]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Replaced images
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_int swig_types[36]
1379 #define SWIGTYPE_p_wxSize swig_types[37]
1380 #define SWIGTYPE_p_wxDC swig_types[38]
1381 #define SWIGTYPE_p_wxPySizer swig_types[39]
1382 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1383 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1384 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1385 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1388 #define SWIGTYPE_p_wxArrayString swig_types[46]
1389 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1390 #define SWIGTYPE_p_wxToolTip swig_types[48]
1391 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1392 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1393 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1394 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1396 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1397 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1398 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1399 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1401 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1402 #define SWIGTYPE_p_long swig_types[60]
1403 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1404 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1405 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1406 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1407 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1409 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1411 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1412 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1413 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1414 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1415 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1416 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1417 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1418 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1419 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1420 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1421 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1422 #define SWIGTYPE_p_wxRect swig_types[80]
1423 #define SWIGTYPE_p_wxButton swig_types[81]
1424 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1425 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1426 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1427 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1428 #define SWIGTYPE_p_char swig_types[86]
1429 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1430 #define SWIGTYPE_p_wxImage swig_types[88]
1431 #define SWIGTYPE_p_wxFrame swig_types[89]
1432 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1434 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1435 #define SWIGTYPE_p_wxPoint swig_types[93]
1436 #define SWIGTYPE_p_wxCursor swig_types[94]
1437 #define SWIGTYPE_p_wxObject swig_types[95]
1438 #define SWIGTYPE_p_wxInputStream swig_types[96]
1439 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1440 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1441 #define SWIGTYPE_p_wxDateTime swig_types[99]
1442 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1443 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1444 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1445 #define SWIGTYPE_p_unsigned_long swig_types[103]
1446 #define SWIGTYPE_p_wxWindow swig_types[104]
1447 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1448 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1449 #define SWIGTYPE_p_wxBitmap swig_types[107]
1450 #define SWIGTYPE_unsigned_int swig_types[108]
1451 #define SWIGTYPE_p_unsigned_int swig_types[109]
1452 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1453 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1454 #define SWIGTYPE_p_unsigned_char swig_types[112]
1455 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1456 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1457 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1458 #define SWIGTYPE_p_wxPyApp swig_types[116]
1459 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1460 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1462 #define SWIGTYPE_p_wxQuantize swig_types[120]
1463 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1464 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1465 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1466 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1467 #define SWIGTYPE_p_wxColour swig_types[125]
1468 #define SWIGTYPE_p_wxValidator swig_types[126]
1469 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1470 static swig_type_info *swig_types[129];
1471
1472 /* -------- TYPES TABLE (END) -------- */
1473
1474
1475 /*-----------------------------------------------
1476 @(target):= _core_.so
1477 ------------------------------------------------*/
1478 #define SWIG_init init_core_
1479
1480 #define SWIG_name "_core_"
1481
1482 #include "wx/wxPython/wxPython_int.h"
1483 #include "wx/wxPython/pyclasses.h"
1484
1485
1486 #ifndef wxPyUSE_EXPORT
1487 // Helper functions for dealing with SWIG objects and such. These are
1488 // located here so they know about the SWIG types and functions declared
1489 // in the wrapper code.
1490
1491 #include <wx/hashmap.h>
1492 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1493
1494
1495 // Maintains a hashmap of className to swig_type_info pointers. Given the
1496 // name of a class either looks up the type info in the cache, or scans the
1497 // SWIG tables for it.
1498 extern PyObject* wxPyPtrTypeMap;
1499 static
1500 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1501
1502 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1503
1504 if (typeInfoCache == NULL)
1505 typeInfoCache = new wxPyTypeInfoHashMap;
1506
1507 wxString name(className);
1508 swig_type_info* swigType = (*typeInfoCache)[name];
1509
1510 if (! swigType) {
1511 // it wasn't in the cache, so look it up from SWIG
1512 name.Append(wxT(" *"));
1513 swigType = SWIG_TypeQuery(name.mb_str());
1514
1515 // if it still wasn't found, try looking for a mapped name
1516 if (!swigType) {
1517 PyObject* item;
1518 name = className;
1519
1520 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1521 (char*)(const char*)name.mbc_str())) != NULL) {
1522 name = wxString(PyString_AsString(item), *wxConvCurrent);
1523 name.Append(wxT(" *"));
1524 swigType = SWIG_TypeQuery(name.mb_str());
1525 }
1526 }
1527 if (swigType) {
1528 // and add it to the map if found
1529 (*typeInfoCache)[className] = swigType;
1530 }
1531 }
1532 return swigType;
1533 }
1534
1535
1536 // Check if a class name is a type known to SWIG
1537 bool wxPyCheckSwigType(const wxChar* className) {
1538
1539 swig_type_info* swigType = wxPyFindSwigType(className);
1540 return swigType != NULL;
1541 }
1542
1543
1544 // Given a pointer to a C++ object and a class name, construct a Python proxy
1545 // object for it.
1546 PyObject* wxPyConstructObject(void* ptr,
1547 const wxChar* className,
1548 int setThisOwn) {
1549
1550 swig_type_info* swigType = wxPyFindSwigType(className);
1551 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1552
1553 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1554 }
1555
1556
1557 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1558 // Ensures that the proxy object is of the specified (or derived) type. If
1559 // not able to perform the conversion then a Python exception is set and the
1560 // error should be handled properly in the caller. Returns True on success.
1561 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1562 const wxChar* className) {
1563
1564 swig_type_info* swigType = wxPyFindSwigType(className);
1565 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1566
1567 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1568 }
1569
1570
1571 // Make a SWIGified pointer object suitable for a .this attribute
1572 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1573
1574 PyObject* robj = NULL;
1575
1576 swig_type_info* swigType = wxPyFindSwigType(className);
1577 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1578
1579 #ifdef SWIG_COBJECT_TYPES
1580 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1581 #else
1582 {
1583 char result[1024];
1584 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1585 PyString_FromString(result) : 0;
1586 }
1587 #endif
1588
1589 return robj;
1590 }
1591
1592
1593
1594
1595 // Export a C API in a struct. Other modules will be able to load this from
1596 // the wx._core_ module and will then have safe access to these functions,
1597 // even if they are located in another shared library.
1598 static wxPyCoreAPI API = {
1599
1600 wxPyCheckSwigType,
1601 wxPyConstructObject,
1602 wxPyConvertSwigPtr,
1603 wxPyMakeSwigPtr,
1604
1605 wxPyBeginAllowThreads,
1606 wxPyEndAllowThreads,
1607 wxPyBeginBlockThreads,
1608 wxPyEndBlockThreads,
1609
1610 wxPy_ConvertList,
1611
1612 wxString_in_helper,
1613 Py2wxString,
1614 wx2PyString,
1615
1616 byte_LIST_helper,
1617 int_LIST_helper,
1618 long_LIST_helper,
1619 string_LIST_helper,
1620 wxPoint_LIST_helper,
1621 wxBitmap_LIST_helper,
1622 wxString_LIST_helper,
1623 wxAcceleratorEntry_LIST_helper,
1624
1625 wxSize_helper,
1626 wxPoint_helper,
1627 wxRealPoint_helper,
1628 wxRect_helper,
1629 wxColour_helper,
1630 wxPoint2D_helper,
1631
1632 wxPySimple_typecheck,
1633 wxColour_typecheck,
1634
1635 wxPyCBH_setCallbackInfo,
1636 wxPyCBH_findCallback,
1637 wxPyCBH_callCallback,
1638 wxPyCBH_callCallbackObj,
1639 wxPyCBH_delete,
1640
1641 wxPyMake_wxObject,
1642 wxPyMake_wxSizer,
1643 wxPyPtrTypeMap_Add,
1644 wxPy2int_seq_helper,
1645 wxPy4int_seq_helper,
1646 wxArrayString2PyList_helper,
1647 wxArrayInt2PyList_helper,
1648
1649 wxPyClientData_dtor,
1650 wxPyUserData_dtor,
1651 wxPyOORClientData_dtor,
1652
1653 wxPyCBInputStream_create,
1654 wxPyCBInputStream_copy,
1655
1656 wxPyInstance_Check,
1657 wxPySwigInstance_Check,
1658
1659 wxPyCheckForApp
1660
1661 };
1662
1663 #endif
1664
1665
1666 #if !WXWIN_COMPATIBILITY_2_4
1667 #define wxHIDE_READONLY 0
1668 #endif
1669
1670
1671 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1672 #define SWIG_From_int PyInt_FromLong
1673 /*@@*/
1674
1675
1676 #if ! wxUSE_HOTKEY
1677 enum wxHotkeyModifier
1678 {
1679 wxMOD_NONE = 0,
1680 wxMOD_ALT = 1,
1681 wxMOD_CONTROL = 2,
1682 wxMOD_SHIFT = 4,
1683 wxMOD_WIN = 8
1684 };
1685 #define wxEVT_HOTKEY 9999
1686 #endif
1687
1688 static const wxString wxPyEmptyString(wxEmptyString);
1689 static wxString wxObject_GetClassName(wxObject *self){
1690 return self->GetClassInfo()->GetClassName();
1691 }
1692 static void wxObject_Destroy(wxObject *self){
1693 delete self;
1694 }
1695
1696 #ifndef __WXMAC__
1697 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1698 #endif
1699
1700
1701 #include <limits.h>
1702
1703
1704 SWIGINTERN int
1705 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1706 const char *errmsg)
1707 {
1708 if (value < min_value) {
1709 if (errmsg) {
1710 PyErr_Format(PyExc_OverflowError,
1711 "value %ld is less than '%s' minimum %ld",
1712 value, errmsg, min_value);
1713 }
1714 return 0;
1715 } else if (value > max_value) {
1716 if (errmsg) {
1717 PyErr_Format(PyExc_OverflowError,
1718 "value %ld is greater than '%s' maximum %ld",
1719 value, errmsg, max_value);
1720 }
1721 return 0;
1722 }
1723 return 1;
1724 }
1725
1726
1727 SWIGINTERN int
1728 SWIG_AsVal_long(PyObject* obj, long* val)
1729 {
1730 if (PyNumber_Check(obj)) {
1731 if (val) *val = PyInt_AsLong(obj);
1732 return 1;
1733 }
1734 else {
1735 SWIG_type_error("number", obj);
1736 }
1737 return 0;
1738 }
1739
1740
1741 #if INT_MAX != LONG_MAX
1742 SWIGINTERN int
1743 SWIG_AsVal_int(PyObject *obj, int *val)
1744 {
1745 const char* errmsg = val ? "int" : (char*)0;
1746 long v;
1747 if (SWIG_AsVal_long(obj, &v)) {
1748 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1749 if (val) *val = (int)(v);
1750 return 1;
1751 } else {
1752 return 0;
1753 }
1754 } else {
1755 PyErr_Clear();
1756 }
1757 if (val) {
1758 SWIG_type_error(errmsg, obj);
1759 }
1760 return 0;
1761 }
1762 #else
1763 SWIGINTERNSHORT int
1764 SWIG_AsVal_int(PyObject *obj, int *val)
1765 {
1766 return SWIG_AsVal_long(obj,(long*)val);
1767 }
1768 #endif
1769
1770
1771 SWIGINTERNSHORT int
1772 SWIG_As_int(PyObject* obj)
1773 {
1774 int v;
1775 if (!SWIG_AsVal_int(obj, &v)) {
1776 /*
1777 this is needed to make valgrind/purify happier.
1778 */
1779 memset((void*)&v, 0, sizeof(int));
1780 }
1781 return v;
1782 }
1783
1784
1785 SWIGINTERNSHORT int
1786 SWIG_Check_int(PyObject* obj)
1787 {
1788 return SWIG_AsVal_int(obj, (int*)0);
1789 }
1790
1791 static PyObject *wxSize_Get(wxSize *self){
1792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1793 PyObject* tup = PyTuple_New(2);
1794 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1795 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1796 wxPyEndBlockThreads(blocked);
1797 return tup;
1798 }
1799
1800 SWIGINTERN int
1801 SWIG_AsVal_double(PyObject *obj, double* val)
1802 {
1803 if (PyNumber_Check(obj)) {
1804 if (val) *val = PyFloat_AsDouble(obj);
1805 return 1;
1806 }
1807 else {
1808 SWIG_type_error("number", obj);
1809 }
1810 return 0;
1811 }
1812
1813
1814 SWIGINTERNSHORT double
1815 SWIG_As_double(PyObject* obj)
1816 {
1817 double v;
1818 if (!SWIG_AsVal_double(obj, &v)) {
1819 /*
1820 this is needed to make valgrind/purify happier.
1821 */
1822 memset((void*)&v, 0, sizeof(double));
1823 }
1824 return v;
1825 }
1826
1827
1828 SWIGINTERNSHORT int
1829 SWIG_Check_double(PyObject* obj)
1830 {
1831 return SWIG_AsVal_double(obj, (double*)0);
1832 }
1833
1834
1835 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1836 #define SWIG_From_double PyFloat_FromDouble
1837 /*@@*/
1838
1839 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1840 self->x = x;
1841 self->y = y;
1842 }
1843 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 PyObject* tup = PyTuple_New(2);
1846 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1847 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1848 wxPyEndBlockThreads(blocked);
1849 return tup;
1850 }
1851
1852 SWIGINTERNSHORT long
1853 SWIG_As_long(PyObject* obj)
1854 {
1855 long v;
1856 if (!SWIG_AsVal_long(obj, &v)) {
1857 /*
1858 this is needed to make valgrind/purify happier.
1859 */
1860 memset((void*)&v, 0, sizeof(long));
1861 }
1862 return v;
1863 }
1864
1865
1866 SWIGINTERNSHORT int
1867 SWIG_Check_long(PyObject* obj)
1868 {
1869 return SWIG_AsVal_long(obj, (long*)0);
1870 }
1871
1872 static void wxPoint_Set(wxPoint *self,long x,long y){
1873 self->x = x;
1874 self->y = y;
1875 }
1876 static PyObject *wxPoint_Get(wxPoint *self){
1877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1878 PyObject* tup = PyTuple_New(2);
1879 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1880 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1881 wxPyEndBlockThreads(blocked);
1882 return tup;
1883 }
1884 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1885 self->x = x;
1886 self->y = y;
1887 self->width = width;
1888 self->height = height;
1889 }
1890 static PyObject *wxRect_Get(wxRect *self){
1891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1892 PyObject* tup = PyTuple_New(4);
1893 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1894 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1895 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1896 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1897 wxPyEndBlockThreads(blocked);
1898 return tup;
1899 }
1900
1901 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1902 wxRegion reg1(*r1);
1903 wxRegion reg2(*r2);
1904 wxRect dest(0,0,0,0);
1905 PyObject* obj;
1906
1907 reg1.Intersect(reg2);
1908 dest = reg1.GetBox();
1909
1910 if (dest != wxRect(0,0,0,0)) {
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1912 wxRect* newRect = new wxRect(dest);
1913 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1914 wxPyEndBlockThreads(blocked);
1915 return obj;
1916 }
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920
1921
1922 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1923 PyObject* o2;
1924 PyObject* o3;
1925
1926 if (!target) {
1927 target = o;
1928 } else if (target == Py_None) {
1929 Py_DECREF(Py_None);
1930 target = o;
1931 } else {
1932 if (!PyTuple_Check(target)) {
1933 o2 = target;
1934 target = PyTuple_New(1);
1935 PyTuple_SetItem(target, 0, o2);
1936 }
1937 o3 = PyTuple_New(1);
1938 PyTuple_SetItem(o3, 0, o);
1939
1940 o2 = target;
1941 target = PySequence_Concat(o2, o3);
1942 Py_DECREF(o2);
1943 Py_DECREF(o3);
1944 }
1945 return target;
1946 }
1947
1948
1949 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1950 self->m_x = x;
1951 self->m_y = y;
1952 }
1953 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1954 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1955 PyObject* tup = PyTuple_New(2);
1956 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1957 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1958 wxPyEndBlockThreads(blocked);
1959 return tup;
1960 }
1961
1962 #include "wx/wxPython/pyistream.h"
1963
1964 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1965 wxInputStream* wxis = wxPyCBInputStream::create(p);
1966 if (wxis)
1967 return new wxPyInputStream(wxis);
1968 else
1969 return NULL;
1970 }
1971
1972 SWIGINTERNSHORT PyObject*
1973 SWIG_From_char(char c)
1974 {
1975 return PyString_FromStringAndSize(&c,1);
1976 }
1977
1978
1979 SWIGINTERNSHORT PyObject*
1980 SWIG_From_unsigned_SS_long(unsigned long value)
1981 {
1982 return (value > LONG_MAX) ?
1983 PyLong_FromUnsignedLong(value)
1984 : PyInt_FromLong((long)(value));
1985 }
1986
1987
1988 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1989 SWIGINTERN int
1990 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1991 {
1992 static swig_type_info* pchar_info = 0;
1993 char* vptr = 0;
1994 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1995 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1996 if (cptr) *cptr = vptr;
1997 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1998 return SWIG_OLDOBJ;
1999 } else {
2000 PyErr_Clear();
2001 if (PyString_Check(obj)) {
2002 if (cptr) {
2003 *cptr = PyString_AS_STRING(obj);
2004 if (psize) {
2005 *psize = PyString_GET_SIZE(obj) + 1;
2006 }
2007 }
2008 return SWIG_PYSTR;
2009 }
2010 }
2011 if (cptr) {
2012 SWIG_type_error("char *", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERN int
2019 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2020 {
2021 char* cptr; size_t csize;
2022 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2023 /* in C you can do:
2024
2025 char x[5] = "hello";
2026
2027 ie, assing the array using an extra '0' char.
2028 */
2029 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2030 if (csize <= size) {
2031 if (val) {
2032 if (csize) memcpy(val, cptr, csize);
2033 if (csize < size) memset(val + csize, 0, size - csize);
2034 }
2035 return 1;
2036 }
2037 }
2038 if (val) {
2039 PyErr_Format(PyExc_TypeError,
2040 "a char array of maximum size %lu is expected",
2041 (unsigned long) size);
2042 }
2043 return 0;
2044 }
2045
2046
2047 SWIGINTERN int
2048 SWIG_AsVal_char(PyObject *obj, char *val)
2049 {
2050 const char* errmsg = val ? "char" : (char*)0;
2051 long v;
2052 if (SWIG_AsVal_long(obj, &v)) {
2053 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2054 if (val) *val = (char)(v);
2055 return 1;
2056 } else {
2057 return 0;
2058 }
2059 } else {
2060 PyErr_Clear();
2061 return SWIG_AsCharArray(obj, val, 1);
2062 }
2063 }
2064
2065
2066 SWIGINTERNSHORT char
2067 SWIG_As_char(PyObject* obj)
2068 {
2069 char v;
2070 if (!SWIG_AsVal_char(obj, &v)) {
2071 /*
2072 this is needed to make valgrind/purify happier.
2073 */
2074 memset((void*)&v, 0, sizeof(char));
2075 }
2076 return v;
2077 }
2078
2079
2080 SWIGINTERNSHORT int
2081 SWIG_Check_char(PyObject* obj)
2082 {
2083 return SWIG_AsVal_char(obj, (char*)0);
2084 }
2085
2086
2087 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2088 #define SWIG_From_long PyInt_FromLong
2089 /*@@*/
2090
2091 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2092 // We use only strings for the streams, not unicode
2093 PyObject* str = PyObject_Str(obj);
2094 if (! str) {
2095 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2096 return;
2097 }
2098 self->Write(PyString_AS_STRING(str),
2099 PyString_GET_SIZE(str));
2100 Py_DECREF(str);
2101 }
2102
2103 #include "wx/wxPython/pyistream.h"
2104
2105
2106 class wxPyFileSystemHandler : public wxFileSystemHandler
2107 {
2108 public:
2109 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2110
2111 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2112 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2113 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2114 DEC_PYCALLBACK_STRING__pure(FindNext);
2115
2116 wxString GetProtocol(const wxString& location) {
2117 return wxFileSystemHandler::GetProtocol(location);
2118 }
2119
2120 wxString GetLeftLocation(const wxString& location) {
2121 return wxFileSystemHandler::GetLeftLocation(location);
2122 }
2123
2124 wxString GetAnchor(const wxString& location) {
2125 return wxFileSystemHandler::GetAnchor(location);
2126 }
2127
2128 wxString GetRightLocation(const wxString& location) {
2129 return wxFileSystemHandler::GetRightLocation(location);
2130 }
2131
2132 wxString GetMimeTypeFromExt(const wxString& location) {
2133 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2134 }
2135
2136 PYPRIVATE;
2137 };
2138
2139
2140 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2141 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2142 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2143 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2144
2145
2146 SWIGINTERN int
2147 SWIG_AsVal_bool(PyObject *obj, bool *val)
2148 {
2149 if (obj == Py_True) {
2150 if (val) *val = true;
2151 return 1;
2152 }
2153 if (obj == Py_False) {
2154 if (val) *val = false;
2155 return 1;
2156 }
2157 int res = 0;
2158 if (SWIG_AsVal_int(obj, &res)) {
2159 if (val) *val = res ? true : false;
2160 return 1;
2161 } else {
2162 PyErr_Clear();
2163 }
2164 if (val) {
2165 SWIG_type_error("bool", obj);
2166 }
2167 return 0;
2168 }
2169
2170
2171 SWIGINTERNSHORT bool
2172 SWIG_As_bool(PyObject* obj)
2173 {
2174 bool v;
2175 if (!SWIG_AsVal_bool(obj, &v)) {
2176 /*
2177 this is needed to make valgrind/purify happier.
2178 */
2179 memset((void*)&v, 0, sizeof(bool));
2180 }
2181 return v;
2182 }
2183
2184
2185 SWIGINTERNSHORT int
2186 SWIG_Check_bool(PyObject* obj)
2187 {
2188 return SWIG_AsVal_bool(obj, (bool*)0);
2189 }
2190
2191 static wxString FileSystem_URLToFileName(wxString const &url){
2192 wxFileName fname = wxFileSystem::URLToFileName(url);
2193 return fname.GetFullPath();
2194 }
2195
2196 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2197 wxImage& image,
2198 long type) {
2199 wxMemoryFSHandler::AddFile(filename, image, type);
2200 }
2201
2202 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2203 const wxBitmap& bitmap,
2204 long type) {
2205 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2206 }
2207
2208 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2209 PyObject* data) {
2210 if (! PyString_Check(data)) {
2211 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2212 "Expected string object"));
2213 return;
2214 }
2215
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 void* ptr = (void*)PyString_AsString(data);
2218 size_t size = PyString_Size(data);
2219 wxPyEndBlockThreads(blocked);
2220
2221 wxMemoryFSHandler::AddFile(filename, ptr, size);
2222 }
2223
2224
2225 #include "wx/wxPython/pyistream.h"
2226
2227
2228 SWIGINTERN int
2229 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2230 {
2231 long v = 0;
2232 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2233 SWIG_type_error("unsigned number", obj);
2234 }
2235 else if (val)
2236 *val = (unsigned long)v;
2237 return 1;
2238 }
2239
2240
2241 SWIGINTERNSHORT int
2242 SWIG_CheckUnsignedLongInRange(unsigned long value,
2243 unsigned long max_value,
2244 const char *errmsg)
2245 {
2246 if (value > max_value) {
2247 if (errmsg) {
2248 PyErr_Format(PyExc_OverflowError,
2249 "value %lu is greater than '%s' minimum %lu",
2250 value, errmsg, max_value);
2251 }
2252 return 0;
2253 }
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERN int
2259 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2260 {
2261 const char* errmsg = val ? "unsigned char" : (char*)0;
2262 unsigned long v;
2263 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2264 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2265 if (val) *val = (unsigned char)(v);
2266 return 1;
2267 } else {
2268 return 0;
2269 }
2270 } else {
2271 PyErr_Clear();
2272 }
2273 if (val) {
2274 SWIG_type_error(errmsg, obj);
2275 }
2276 return 0;
2277 }
2278
2279
2280 SWIGINTERNSHORT unsigned char
2281 SWIG_As_unsigned_SS_char(PyObject* obj)
2282 {
2283 unsigned char v;
2284 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2285 /*
2286 this is needed to make valgrind/purify happier.
2287 */
2288 memset((void*)&v, 0, sizeof(unsigned char));
2289 }
2290 return v;
2291 }
2292
2293
2294 SWIGINTERNSHORT int
2295 SWIG_Check_unsigned_SS_char(PyObject* obj)
2296 {
2297 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2298 }
2299
2300
2301 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2302 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2303 /*@@*/
2304
2305
2306
2307 SWIGINTERNSHORT unsigned long
2308 SWIG_As_unsigned_SS_long(PyObject* obj)
2309 {
2310 unsigned long v;
2311 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2312 /*
2313 this is needed to make valgrind/purify happier.
2314 */
2315 memset((void*)&v, 0, sizeof(unsigned long));
2316 }
2317 return v;
2318 }
2319
2320
2321 SWIGINTERNSHORT int
2322 SWIG_Check_unsigned_SS_long(PyObject* obj)
2323 {
2324 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2325 }
2326
2327 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2328 wxImageHistogramEntry e = (*self)[key];
2329 return e.value;
2330 }
2331 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2332 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2333 wxImageHistogramEntry e = (*self)[key];
2334 return e.value;
2335 }
2336 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2337 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2338 colour.Green(),
2339 colour.Blue());
2340 wxImageHistogramEntry e = (*self)[key];
2341 return e.value;
2342 }
2343
2344 typedef unsigned char* buffer;
2345
2346 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2347 if (width > 0 && height > 0)
2348 return new wxImage(width, height, clear);
2349 else
2350 return new wxImage;
2351 }
2352 static wxImage *new_wxImage(wxBitmap const &bitmap){
2353 return new wxImage(bitmap.ConvertToImage());
2354 }
2355 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2356 if (DATASIZE != width*height*3) {
2357 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2358 return NULL;
2359 }
2360
2361 // Copy the source data so the wxImage can clean it up later
2362 buffer copy = (buffer)malloc(DATASIZE);
2363 if (copy == NULL) {
2364 wxPyBLOCK_THREADS(PyErr_NoMemory());
2365 return NULL;
2366 }
2367 memcpy(copy, data, DATASIZE);
2368 return new wxImage(width, height, copy, false);
2369 }
2370 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2371 if (DATASIZE != width*height*3) {
2372 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2373 return NULL;
2374 }
2375 if (ALPHASIZE != width*height) {
2376 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2377 return NULL;
2378 }
2379
2380 // Copy the source data so the wxImage can clean it up later
2381 buffer dcopy = (buffer)malloc(DATASIZE);
2382 if (dcopy == NULL) {
2383 wxPyBLOCK_THREADS(PyErr_NoMemory());
2384 return NULL;
2385 }
2386 memcpy(dcopy, data, DATASIZE);
2387
2388 buffer acopy = (buffer)malloc(ALPHASIZE);
2389 if (acopy == NULL) {
2390 wxPyBLOCK_THREADS(PyErr_NoMemory());
2391 return NULL;
2392 }
2393 memcpy(acopy, alpha, ALPHASIZE);
2394
2395 return new wxImage(width, height, dcopy, acopy, false);
2396 }
2397 static wxSize wxImage_GetSize(wxImage *self){
2398 wxSize size(self->GetWidth(), self->GetHeight());
2399 return size;
2400 }
2401 static PyObject *wxImage_GetData(wxImage *self){
2402 buffer data = self->GetData();
2403 int len = self->GetWidth() * self->GetHeight() * 3;
2404 PyObject* rv;
2405 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2406 return rv;
2407 }
2408 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2409 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2410 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2411 return;
2412 }
2413 buffer copy = (buffer)malloc(DATASIZE);
2414 if (copy == NULL) {
2415 wxPyBLOCK_THREADS(PyErr_NoMemory());
2416 return;
2417 }
2418 memcpy(copy, data, DATASIZE);
2419 self->SetData(copy, false);
2420 // wxImage takes ownership of copy...
2421 }
2422 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2423 buffer data = self->GetData();
2424 int len = self->GetWidth() * self->GetHeight() * 3;
2425 PyObject* rv;
2426 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2427 return rv;
2428 }
2429 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2430 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2431 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2432 return;
2433 }
2434 self->SetData(data, true);
2435 }
2436 static PyObject *wxImage_GetAlphaData(wxImage *self){
2437 buffer data = self->GetAlpha();
2438 if (! data) {
2439 RETURN_NONE();
2440 } else {
2441 int len = self->GetWidth() * self->GetHeight();
2442 PyObject* rv;
2443 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2444 return rv;
2445 }
2446 }
2447 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2448 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2449 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2450 return;
2451 }
2452 buffer acopy = (buffer)malloc(ALPHASIZE);
2453 if (acopy == NULL) {
2454 wxPyBLOCK_THREADS(PyErr_NoMemory());
2455 return;
2456 }
2457 memcpy(acopy, alpha, ALPHASIZE);
2458 self->SetAlpha(acopy, false);
2459 // wxImage takes ownership of acopy...
2460 }
2461 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2462 buffer data = self->GetAlpha();
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2466 return rv;
2467 }
2468 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2469 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2470 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2471 return;
2472 }
2473 self->SetAlpha(alpha, true);
2474 }
2475 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2476 wxBitmap bitmap(*self, depth);
2477 return bitmap;
2478 }
2479 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2480 wxImage mono = self->ConvertToMono( red, green, blue );
2481 wxBitmap bitmap( mono, 1 );
2482 return bitmap;
2483 }
2484 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2485 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2487 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2491 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2492 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2493 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2494 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2495 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2496 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2497 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2498 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2499
2500 #include <wx/quantize.h>
2501
2502 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2503 return wxQuantize::Quantize(src, dest,
2504 //NULL, // palette
2505 desiredNoColours,
2506 NULL, // eightBitData
2507 flags);
2508 }
2509 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2510 if (PyCallable_Check(func)) {
2511 self->Connect(id, lastId, eventType,
2512 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2513 new wxPyCallback(func));
2514 }
2515 else if (func == Py_None) {
2516 self->Disconnect(id, lastId, eventType,
2517 (wxObjectEventFunction)
2518 &wxPyCallback::EventThunker);
2519 }
2520 else {
2521 wxPyBLOCK_THREADS(
2522 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2523 }
2524 }
2525 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2526 return self->Disconnect(id, lastId, eventType,
2527 (wxObjectEventFunction)
2528 &wxPyCallback::EventThunker);
2529 }
2530 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2531 if (_self && _self != Py_None) {
2532 self->SetClientObject(new wxPyOORClientData(_self, incref));
2533 }
2534 else {
2535 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2536 if (data) {
2537 self->SetClientObject(NULL); // This will delete it too
2538 }
2539 }
2540 }
2541
2542 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2543 #if wxUSE_UNICODE
2544 return self->GetUnicodeKey();
2545 #else
2546 return 0;
2547 #endif
2548 }
2549
2550 #if UINT_MAX < LONG_MAX
2551 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2552 #define SWIG_From_unsigned_SS_int SWIG_From_long
2553 /*@@*/
2554 #else
2555 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2556 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2557 /*@@*/
2558 #endif
2559
2560
2561 #if UINT_MAX != ULONG_MAX
2562 SWIGINTERN int
2563 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2564 {
2565 const char* errmsg = val ? "unsigned int" : (char*)0;
2566 unsigned long v;
2567 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2568 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2569 if (val) *val = (unsigned int)(v);
2570 return 1;
2571 }
2572 } else {
2573 PyErr_Clear();
2574 }
2575 if (val) {
2576 SWIG_type_error(errmsg, obj);
2577 }
2578 return 0;
2579 }
2580 #else
2581 SWIGINTERNSHORT unsigned int
2582 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2583 {
2584 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2585 }
2586 #endif
2587
2588
2589 SWIGINTERNSHORT unsigned int
2590 SWIG_As_unsigned_SS_int(PyObject* obj)
2591 {
2592 unsigned int v;
2593 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2594 /*
2595 this is needed to make valgrind/purify happier.
2596 */
2597 memset((void*)&v, 0, sizeof(unsigned int));
2598 }
2599 return v;
2600 }
2601
2602
2603 SWIGINTERNSHORT int
2604 SWIG_Check_unsigned_SS_int(PyObject* obj)
2605 {
2606 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2607 }
2608
2609 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2610 self->m_size = size;
2611 }
2612 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2613 int count = self->GetNumberOfFiles();
2614 wxString* files = self->GetFiles();
2615 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2616 PyObject* list = PyList_New(count);
2617
2618 if (!list) {
2619 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2620 wxPyEndBlockThreads(blocked);
2621 return NULL;
2622 }
2623
2624 for (int i=0; i<count; i++) {
2625 PyList_SetItem(list, i, wx2PyString(files[i]));
2626 }
2627 wxPyEndBlockThreads(blocked);
2628 return list;
2629 }
2630
2631
2632 static wxPyApp *new_wxPyApp(){
2633 wxPythonApp = new wxPyApp();
2634 return wxPythonApp;
2635 }
2636
2637 void wxApp_CleanUp() {
2638 __wxPyCleanup();
2639 }
2640
2641
2642 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2643
2644
2645 SWIGINTERNSHORT int
2646 SWIG_AsCharPtr(PyObject *obj, char **val)
2647 {
2648 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2649 return 1;
2650 }
2651 if (val) {
2652 PyErr_Clear();
2653 SWIG_type_error("char *", obj);
2654 }
2655 return 0;
2656 }
2657
2658
2659 SWIGINTERN PyObject *
2660 SWIG_FromCharPtr(const char* cptr)
2661 {
2662 if (cptr) {
2663 size_t size = strlen(cptr);
2664 if (size > INT_MAX) {
2665 return SWIG_NewPointerObj((char*)(cptr),
2666 SWIG_TypeQuery("char *"), 0);
2667 } else {
2668 if (size != 0) {
2669 return PyString_FromStringAndSize(cptr, size);
2670 } else {
2671 return PyString_FromString(cptr);
2672 }
2673 }
2674 }
2675 Py_INCREF(Py_None);
2676 return Py_None;
2677 }
2678
2679
2680 #ifdef __WXMAC__
2681
2682 // A dummy class that raises an exception if used...
2683 class wxEventLoop
2684 {
2685 public:
2686 wxEventLoop() { wxPyRaiseNotImplemented(); }
2687 int Run() { return 0; }
2688 void Exit(int rc = 0) {}
2689 bool Pending() const { return false; }
2690 bool Dispatch() { return false; }
2691 bool IsRunning() const { return false; }
2692 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2693 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2694 };
2695
2696 #else
2697
2698 #include <wx/evtloop.h>
2699
2700 #endif
2701
2702
2703
2704 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2705 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2706 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2707 static PyObject *wxWindow_GetChildren(wxWindow *self){
2708 wxWindowList& list = self->GetChildren();
2709 return wxPy_ConvertList(&list);
2710 }
2711 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2712 #if wxUSE_HOTKEY
2713 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2714 #else
2715 return false;
2716 #endif
2717 }
2718 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2719
2720
2721
2722 return false;
2723
2724 }
2725 static long wxWindow_GetHandle(wxWindow *self){
2726 return wxPyGetWinHandle(self);
2727 }
2728 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2729 self->AssociateHandle((WXWidget)handle);
2730 }
2731
2732 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2733 return wxWindow::FindWindowById(id, parent);
2734 }
2735
2736 wxWindow* wxFindWindowByName( const wxString& name,
2737 const wxWindow *parent = NULL ) {
2738 return wxWindow::FindWindowByName(name, parent);
2739 }
2740
2741 wxWindow* wxFindWindowByLabel( const wxString& label,
2742 const wxWindow *parent = NULL ) {
2743 return wxWindow::FindWindowByLabel(label, parent);
2744 }
2745
2746
2747 #ifdef __WXMSW__
2748 #include <wx/msw/private.h> // to get wxGetWindowId
2749 #endif
2750
2751
2752 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2753 #ifdef __WXMSW__
2754 WXHWND hWnd = (WXHWND)_hWnd;
2755 long id = wxGetWindowId(hWnd);
2756 wxWindow* win = new wxWindow;
2757 parent->AddChild(win);
2758 win->SetEventHandler(win);
2759 win->SetHWND(hWnd);
2760 win->SetId(id);
2761 win->SubclassWin(hWnd);
2762 win->AdoptAttributesFromHWND();
2763 win->SetupColours();
2764 return win;
2765 #else
2766 wxPyRaiseNotImplemented();
2767 return NULL;
2768 #endif
2769 }
2770
2771
2772 PyObject* GetTopLevelWindows() {
2773 return wxPy_ConvertList(&wxTopLevelWindows);
2774 }
2775
2776
2777 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2778 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2779 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2780
2781 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2782
2783 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2784 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2785 wxMenuItemList& list = self->GetMenuItems();
2786 return wxPy_ConvertList(&list);
2787 }
2788 static const wxString wxPyControlNameStr(wxControlNameStr);
2789 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2790 if (clientData) {
2791 wxPyClientData* data = new wxPyClientData(clientData);
2792 return self->Append(item, data);
2793 } else
2794 return self->Append(item);
2795 }
2796 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2797 if (clientData) {
2798 wxPyClientData* data = new wxPyClientData(clientData);
2799 return self->Insert(item, pos, data);
2800 } else
2801 return self->Insert(item, pos);
2802 }
2803 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2804 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2805 if (data) {
2806 Py_INCREF(data->m_obj);
2807 return data->m_obj;
2808 } else {
2809 Py_INCREF(Py_None);
2810 return Py_None;
2811 }
2812 }
2813 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2814 wxPyClientData* data = new wxPyClientData(clientData);
2815 self->SetClientObject(n, data);
2816 }
2817
2818
2819 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2820 wxPyUserData* data = NULL;
2821 if ( userData ) {
2822 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2823 data = new wxPyUserData(userData);
2824 wxPyEndBlockThreads(blocked);
2825 }
2826 return new wxSizerItem(window, proportion, flag, border, data);
2827 }
2828 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2829 wxPyUserData* data = NULL;
2830 if ( userData ) {
2831 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2832 data = new wxPyUserData(userData);
2833 wxPyEndBlockThreads(blocked);
2834 }
2835 return new wxSizerItem(width, height, proportion, flag, border, data);
2836 }
2837 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2838 wxPyUserData* data = NULL;
2839 if ( userData ) {
2840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2841 data = new wxPyUserData(userData);
2842 wxPyEndBlockThreads(blocked);
2843 }
2844 return new wxSizerItem(sizer, proportion, flag, border, data);
2845 }
2846
2847 #include <float.h>
2848 SWIGINTERN int
2849 SWIG_CheckDoubleInRange(double value, double min_value,
2850 double max_value, const char* errmsg)
2851 {
2852 if (value < min_value) {
2853 if (errmsg) {
2854 PyErr_Format(PyExc_OverflowError,
2855 "value %g is less than %s minimum %g",
2856 value, errmsg, min_value);
2857 }
2858 return 0;
2859 } else if (value > max_value) {
2860 if (errmsg) {
2861 PyErr_Format(PyExc_OverflowError,
2862 "value %g is greater than %s maximum %g",
2863 value, errmsg, max_value);
2864 }
2865 return 0;
2866 }
2867 return 1;
2868 }
2869
2870
2871 SWIGINTERN int
2872 SWIG_AsVal_float(PyObject *obj, float *val)
2873 {
2874 const char* errmsg = val ? "float" : (char*)0;
2875 double v;
2876 if (SWIG_AsVal_double(obj, &v)) {
2877 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2878 if (val) *val = (float)(v);
2879 return 1;
2880 } else {
2881 return 0;
2882 }
2883 } else {
2884 PyErr_Clear();
2885 }
2886 if (val) {
2887 SWIG_type_error(errmsg, obj);
2888 }
2889 return 0;
2890 }
2891
2892
2893 SWIGINTERNSHORT float
2894 SWIG_As_float(PyObject* obj)
2895 {
2896 float v;
2897 if (!SWIG_AsVal_float(obj, &v)) {
2898 /*
2899 this is needed to make valgrind/purify happier.
2900 */
2901 memset((void*)&v, 0, sizeof(float));
2902 }
2903 return v;
2904 }
2905
2906
2907 SWIGINTERNSHORT int
2908 SWIG_Check_float(PyObject* obj)
2909 {
2910 return SWIG_AsVal_float(obj, (float*)0);
2911 }
2912
2913
2914 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2915 #define SWIG_From_float PyFloat_FromDouble
2916 /*@@*/
2917
2918 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2919 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2920 if (data) {
2921 Py_INCREF(data->m_obj);
2922 return data->m_obj;
2923 } else {
2924 Py_INCREF(Py_None);
2925 return Py_None;
2926 }
2927 }
2928
2929 // Figure out the type of the sizer item
2930
2931 struct wxPySizerItemInfo {
2932 wxPySizerItemInfo()
2933 : window(NULL), sizer(NULL), gotSize(false),
2934 size(wxDefaultSize), gotPos(false), pos(-1)
2935 {}
2936
2937 wxWindow* window;
2938 wxSizer* sizer;
2939 bool gotSize;
2940 wxSize size;
2941 bool gotPos;
2942 int pos;
2943 };
2944
2945 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2946
2947 wxPySizerItemInfo info;
2948 wxSize size;
2949 wxSize* sizePtr = &size;
2950
2951 // Find out what the type of the item is
2952 // try wxWindow
2953 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2954 PyErr_Clear();
2955 info.window = NULL;
2956
2957 // try wxSizer
2958 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2959 PyErr_Clear();
2960 info.sizer = NULL;
2961
2962 // try wxSize or (w,h)
2963 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2964 info.size = *sizePtr;
2965 info.gotSize = true;
2966 }
2967
2968 // or a single int
2969 if (checkIdx && PyInt_Check(item)) {
2970 info.pos = PyInt_AsLong(item);
2971 info.gotPos = true;
2972 }
2973 }
2974 }
2975
2976 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2977 // no expected type, figure out what kind of error message to generate
2978 if ( !checkSize && !checkIdx )
2979 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2980 else if ( checkSize && !checkIdx )
2981 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2982 else if ( !checkSize && checkIdx)
2983 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2984 else
2985 // can this one happen?
2986 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2987 }
2988
2989 return info;
2990 }
2991
2992 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2993 if (!self->GetClientObject())
2994 self->SetClientObject(new wxPyOORClientData(_self));
2995 }
2996 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2997
2998 wxPyUserData* data = NULL;
2999 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3000 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3001 if ( userData && (info.window || info.sizer || info.gotSize) )
3002 data = new wxPyUserData(userData);
3003 wxPyEndBlockThreads(blocked);
3004
3005 // Now call the real Add method if a valid item type was found
3006 if ( info.window )
3007 return self->Add(info.window, proportion, flag, border, data);
3008 else if ( info.sizer )
3009 return self->Add(info.sizer, proportion, flag, border, data);
3010 else if (info.gotSize)
3011 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3012 proportion, flag, border, data);
3013 else
3014 return NULL;
3015 }
3016 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3017
3018 wxPyUserData* data = NULL;
3019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3021 if ( userData && (info.window || info.sizer || info.gotSize) )
3022 data = new wxPyUserData(userData);
3023 wxPyEndBlockThreads(blocked);
3024
3025 // Now call the real Insert method if a valid item type was found
3026 if ( info.window )
3027 return self->Insert(before, info.window, proportion, flag, border, data);
3028 else if ( info.sizer )
3029 return self->Insert(before, info.sizer, proportion, flag, border, data);
3030 else if (info.gotSize)
3031 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3032 proportion, flag, border, data);
3033 else
3034 return NULL;
3035 }
3036 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3037
3038 wxPyUserData* data = NULL;
3039 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3040 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3041 if ( userData && (info.window || info.sizer || info.gotSize) )
3042 data = new wxPyUserData(userData);
3043 wxPyEndBlockThreads(blocked);
3044
3045 // Now call the real Prepend method if a valid item type was found
3046 if ( info.window )
3047 return self->Prepend(info.window, proportion, flag, border, data);
3048 else if ( info.sizer )
3049 return self->Prepend(info.sizer, proportion, flag, border, data);
3050 else if (info.gotSize)
3051 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3052 proportion, flag, border, data);
3053 else
3054 return NULL;
3055 }
3056 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3059 wxPyEndBlockThreads(blocked);
3060 if ( info.window )
3061 return self->Remove(info.window);
3062 else if ( info.sizer )
3063 return self->Remove(info.sizer);
3064 else if ( info.gotPos )
3065 return self->Remove(info.pos);
3066 else
3067 return false;
3068 }
3069 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3072 wxPyEndBlockThreads(blocked);
3073 if ( info.window )
3074 return self->Detach(info.window);
3075 else if ( info.sizer )
3076 return self->Detach(info.sizer);
3077 else if ( info.gotPos )
3078 return self->Detach(info.pos);
3079 else
3080 return false;
3081 }
3082 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3085 wxPyEndBlockThreads(blocked);
3086 if ( info.window )
3087 return self->GetItem(info.window);
3088 else if ( info.sizer )
3089 return self->GetItem(info.sizer);
3090 else if ( info.gotPos )
3091 return self->GetItem(info.pos);
3092 else
3093 return NULL;
3094 }
3095 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3096 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3098 wxPyEndBlockThreads(blocked);
3099 if ( info.window )
3100 self->SetItemMinSize(info.window, size);
3101 else if ( info.sizer )
3102 self->SetItemMinSize(info.sizer, size);
3103 else if ( info.gotPos )
3104 self->SetItemMinSize(info.pos, size);
3105 }
3106 static PyObject *wxSizer_GetChildren(wxSizer *self){
3107 wxSizerItemList& list = self->GetChildren();
3108 return wxPy_ConvertList(&list);
3109 }
3110 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3111 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3112 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3113 wxPyEndBlockThreads(blocked);
3114 if ( info.window )
3115 return self->Show(info.window, show, recursive);
3116 else if ( info.sizer )
3117 return self->Show(info.sizer, show, recursive);
3118 else if ( info.gotPos )
3119 return self->Show(info.pos, show);
3120 else
3121 return false;
3122 }
3123 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3124 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3125 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3126 wxPyEndBlockThreads(blocked);
3127 if ( info.window )
3128 return self->IsShown(info.window);
3129 else if ( info.sizer )
3130 return self->IsShown(info.sizer);
3131 else if ( info.gotPos )
3132 return self->IsShown(info.pos);
3133 else
3134 return false;
3135 }
3136
3137 // See pyclasses.h
3138 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3139 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3140 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3141
3142
3143
3144
3145 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3146 {
3147 if (source == Py_None) {
3148 **obj = wxGBPosition(-1,-1);
3149 return true;
3150 }
3151 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3152 }
3153
3154 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3155 {
3156 if (source == Py_None) {
3157 **obj = wxGBSpan(-1,-1);
3158 return true;
3159 }
3160 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3161 }
3162
3163
3164 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3165 self->SetRow(row);
3166 self->SetCol(col);
3167 }
3168 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3170 PyObject* tup = PyTuple_New(2);
3171 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3172 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3173 wxPyEndBlockThreads(blocked);
3174 return tup;
3175 }
3176 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3177 self->SetRowspan(rowspan);
3178 self->SetColspan(colspan);
3179 }
3180 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3182 PyObject* tup = PyTuple_New(2);
3183 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3184 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3185 wxPyEndBlockThreads(blocked);
3186 return tup;
3187 }
3188 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3189 wxPyUserData* data = NULL;
3190 if ( userData ) {
3191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3192 data = new wxPyUserData(userData);
3193 wxPyEndBlockThreads(blocked);
3194 }
3195 return new wxGBSizerItem(window, pos, span, flag, border, data);
3196 }
3197 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3198 wxPyUserData* data = NULL;
3199 if ( userData ) {
3200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 data = new wxPyUserData(userData);
3202 wxPyEndBlockThreads(blocked);
3203 }
3204 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3205 }
3206 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3207 wxPyUserData* data = NULL;
3208 if ( userData ) {
3209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3210 data = new wxPyUserData(userData);
3211 wxPyEndBlockThreads(blocked);
3212 }
3213 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3214 }
3215 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3216 int row, col;
3217 self->GetEndPos(row, col);
3218 return wxGBPosition(row, col);
3219 }
3220 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3221
3222 wxPyUserData* data = NULL;
3223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3224 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3225 if ( userData && (info.window || info.sizer || info.gotSize) )
3226 data = new wxPyUserData(userData);
3227 wxPyEndBlockThreads(blocked);
3228
3229 // Now call the real Add method if a valid item type was found
3230 if ( info.window )
3231 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3232 else if ( info.sizer )
3233 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3234 else if (info.gotSize)
3235 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3236 pos, span, flag, border, data);
3237 return NULL;
3238 }
3239
3240
3241 #ifdef __cplusplus
3242 extern "C" {
3243 #endif
3244 static int _wrap_EmptyString_set(PyObject *) {
3245 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3246 return 1;
3247 }
3248
3249
3250 static PyObject *_wrap_EmptyString_get(void) {
3251 PyObject *pyobj;
3252
3253 {
3254 #if wxUSE_UNICODE
3255 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3256 #else
3257 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3258 #endif
3259 }
3260 return pyobj;
3261 }
3262
3263
3264 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3265 PyObject *resultobj;
3266 wxObject *arg1 = (wxObject *) 0 ;
3267 wxString result;
3268 PyObject * obj0 = 0 ;
3269 char *kwnames[] = {
3270 (char *) "self", NULL
3271 };
3272
3273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3275 if (SWIG_arg_fail(1)) SWIG_fail;
3276 {
3277 PyThreadState* __tstate = wxPyBeginAllowThreads();
3278 result = wxObject_GetClassName(arg1);
3279
3280 wxPyEndAllowThreads(__tstate);
3281 if (PyErr_Occurred()) SWIG_fail;
3282 }
3283 {
3284 #if wxUSE_UNICODE
3285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3286 #else
3287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3288 #endif
3289 }
3290 return resultobj;
3291 fail:
3292 return NULL;
3293 }
3294
3295
3296 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3297 PyObject *resultobj;
3298 wxObject *arg1 = (wxObject *) 0 ;
3299 PyObject * obj0 = 0 ;
3300 char *kwnames[] = {
3301 (char *) "self", NULL
3302 };
3303
3304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3306 if (SWIG_arg_fail(1)) SWIG_fail;
3307 {
3308 PyThreadState* __tstate = wxPyBeginAllowThreads();
3309 wxObject_Destroy(arg1);
3310
3311 wxPyEndAllowThreads(__tstate);
3312 if (PyErr_Occurred()) SWIG_fail;
3313 }
3314 Py_INCREF(Py_None); resultobj = Py_None;
3315 return resultobj;
3316 fail:
3317 return NULL;
3318 }
3319
3320
3321 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3322 PyObject *obj;
3323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3324 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3325 Py_INCREF(obj);
3326 return Py_BuildValue((char *)"");
3327 }
3328 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3329 PyObject *resultobj;
3330 wxSize *arg1 = (wxSize *) 0 ;
3331 int arg2 ;
3332 PyObject * obj0 = 0 ;
3333 PyObject * obj1 = 0 ;
3334 char *kwnames[] = {
3335 (char *) "self",(char *) "x", NULL
3336 };
3337
3338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3340 if (SWIG_arg_fail(1)) SWIG_fail;
3341 {
3342 arg2 = (int)(SWIG_As_int(obj1));
3343 if (SWIG_arg_fail(2)) SWIG_fail;
3344 }
3345 if (arg1) (arg1)->x = arg2;
3346
3347 Py_INCREF(Py_None); resultobj = Py_None;
3348 return resultobj;
3349 fail:
3350 return NULL;
3351 }
3352
3353
3354 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3355 PyObject *resultobj;
3356 wxSize *arg1 = (wxSize *) 0 ;
3357 int result;
3358 PyObject * obj0 = 0 ;
3359 char *kwnames[] = {
3360 (char *) "self", NULL
3361 };
3362
3363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3365 if (SWIG_arg_fail(1)) SWIG_fail;
3366 result = (int) ((arg1)->x);
3367
3368 {
3369 resultobj = SWIG_From_int((int)(result));
3370 }
3371 return resultobj;
3372 fail:
3373 return NULL;
3374 }
3375
3376
3377 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3378 PyObject *resultobj;
3379 wxSize *arg1 = (wxSize *) 0 ;
3380 int arg2 ;
3381 PyObject * obj0 = 0 ;
3382 PyObject * obj1 = 0 ;
3383 char *kwnames[] = {
3384 (char *) "self",(char *) "y", NULL
3385 };
3386
3387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3389 if (SWIG_arg_fail(1)) SWIG_fail;
3390 {
3391 arg2 = (int)(SWIG_As_int(obj1));
3392 if (SWIG_arg_fail(2)) SWIG_fail;
3393 }
3394 if (arg1) (arg1)->y = arg2;
3395
3396 Py_INCREF(Py_None); resultobj = Py_None;
3397 return resultobj;
3398 fail:
3399 return NULL;
3400 }
3401
3402
3403 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3404 PyObject *resultobj;
3405 wxSize *arg1 = (wxSize *) 0 ;
3406 int result;
3407 PyObject * obj0 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "self", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3414 if (SWIG_arg_fail(1)) SWIG_fail;
3415 result = (int) ((arg1)->y);
3416
3417 {
3418 resultobj = SWIG_From_int((int)(result));
3419 }
3420 return resultobj;
3421 fail:
3422 return NULL;
3423 }
3424
3425
3426 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3427 PyObject *resultobj;
3428 int arg1 = (int) 0 ;
3429 int arg2 = (int) 0 ;
3430 wxSize *result;
3431 PyObject * obj0 = 0 ;
3432 PyObject * obj1 = 0 ;
3433 char *kwnames[] = {
3434 (char *) "w",(char *) "h", NULL
3435 };
3436
3437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3438 if (obj0) {
3439 {
3440 arg1 = (int)(SWIG_As_int(obj0));
3441 if (SWIG_arg_fail(1)) SWIG_fail;
3442 }
3443 }
3444 if (obj1) {
3445 {
3446 arg2 = (int)(SWIG_As_int(obj1));
3447 if (SWIG_arg_fail(2)) SWIG_fail;
3448 }
3449 }
3450 {
3451 PyThreadState* __tstate = wxPyBeginAllowThreads();
3452 result = (wxSize *)new wxSize(arg1,arg2);
3453
3454 wxPyEndAllowThreads(__tstate);
3455 if (PyErr_Occurred()) SWIG_fail;
3456 }
3457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3458 return resultobj;
3459 fail:
3460 return NULL;
3461 }
3462
3463
3464 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3465 PyObject *resultobj;
3466 wxSize *arg1 = (wxSize *) 0 ;
3467 PyObject * obj0 = 0 ;
3468 char *kwnames[] = {
3469 (char *) "self", NULL
3470 };
3471
3472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3474 if (SWIG_arg_fail(1)) SWIG_fail;
3475 {
3476 PyThreadState* __tstate = wxPyBeginAllowThreads();
3477 delete arg1;
3478
3479 wxPyEndAllowThreads(__tstate);
3480 if (PyErr_Occurred()) SWIG_fail;
3481 }
3482 Py_INCREF(Py_None); resultobj = Py_None;
3483 return resultobj;
3484 fail:
3485 return NULL;
3486 }
3487
3488
3489 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3490 PyObject *resultobj;
3491 wxSize *arg1 = (wxSize *) 0 ;
3492 wxSize *arg2 = 0 ;
3493 bool result;
3494 wxSize temp2 ;
3495 PyObject * obj0 = 0 ;
3496 PyObject * obj1 = 0 ;
3497 char *kwnames[] = {
3498 (char *) "self",(char *) "sz", NULL
3499 };
3500
3501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3503 if (SWIG_arg_fail(1)) SWIG_fail;
3504 {
3505 arg2 = &temp2;
3506 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3507 }
3508 {
3509 PyThreadState* __tstate = wxPyBeginAllowThreads();
3510 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3511
3512 wxPyEndAllowThreads(__tstate);
3513 if (PyErr_Occurred()) SWIG_fail;
3514 }
3515 {
3516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3517 }
3518 return resultobj;
3519 fail:
3520 return NULL;
3521 }
3522
3523
3524 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3525 PyObject *resultobj;
3526 wxSize *arg1 = (wxSize *) 0 ;
3527 wxSize *arg2 = 0 ;
3528 bool result;
3529 wxSize temp2 ;
3530 PyObject * obj0 = 0 ;
3531 PyObject * obj1 = 0 ;
3532 char *kwnames[] = {
3533 (char *) "self",(char *) "sz", NULL
3534 };
3535
3536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3538 if (SWIG_arg_fail(1)) SWIG_fail;
3539 {
3540 arg2 = &temp2;
3541 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3542 }
3543 {
3544 PyThreadState* __tstate = wxPyBeginAllowThreads();
3545 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3546
3547 wxPyEndAllowThreads(__tstate);
3548 if (PyErr_Occurred()) SWIG_fail;
3549 }
3550 {
3551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3552 }
3553 return resultobj;
3554 fail:
3555 return NULL;
3556 }
3557
3558
3559 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3560 PyObject *resultobj;
3561 wxSize *arg1 = (wxSize *) 0 ;
3562 wxSize *arg2 = 0 ;
3563 wxSize result;
3564 wxSize temp2 ;
3565 PyObject * obj0 = 0 ;
3566 PyObject * obj1 = 0 ;
3567 char *kwnames[] = {
3568 (char *) "self",(char *) "sz", NULL
3569 };
3570
3571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3573 if (SWIG_arg_fail(1)) SWIG_fail;
3574 {
3575 arg2 = &temp2;
3576 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3577 }
3578 {
3579 PyThreadState* __tstate = wxPyBeginAllowThreads();
3580 result = (arg1)->operator +((wxSize const &)*arg2);
3581
3582 wxPyEndAllowThreads(__tstate);
3583 if (PyErr_Occurred()) SWIG_fail;
3584 }
3585 {
3586 wxSize * resultptr;
3587 resultptr = new wxSize((wxSize &)(result));
3588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3589 }
3590 return resultobj;
3591 fail:
3592 return NULL;
3593 }
3594
3595
3596 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3597 PyObject *resultobj;
3598 wxSize *arg1 = (wxSize *) 0 ;
3599 wxSize *arg2 = 0 ;
3600 wxSize result;
3601 wxSize temp2 ;
3602 PyObject * obj0 = 0 ;
3603 PyObject * obj1 = 0 ;
3604 char *kwnames[] = {
3605 (char *) "self",(char *) "sz", NULL
3606 };
3607
3608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3610 if (SWIG_arg_fail(1)) SWIG_fail;
3611 {
3612 arg2 = &temp2;
3613 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3614 }
3615 {
3616 PyThreadState* __tstate = wxPyBeginAllowThreads();
3617 result = (arg1)->operator -((wxSize const &)*arg2);
3618
3619 wxPyEndAllowThreads(__tstate);
3620 if (PyErr_Occurred()) SWIG_fail;
3621 }
3622 {
3623 wxSize * resultptr;
3624 resultptr = new wxSize((wxSize &)(result));
3625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3626 }
3627 return resultobj;
3628 fail:
3629 return NULL;
3630 }
3631
3632
3633 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3634 PyObject *resultobj;
3635 wxSize *arg1 = (wxSize *) 0 ;
3636 wxSize *arg2 = 0 ;
3637 wxSize temp2 ;
3638 PyObject * obj0 = 0 ;
3639 PyObject * obj1 = 0 ;
3640 char *kwnames[] = {
3641 (char *) "self",(char *) "sz", NULL
3642 };
3643
3644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3646 if (SWIG_arg_fail(1)) SWIG_fail;
3647 {
3648 arg2 = &temp2;
3649 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3650 }
3651 {
3652 PyThreadState* __tstate = wxPyBeginAllowThreads();
3653 (arg1)->IncTo((wxSize const &)*arg2);
3654
3655 wxPyEndAllowThreads(__tstate);
3656 if (PyErr_Occurred()) SWIG_fail;
3657 }
3658 Py_INCREF(Py_None); resultobj = Py_None;
3659 return resultobj;
3660 fail:
3661 return NULL;
3662 }
3663
3664
3665 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3666 PyObject *resultobj;
3667 wxSize *arg1 = (wxSize *) 0 ;
3668 wxSize *arg2 = 0 ;
3669 wxSize temp2 ;
3670 PyObject * obj0 = 0 ;
3671 PyObject * obj1 = 0 ;
3672 char *kwnames[] = {
3673 (char *) "self",(char *) "sz", NULL
3674 };
3675
3676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3678 if (SWIG_arg_fail(1)) SWIG_fail;
3679 {
3680 arg2 = &temp2;
3681 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3682 }
3683 {
3684 PyThreadState* __tstate = wxPyBeginAllowThreads();
3685 (arg1)->DecTo((wxSize const &)*arg2);
3686
3687 wxPyEndAllowThreads(__tstate);
3688 if (PyErr_Occurred()) SWIG_fail;
3689 }
3690 Py_INCREF(Py_None); resultobj = Py_None;
3691 return resultobj;
3692 fail:
3693 return NULL;
3694 }
3695
3696
3697 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3698 PyObject *resultobj;
3699 wxSize *arg1 = (wxSize *) 0 ;
3700 int arg2 ;
3701 int arg3 ;
3702 PyObject * obj0 = 0 ;
3703 PyObject * obj1 = 0 ;
3704 PyObject * obj2 = 0 ;
3705 char *kwnames[] = {
3706 (char *) "self",(char *) "w",(char *) "h", NULL
3707 };
3708
3709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3711 if (SWIG_arg_fail(1)) SWIG_fail;
3712 {
3713 arg2 = (int)(SWIG_As_int(obj1));
3714 if (SWIG_arg_fail(2)) SWIG_fail;
3715 }
3716 {
3717 arg3 = (int)(SWIG_As_int(obj2));
3718 if (SWIG_arg_fail(3)) SWIG_fail;
3719 }
3720 {
3721 PyThreadState* __tstate = wxPyBeginAllowThreads();
3722 (arg1)->Set(arg2,arg3);
3723
3724 wxPyEndAllowThreads(__tstate);
3725 if (PyErr_Occurred()) SWIG_fail;
3726 }
3727 Py_INCREF(Py_None); resultobj = Py_None;
3728 return resultobj;
3729 fail:
3730 return NULL;
3731 }
3732
3733
3734 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3735 PyObject *resultobj;
3736 wxSize *arg1 = (wxSize *) 0 ;
3737 int arg2 ;
3738 PyObject * obj0 = 0 ;
3739 PyObject * obj1 = 0 ;
3740 char *kwnames[] = {
3741 (char *) "self",(char *) "w", NULL
3742 };
3743
3744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3746 if (SWIG_arg_fail(1)) SWIG_fail;
3747 {
3748 arg2 = (int)(SWIG_As_int(obj1));
3749 if (SWIG_arg_fail(2)) SWIG_fail;
3750 }
3751 {
3752 PyThreadState* __tstate = wxPyBeginAllowThreads();
3753 (arg1)->SetWidth(arg2);
3754
3755 wxPyEndAllowThreads(__tstate);
3756 if (PyErr_Occurred()) SWIG_fail;
3757 }
3758 Py_INCREF(Py_None); resultobj = Py_None;
3759 return resultobj;
3760 fail:
3761 return NULL;
3762 }
3763
3764
3765 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3766 PyObject *resultobj;
3767 wxSize *arg1 = (wxSize *) 0 ;
3768 int arg2 ;
3769 PyObject * obj0 = 0 ;
3770 PyObject * obj1 = 0 ;
3771 char *kwnames[] = {
3772 (char *) "self",(char *) "h", NULL
3773 };
3774
3775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3777 if (SWIG_arg_fail(1)) SWIG_fail;
3778 {
3779 arg2 = (int)(SWIG_As_int(obj1));
3780 if (SWIG_arg_fail(2)) SWIG_fail;
3781 }
3782 {
3783 PyThreadState* __tstate = wxPyBeginAllowThreads();
3784 (arg1)->SetHeight(arg2);
3785
3786 wxPyEndAllowThreads(__tstate);
3787 if (PyErr_Occurred()) SWIG_fail;
3788 }
3789 Py_INCREF(Py_None); resultobj = Py_None;
3790 return resultobj;
3791 fail:
3792 return NULL;
3793 }
3794
3795
3796 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3797 PyObject *resultobj;
3798 wxSize *arg1 = (wxSize *) 0 ;
3799 int result;
3800 PyObject * obj0 = 0 ;
3801 char *kwnames[] = {
3802 (char *) "self", NULL
3803 };
3804
3805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3807 if (SWIG_arg_fail(1)) SWIG_fail;
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 result = (int)((wxSize const *)arg1)->GetWidth();
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 {
3816 resultobj = SWIG_From_int((int)(result));
3817 }
3818 return resultobj;
3819 fail:
3820 return NULL;
3821 }
3822
3823
3824 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3825 PyObject *resultobj;
3826 wxSize *arg1 = (wxSize *) 0 ;
3827 int result;
3828 PyObject * obj0 = 0 ;
3829 char *kwnames[] = {
3830 (char *) "self", NULL
3831 };
3832
3833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3835 if (SWIG_arg_fail(1)) SWIG_fail;
3836 {
3837 PyThreadState* __tstate = wxPyBeginAllowThreads();
3838 result = (int)((wxSize const *)arg1)->GetHeight();
3839
3840 wxPyEndAllowThreads(__tstate);
3841 if (PyErr_Occurred()) SWIG_fail;
3842 }
3843 {
3844 resultobj = SWIG_From_int((int)(result));
3845 }
3846 return resultobj;
3847 fail:
3848 return NULL;
3849 }
3850
3851
3852 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3853 PyObject *resultobj;
3854 wxSize *arg1 = (wxSize *) 0 ;
3855 bool result;
3856 PyObject * obj0 = 0 ;
3857 char *kwnames[] = {
3858 (char *) "self", NULL
3859 };
3860
3861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3863 if (SWIG_arg_fail(1)) SWIG_fail;
3864 {
3865 PyThreadState* __tstate = wxPyBeginAllowThreads();
3866 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3867
3868 wxPyEndAllowThreads(__tstate);
3869 if (PyErr_Occurred()) SWIG_fail;
3870 }
3871 {
3872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3873 }
3874 return resultobj;
3875 fail:
3876 return NULL;
3877 }
3878
3879
3880 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3881 PyObject *resultobj;
3882 wxSize *arg1 = (wxSize *) 0 ;
3883 wxSize *arg2 = 0 ;
3884 wxSize temp2 ;
3885 PyObject * obj0 = 0 ;
3886 PyObject * obj1 = 0 ;
3887 char *kwnames[] = {
3888 (char *) "self",(char *) "size", NULL
3889 };
3890
3891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3893 if (SWIG_arg_fail(1)) SWIG_fail;
3894 {
3895 arg2 = &temp2;
3896 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3897 }
3898 {
3899 PyThreadState* __tstate = wxPyBeginAllowThreads();
3900 (arg1)->SetDefaults((wxSize const &)*arg2);
3901
3902 wxPyEndAllowThreads(__tstate);
3903 if (PyErr_Occurred()) SWIG_fail;
3904 }
3905 Py_INCREF(Py_None); resultobj = Py_None;
3906 return resultobj;
3907 fail:
3908 return NULL;
3909 }
3910
3911
3912 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3913 PyObject *resultobj;
3914 wxSize *arg1 = (wxSize *) 0 ;
3915 PyObject *result;
3916 PyObject * obj0 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "self", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3923 if (SWIG_arg_fail(1)) SWIG_fail;
3924 {
3925 PyThreadState* __tstate = wxPyBeginAllowThreads();
3926 result = (PyObject *)wxSize_Get(arg1);
3927
3928 wxPyEndAllowThreads(__tstate);
3929 if (PyErr_Occurred()) SWIG_fail;
3930 }
3931 resultobj = result;
3932 return resultobj;
3933 fail:
3934 return NULL;
3935 }
3936
3937
3938 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3939 PyObject *obj;
3940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3941 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3942 Py_INCREF(obj);
3943 return Py_BuildValue((char *)"");
3944 }
3945 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3946 PyObject *resultobj;
3947 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3948 double arg2 ;
3949 PyObject * obj0 = 0 ;
3950 PyObject * obj1 = 0 ;
3951 char *kwnames[] = {
3952 (char *) "self",(char *) "x", NULL
3953 };
3954
3955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3957 if (SWIG_arg_fail(1)) SWIG_fail;
3958 {
3959 arg2 = (double)(SWIG_As_double(obj1));
3960 if (SWIG_arg_fail(2)) SWIG_fail;
3961 }
3962 if (arg1) (arg1)->x = arg2;
3963
3964 Py_INCREF(Py_None); resultobj = Py_None;
3965 return resultobj;
3966 fail:
3967 return NULL;
3968 }
3969
3970
3971 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3972 PyObject *resultobj;
3973 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3974 double result;
3975 PyObject * obj0 = 0 ;
3976 char *kwnames[] = {
3977 (char *) "self", NULL
3978 };
3979
3980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3982 if (SWIG_arg_fail(1)) SWIG_fail;
3983 result = (double) ((arg1)->x);
3984
3985 {
3986 resultobj = SWIG_From_double((double)(result));
3987 }
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj;
3996 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3997 double arg2 ;
3998 PyObject * obj0 = 0 ;
3999 PyObject * obj1 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "self",(char *) "y", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4006 if (SWIG_arg_fail(1)) SWIG_fail;
4007 {
4008 arg2 = (double)(SWIG_As_double(obj1));
4009 if (SWIG_arg_fail(2)) SWIG_fail;
4010 }
4011 if (arg1) (arg1)->y = arg2;
4012
4013 Py_INCREF(Py_None); resultobj = Py_None;
4014 return resultobj;
4015 fail:
4016 return NULL;
4017 }
4018
4019
4020 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4021 PyObject *resultobj;
4022 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4023 double result;
4024 PyObject * obj0 = 0 ;
4025 char *kwnames[] = {
4026 (char *) "self", NULL
4027 };
4028
4029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4031 if (SWIG_arg_fail(1)) SWIG_fail;
4032 result = (double) ((arg1)->y);
4033
4034 {
4035 resultobj = SWIG_From_double((double)(result));
4036 }
4037 return resultobj;
4038 fail:
4039 return NULL;
4040 }
4041
4042
4043 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4044 PyObject *resultobj;
4045 double arg1 = (double) 0.0 ;
4046 double arg2 = (double) 0.0 ;
4047 wxRealPoint *result;
4048 PyObject * obj0 = 0 ;
4049 PyObject * obj1 = 0 ;
4050 char *kwnames[] = {
4051 (char *) "x",(char *) "y", NULL
4052 };
4053
4054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4055 if (obj0) {
4056 {
4057 arg1 = (double)(SWIG_As_double(obj0));
4058 if (SWIG_arg_fail(1)) SWIG_fail;
4059 }
4060 }
4061 if (obj1) {
4062 {
4063 arg2 = (double)(SWIG_As_double(obj1));
4064 if (SWIG_arg_fail(2)) SWIG_fail;
4065 }
4066 }
4067 {
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4070
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj;
4083 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4084 PyObject * obj0 = 0 ;
4085 char *kwnames[] = {
4086 (char *) "self", NULL
4087 };
4088
4089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4091 if (SWIG_arg_fail(1)) SWIG_fail;
4092 {
4093 PyThreadState* __tstate = wxPyBeginAllowThreads();
4094 delete arg1;
4095
4096 wxPyEndAllowThreads(__tstate);
4097 if (PyErr_Occurred()) SWIG_fail;
4098 }
4099 Py_INCREF(Py_None); resultobj = Py_None;
4100 return resultobj;
4101 fail:
4102 return NULL;
4103 }
4104
4105
4106 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj;
4108 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4109 wxRealPoint *arg2 = 0 ;
4110 bool result;
4111 wxRealPoint temp2 ;
4112 PyObject * obj0 = 0 ;
4113 PyObject * obj1 = 0 ;
4114 char *kwnames[] = {
4115 (char *) "self",(char *) "pt", NULL
4116 };
4117
4118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4120 if (SWIG_arg_fail(1)) SWIG_fail;
4121 {
4122 arg2 = &temp2;
4123 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4124 }
4125 {
4126 PyThreadState* __tstate = wxPyBeginAllowThreads();
4127 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4128
4129 wxPyEndAllowThreads(__tstate);
4130 if (PyErr_Occurred()) SWIG_fail;
4131 }
4132 {
4133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4134 }
4135 return resultobj;
4136 fail:
4137 return NULL;
4138 }
4139
4140
4141 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4142 PyObject *resultobj;
4143 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4144 wxRealPoint *arg2 = 0 ;
4145 bool result;
4146 wxRealPoint temp2 ;
4147 PyObject * obj0 = 0 ;
4148 PyObject * obj1 = 0 ;
4149 char *kwnames[] = {
4150 (char *) "self",(char *) "pt", NULL
4151 };
4152
4153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4155 if (SWIG_arg_fail(1)) SWIG_fail;
4156 {
4157 arg2 = &temp2;
4158 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4159 }
4160 {
4161 PyThreadState* __tstate = wxPyBeginAllowThreads();
4162 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4163
4164 wxPyEndAllowThreads(__tstate);
4165 if (PyErr_Occurred()) SWIG_fail;
4166 }
4167 {
4168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4169 }
4170 return resultobj;
4171 fail:
4172 return NULL;
4173 }
4174
4175
4176 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4177 PyObject *resultobj;
4178 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4179 wxRealPoint *arg2 = 0 ;
4180 wxRealPoint result;
4181 wxRealPoint temp2 ;
4182 PyObject * obj0 = 0 ;
4183 PyObject * obj1 = 0 ;
4184 char *kwnames[] = {
4185 (char *) "self",(char *) "pt", NULL
4186 };
4187
4188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4190 if (SWIG_arg_fail(1)) SWIG_fail;
4191 {
4192 arg2 = &temp2;
4193 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4194 }
4195 {
4196 PyThreadState* __tstate = wxPyBeginAllowThreads();
4197 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4198
4199 wxPyEndAllowThreads(__tstate);
4200 if (PyErr_Occurred()) SWIG_fail;
4201 }
4202 {
4203 wxRealPoint * resultptr;
4204 resultptr = new wxRealPoint((wxRealPoint &)(result));
4205 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4206 }
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj;
4215 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4216 wxRealPoint *arg2 = 0 ;
4217 wxRealPoint result;
4218 wxRealPoint temp2 ;
4219 PyObject * obj0 = 0 ;
4220 PyObject * obj1 = 0 ;
4221 char *kwnames[] = {
4222 (char *) "self",(char *) "pt", NULL
4223 };
4224
4225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4227 if (SWIG_arg_fail(1)) SWIG_fail;
4228 {
4229 arg2 = &temp2;
4230 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4231 }
4232 {
4233 PyThreadState* __tstate = wxPyBeginAllowThreads();
4234 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4235
4236 wxPyEndAllowThreads(__tstate);
4237 if (PyErr_Occurred()) SWIG_fail;
4238 }
4239 {
4240 wxRealPoint * resultptr;
4241 resultptr = new wxRealPoint((wxRealPoint &)(result));
4242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4243 }
4244 return resultobj;
4245 fail:
4246 return NULL;
4247 }
4248
4249
4250 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4251 PyObject *resultobj;
4252 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4253 double arg2 ;
4254 double arg3 ;
4255 PyObject * obj0 = 0 ;
4256 PyObject * obj1 = 0 ;
4257 PyObject * obj2 = 0 ;
4258 char *kwnames[] = {
4259 (char *) "self",(char *) "x",(char *) "y", NULL
4260 };
4261
4262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4264 if (SWIG_arg_fail(1)) SWIG_fail;
4265 {
4266 arg2 = (double)(SWIG_As_double(obj1));
4267 if (SWIG_arg_fail(2)) SWIG_fail;
4268 }
4269 {
4270 arg3 = (double)(SWIG_As_double(obj2));
4271 if (SWIG_arg_fail(3)) SWIG_fail;
4272 }
4273 {
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 wxRealPoint_Set(arg1,arg2,arg3);
4276
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 Py_INCREF(Py_None); resultobj = Py_None;
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4288 PyObject *resultobj;
4289 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4290 PyObject *result;
4291 PyObject * obj0 = 0 ;
4292 char *kwnames[] = {
4293 (char *) "self", NULL
4294 };
4295
4296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4298 if (SWIG_arg_fail(1)) SWIG_fail;
4299 {
4300 PyThreadState* __tstate = wxPyBeginAllowThreads();
4301 result = (PyObject *)wxRealPoint_Get(arg1);
4302
4303 wxPyEndAllowThreads(__tstate);
4304 if (PyErr_Occurred()) SWIG_fail;
4305 }
4306 resultobj = result;
4307 return resultobj;
4308 fail:
4309 return NULL;
4310 }
4311
4312
4313 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4314 PyObject *obj;
4315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4316 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4317 Py_INCREF(obj);
4318 return Py_BuildValue((char *)"");
4319 }
4320 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4321 PyObject *resultobj;
4322 wxPoint *arg1 = (wxPoint *) 0 ;
4323 int arg2 ;
4324 PyObject * obj0 = 0 ;
4325 PyObject * obj1 = 0 ;
4326 char *kwnames[] = {
4327 (char *) "self",(char *) "x", NULL
4328 };
4329
4330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4332 if (SWIG_arg_fail(1)) SWIG_fail;
4333 {
4334 arg2 = (int)(SWIG_As_int(obj1));
4335 if (SWIG_arg_fail(2)) SWIG_fail;
4336 }
4337 if (arg1) (arg1)->x = arg2;
4338
4339 Py_INCREF(Py_None); resultobj = Py_None;
4340 return resultobj;
4341 fail:
4342 return NULL;
4343 }
4344
4345
4346 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4347 PyObject *resultobj;
4348 wxPoint *arg1 = (wxPoint *) 0 ;
4349 int result;
4350 PyObject * obj0 = 0 ;
4351 char *kwnames[] = {
4352 (char *) "self", NULL
4353 };
4354
4355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4357 if (SWIG_arg_fail(1)) SWIG_fail;
4358 result = (int) ((arg1)->x);
4359
4360 {
4361 resultobj = SWIG_From_int((int)(result));
4362 }
4363 return resultobj;
4364 fail:
4365 return NULL;
4366 }
4367
4368
4369 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj;
4371 wxPoint *arg1 = (wxPoint *) 0 ;
4372 int arg2 ;
4373 PyObject * obj0 = 0 ;
4374 PyObject * obj1 = 0 ;
4375 char *kwnames[] = {
4376 (char *) "self",(char *) "y", NULL
4377 };
4378
4379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4381 if (SWIG_arg_fail(1)) SWIG_fail;
4382 {
4383 arg2 = (int)(SWIG_As_int(obj1));
4384 if (SWIG_arg_fail(2)) SWIG_fail;
4385 }
4386 if (arg1) (arg1)->y = arg2;
4387
4388 Py_INCREF(Py_None); resultobj = Py_None;
4389 return resultobj;
4390 fail:
4391 return NULL;
4392 }
4393
4394
4395 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4396 PyObject *resultobj;
4397 wxPoint *arg1 = (wxPoint *) 0 ;
4398 int result;
4399 PyObject * obj0 = 0 ;
4400 char *kwnames[] = {
4401 (char *) "self", NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4406 if (SWIG_arg_fail(1)) SWIG_fail;
4407 result = (int) ((arg1)->y);
4408
4409 {
4410 resultobj = SWIG_From_int((int)(result));
4411 }
4412 return resultobj;
4413 fail:
4414 return NULL;
4415 }
4416
4417
4418 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4419 PyObject *resultobj;
4420 int arg1 = (int) 0 ;
4421 int arg2 = (int) 0 ;
4422 wxPoint *result;
4423 PyObject * obj0 = 0 ;
4424 PyObject * obj1 = 0 ;
4425 char *kwnames[] = {
4426 (char *) "x",(char *) "y", NULL
4427 };
4428
4429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4430 if (obj0) {
4431 {
4432 arg1 = (int)(SWIG_As_int(obj0));
4433 if (SWIG_arg_fail(1)) SWIG_fail;
4434 }
4435 }
4436 if (obj1) {
4437 {
4438 arg2 = (int)(SWIG_As_int(obj1));
4439 if (SWIG_arg_fail(2)) SWIG_fail;
4440 }
4441 }
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 result = (wxPoint *)new wxPoint(arg1,arg2);
4445
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4450 return resultobj;
4451 fail:
4452 return NULL;
4453 }
4454
4455
4456 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj;
4458 wxPoint *arg1 = (wxPoint *) 0 ;
4459 PyObject * obj0 = 0 ;
4460 char *kwnames[] = {
4461 (char *) "self", NULL
4462 };
4463
4464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4466 if (SWIG_arg_fail(1)) SWIG_fail;
4467 {
4468 PyThreadState* __tstate = wxPyBeginAllowThreads();
4469 delete arg1;
4470
4471 wxPyEndAllowThreads(__tstate);
4472 if (PyErr_Occurred()) SWIG_fail;
4473 }
4474 Py_INCREF(Py_None); resultobj = Py_None;
4475 return resultobj;
4476 fail:
4477 return NULL;
4478 }
4479
4480
4481 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4482 PyObject *resultobj;
4483 wxPoint *arg1 = (wxPoint *) 0 ;
4484 wxPoint *arg2 = 0 ;
4485 bool result;
4486 wxPoint temp2 ;
4487 PyObject * obj0 = 0 ;
4488 PyObject * obj1 = 0 ;
4489 char *kwnames[] = {
4490 (char *) "self",(char *) "pt", NULL
4491 };
4492
4493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4495 if (SWIG_arg_fail(1)) SWIG_fail;
4496 {
4497 arg2 = &temp2;
4498 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4499 }
4500 {
4501 PyThreadState* __tstate = wxPyBeginAllowThreads();
4502 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4503
4504 wxPyEndAllowThreads(__tstate);
4505 if (PyErr_Occurred()) SWIG_fail;
4506 }
4507 {
4508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4509 }
4510 return resultobj;
4511 fail:
4512 return NULL;
4513 }
4514
4515
4516 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj;
4518 wxPoint *arg1 = (wxPoint *) 0 ;
4519 wxPoint *arg2 = 0 ;
4520 bool result;
4521 wxPoint temp2 ;
4522 PyObject * obj0 = 0 ;
4523 PyObject * obj1 = 0 ;
4524 char *kwnames[] = {
4525 (char *) "self",(char *) "pt", NULL
4526 };
4527
4528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4530 if (SWIG_arg_fail(1)) SWIG_fail;
4531 {
4532 arg2 = &temp2;
4533 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4534 }
4535 {
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4538
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 {
4543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4544 }
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4552 PyObject *resultobj;
4553 wxPoint *arg1 = (wxPoint *) 0 ;
4554 wxPoint *arg2 = 0 ;
4555 wxPoint result;
4556 wxPoint temp2 ;
4557 PyObject * obj0 = 0 ;
4558 PyObject * obj1 = 0 ;
4559 char *kwnames[] = {
4560 (char *) "self",(char *) "pt", NULL
4561 };
4562
4563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4565 if (SWIG_arg_fail(1)) SWIG_fail;
4566 {
4567 arg2 = &temp2;
4568 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4569 }
4570 {
4571 PyThreadState* __tstate = wxPyBeginAllowThreads();
4572 result = (arg1)->operator +((wxPoint const &)*arg2);
4573
4574 wxPyEndAllowThreads(__tstate);
4575 if (PyErr_Occurred()) SWIG_fail;
4576 }
4577 {
4578 wxPoint * resultptr;
4579 resultptr = new wxPoint((wxPoint &)(result));
4580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4581 }
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj;
4590 wxPoint *arg1 = (wxPoint *) 0 ;
4591 wxPoint *arg2 = 0 ;
4592 wxPoint result;
4593 wxPoint temp2 ;
4594 PyObject * obj0 = 0 ;
4595 PyObject * obj1 = 0 ;
4596 char *kwnames[] = {
4597 (char *) "self",(char *) "pt", NULL
4598 };
4599
4600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4602 if (SWIG_arg_fail(1)) SWIG_fail;
4603 {
4604 arg2 = &temp2;
4605 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4606 }
4607 {
4608 PyThreadState* __tstate = wxPyBeginAllowThreads();
4609 result = (arg1)->operator -((wxPoint const &)*arg2);
4610
4611 wxPyEndAllowThreads(__tstate);
4612 if (PyErr_Occurred()) SWIG_fail;
4613 }
4614 {
4615 wxPoint * resultptr;
4616 resultptr = new wxPoint((wxPoint &)(result));
4617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4618 }
4619 return resultobj;
4620 fail:
4621 return NULL;
4622 }
4623
4624
4625 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4626 PyObject *resultobj;
4627 wxPoint *arg1 = (wxPoint *) 0 ;
4628 wxPoint *arg2 = 0 ;
4629 wxPoint *result;
4630 wxPoint temp2 ;
4631 PyObject * obj0 = 0 ;
4632 PyObject * obj1 = 0 ;
4633 char *kwnames[] = {
4634 (char *) "self",(char *) "pt", NULL
4635 };
4636
4637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4639 if (SWIG_arg_fail(1)) SWIG_fail;
4640 {
4641 arg2 = &temp2;
4642 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4643 }
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 {
4647 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4648 result = (wxPoint *) &_result_ref;
4649 }
4650
4651 wxPyEndAllowThreads(__tstate);
4652 if (PyErr_Occurred()) SWIG_fail;
4653 }
4654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4655 return resultobj;
4656 fail:
4657 return NULL;
4658 }
4659
4660
4661 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj;
4663 wxPoint *arg1 = (wxPoint *) 0 ;
4664 wxPoint *arg2 = 0 ;
4665 wxPoint *result;
4666 wxPoint temp2 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char *kwnames[] = {
4670 (char *) "self",(char *) "pt", NULL
4671 };
4672
4673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4675 if (SWIG_arg_fail(1)) SWIG_fail;
4676 {
4677 arg2 = &temp2;
4678 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4679 }
4680 {
4681 PyThreadState* __tstate = wxPyBeginAllowThreads();
4682 {
4683 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4684 result = (wxPoint *) &_result_ref;
4685 }
4686
4687 wxPyEndAllowThreads(__tstate);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4691 return resultobj;
4692 fail:
4693 return NULL;
4694 }
4695
4696
4697 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4698 PyObject *resultobj;
4699 wxPoint *arg1 = (wxPoint *) 0 ;
4700 long arg2 ;
4701 long arg3 ;
4702 PyObject * obj0 = 0 ;
4703 PyObject * obj1 = 0 ;
4704 PyObject * obj2 = 0 ;
4705 char *kwnames[] = {
4706 (char *) "self",(char *) "x",(char *) "y", NULL
4707 };
4708
4709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4711 if (SWIG_arg_fail(1)) SWIG_fail;
4712 {
4713 arg2 = (long)(SWIG_As_long(obj1));
4714 if (SWIG_arg_fail(2)) SWIG_fail;
4715 }
4716 {
4717 arg3 = (long)(SWIG_As_long(obj2));
4718 if (SWIG_arg_fail(3)) SWIG_fail;
4719 }
4720 {
4721 PyThreadState* __tstate = wxPyBeginAllowThreads();
4722 wxPoint_Set(arg1,arg2,arg3);
4723
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 Py_INCREF(Py_None); resultobj = Py_None;
4728 return resultobj;
4729 fail:
4730 return NULL;
4731 }
4732
4733
4734 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4735 PyObject *resultobj;
4736 wxPoint *arg1 = (wxPoint *) 0 ;
4737 PyObject *result;
4738 PyObject * obj0 = 0 ;
4739 char *kwnames[] = {
4740 (char *) "self", NULL
4741 };
4742
4743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4745 if (SWIG_arg_fail(1)) SWIG_fail;
4746 {
4747 PyThreadState* __tstate = wxPyBeginAllowThreads();
4748 result = (PyObject *)wxPoint_Get(arg1);
4749
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 resultobj = result;
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4761 PyObject *obj;
4762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4763 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4764 Py_INCREF(obj);
4765 return Py_BuildValue((char *)"");
4766 }
4767 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4768 PyObject *resultobj;
4769 int arg1 = (int) 0 ;
4770 int arg2 = (int) 0 ;
4771 int arg3 = (int) 0 ;
4772 int arg4 = (int) 0 ;
4773 wxRect *result;
4774 PyObject * obj0 = 0 ;
4775 PyObject * obj1 = 0 ;
4776 PyObject * obj2 = 0 ;
4777 PyObject * obj3 = 0 ;
4778 char *kwnames[] = {
4779 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4780 };
4781
4782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4783 if (obj0) {
4784 {
4785 arg1 = (int)(SWIG_As_int(obj0));
4786 if (SWIG_arg_fail(1)) SWIG_fail;
4787 }
4788 }
4789 if (obj1) {
4790 {
4791 arg2 = (int)(SWIG_As_int(obj1));
4792 if (SWIG_arg_fail(2)) SWIG_fail;
4793 }
4794 }
4795 if (obj2) {
4796 {
4797 arg3 = (int)(SWIG_As_int(obj2));
4798 if (SWIG_arg_fail(3)) SWIG_fail;
4799 }
4800 }
4801 if (obj3) {
4802 {
4803 arg4 = (int)(SWIG_As_int(obj3));
4804 if (SWIG_arg_fail(4)) SWIG_fail;
4805 }
4806 }
4807 {
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4810
4811 wxPyEndAllowThreads(__tstate);
4812 if (PyErr_Occurred()) SWIG_fail;
4813 }
4814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4815 return resultobj;
4816 fail:
4817 return NULL;
4818 }
4819
4820
4821 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4822 PyObject *resultobj;
4823 wxPoint *arg1 = 0 ;
4824 wxPoint *arg2 = 0 ;
4825 wxRect *result;
4826 wxPoint temp1 ;
4827 wxPoint temp2 ;
4828 PyObject * obj0 = 0 ;
4829 PyObject * obj1 = 0 ;
4830 char *kwnames[] = {
4831 (char *) "topLeft",(char *) "bottomRight", NULL
4832 };
4833
4834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4835 {
4836 arg1 = &temp1;
4837 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4838 }
4839 {
4840 arg2 = &temp2;
4841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4842 }
4843 {
4844 PyThreadState* __tstate = wxPyBeginAllowThreads();
4845 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4846
4847 wxPyEndAllowThreads(__tstate);
4848 if (PyErr_Occurred()) SWIG_fail;
4849 }
4850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4851 return resultobj;
4852 fail:
4853 return NULL;
4854 }
4855
4856
4857 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4858 PyObject *resultobj;
4859 wxPoint *arg1 = 0 ;
4860 wxSize *arg2 = 0 ;
4861 wxRect *result;
4862 wxPoint temp1 ;
4863 wxSize temp2 ;
4864 PyObject * obj0 = 0 ;
4865 PyObject * obj1 = 0 ;
4866 char *kwnames[] = {
4867 (char *) "pos",(char *) "size", NULL
4868 };
4869
4870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4871 {
4872 arg1 = &temp1;
4873 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4874 }
4875 {
4876 arg2 = &temp2;
4877 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4878 }
4879 {
4880 PyThreadState* __tstate = wxPyBeginAllowThreads();
4881 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4882
4883 wxPyEndAllowThreads(__tstate);
4884 if (PyErr_Occurred()) SWIG_fail;
4885 }
4886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4887 return resultobj;
4888 fail:
4889 return NULL;
4890 }
4891
4892
4893 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4894 PyObject *resultobj;
4895 wxSize *arg1 = 0 ;
4896 wxRect *result;
4897 wxSize temp1 ;
4898 PyObject * obj0 = 0 ;
4899 char *kwnames[] = {
4900 (char *) "size", NULL
4901 };
4902
4903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4904 {
4905 arg1 = &temp1;
4906 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4907 }
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4911
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj;
4924 wxRect *arg1 = (wxRect *) 0 ;
4925 PyObject * obj0 = 0 ;
4926 char *kwnames[] = {
4927 (char *) "self", NULL
4928 };
4929
4930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4932 if (SWIG_arg_fail(1)) SWIG_fail;
4933 {
4934 PyThreadState* __tstate = wxPyBeginAllowThreads();
4935 delete arg1;
4936
4937 wxPyEndAllowThreads(__tstate);
4938 if (PyErr_Occurred()) SWIG_fail;
4939 }
4940 Py_INCREF(Py_None); resultobj = Py_None;
4941 return resultobj;
4942 fail:
4943 return NULL;
4944 }
4945
4946
4947 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4948 PyObject *resultobj;
4949 wxRect *arg1 = (wxRect *) 0 ;
4950 int result;
4951 PyObject * obj0 = 0 ;
4952 char *kwnames[] = {
4953 (char *) "self", NULL
4954 };
4955
4956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4958 if (SWIG_arg_fail(1)) SWIG_fail;
4959 {
4960 PyThreadState* __tstate = wxPyBeginAllowThreads();
4961 result = (int)((wxRect const *)arg1)->GetX();
4962
4963 wxPyEndAllowThreads(__tstate);
4964 if (PyErr_Occurred()) SWIG_fail;
4965 }
4966 {
4967 resultobj = SWIG_From_int((int)(result));
4968 }
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4976 PyObject *resultobj;
4977 wxRect *arg1 = (wxRect *) 0 ;
4978 int arg2 ;
4979 PyObject * obj0 = 0 ;
4980 PyObject * obj1 = 0 ;
4981 char *kwnames[] = {
4982 (char *) "self",(char *) "x", NULL
4983 };
4984
4985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4987 if (SWIG_arg_fail(1)) SWIG_fail;
4988 {
4989 arg2 = (int)(SWIG_As_int(obj1));
4990 if (SWIG_arg_fail(2)) SWIG_fail;
4991 }
4992 {
4993 PyThreadState* __tstate = wxPyBeginAllowThreads();
4994 (arg1)->SetX(arg2);
4995
4996 wxPyEndAllowThreads(__tstate);
4997 if (PyErr_Occurred()) SWIG_fail;
4998 }
4999 Py_INCREF(Py_None); resultobj = Py_None;
5000 return resultobj;
5001 fail:
5002 return NULL;
5003 }
5004
5005
5006 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5007 PyObject *resultobj;
5008 wxRect *arg1 = (wxRect *) 0 ;
5009 int result;
5010 PyObject * obj0 = 0 ;
5011 char *kwnames[] = {
5012 (char *) "self", NULL
5013 };
5014
5015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5017 if (SWIG_arg_fail(1)) SWIG_fail;
5018 {
5019 PyThreadState* __tstate = wxPyBeginAllowThreads();
5020 result = (int)(arg1)->GetY();
5021
5022 wxPyEndAllowThreads(__tstate);
5023 if (PyErr_Occurred()) SWIG_fail;
5024 }
5025 {
5026 resultobj = SWIG_From_int((int)(result));
5027 }
5028 return resultobj;
5029 fail:
5030 return NULL;
5031 }
5032
5033
5034 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5035 PyObject *resultobj;
5036 wxRect *arg1 = (wxRect *) 0 ;
5037 int arg2 ;
5038 PyObject * obj0 = 0 ;
5039 PyObject * obj1 = 0 ;
5040 char *kwnames[] = {
5041 (char *) "self",(char *) "y", NULL
5042 };
5043
5044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5046 if (SWIG_arg_fail(1)) SWIG_fail;
5047 {
5048 arg2 = (int)(SWIG_As_int(obj1));
5049 if (SWIG_arg_fail(2)) SWIG_fail;
5050 }
5051 {
5052 PyThreadState* __tstate = wxPyBeginAllowThreads();
5053 (arg1)->SetY(arg2);
5054
5055 wxPyEndAllowThreads(__tstate);
5056 if (PyErr_Occurred()) SWIG_fail;
5057 }
5058 Py_INCREF(Py_None); resultobj = Py_None;
5059 return resultobj;
5060 fail:
5061 return NULL;
5062 }
5063
5064
5065 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj;
5067 wxRect *arg1 = (wxRect *) 0 ;
5068 int result;
5069 PyObject * obj0 = 0 ;
5070 char *kwnames[] = {
5071 (char *) "self", NULL
5072 };
5073
5074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5076 if (SWIG_arg_fail(1)) SWIG_fail;
5077 {
5078 PyThreadState* __tstate = wxPyBeginAllowThreads();
5079 result = (int)((wxRect const *)arg1)->GetWidth();
5080
5081 wxPyEndAllowThreads(__tstate);
5082 if (PyErr_Occurred()) SWIG_fail;
5083 }
5084 {
5085 resultobj = SWIG_From_int((int)(result));
5086 }
5087 return resultobj;
5088 fail:
5089 return NULL;
5090 }
5091
5092
5093 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5094 PyObject *resultobj;
5095 wxRect *arg1 = (wxRect *) 0 ;
5096 int arg2 ;
5097 PyObject * obj0 = 0 ;
5098 PyObject * obj1 = 0 ;
5099 char *kwnames[] = {
5100 (char *) "self",(char *) "w", NULL
5101 };
5102
5103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5105 if (SWIG_arg_fail(1)) SWIG_fail;
5106 {
5107 arg2 = (int)(SWIG_As_int(obj1));
5108 if (SWIG_arg_fail(2)) SWIG_fail;
5109 }
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 (arg1)->SetWidth(arg2);
5113
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 Py_INCREF(Py_None); resultobj = Py_None;
5118 return resultobj;
5119 fail:
5120 return NULL;
5121 }
5122
5123
5124 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5125 PyObject *resultobj;
5126 wxRect *arg1 = (wxRect *) 0 ;
5127 int result;
5128 PyObject * obj0 = 0 ;
5129 char *kwnames[] = {
5130 (char *) "self", NULL
5131 };
5132
5133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5135 if (SWIG_arg_fail(1)) SWIG_fail;
5136 {
5137 PyThreadState* __tstate = wxPyBeginAllowThreads();
5138 result = (int)((wxRect const *)arg1)->GetHeight();
5139
5140 wxPyEndAllowThreads(__tstate);
5141 if (PyErr_Occurred()) SWIG_fail;
5142 }
5143 {
5144 resultobj = SWIG_From_int((int)(result));
5145 }
5146 return resultobj;
5147 fail:
5148 return NULL;
5149 }
5150
5151
5152 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5153 PyObject *resultobj;
5154 wxRect *arg1 = (wxRect *) 0 ;
5155 int arg2 ;
5156 PyObject * obj0 = 0 ;
5157 PyObject * obj1 = 0 ;
5158 char *kwnames[] = {
5159 (char *) "self",(char *) "h", NULL
5160 };
5161
5162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5164 if (SWIG_arg_fail(1)) SWIG_fail;
5165 {
5166 arg2 = (int)(SWIG_As_int(obj1));
5167 if (SWIG_arg_fail(2)) SWIG_fail;
5168 }
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 (arg1)->SetHeight(arg2);
5172
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 Py_INCREF(Py_None); resultobj = Py_None;
5177 return resultobj;
5178 fail:
5179 return NULL;
5180 }
5181
5182
5183 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5184 PyObject *resultobj;
5185 wxRect *arg1 = (wxRect *) 0 ;
5186 wxPoint result;
5187 PyObject * obj0 = 0 ;
5188 char *kwnames[] = {
5189 (char *) "self", NULL
5190 };
5191
5192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5194 if (SWIG_arg_fail(1)) SWIG_fail;
5195 {
5196 PyThreadState* __tstate = wxPyBeginAllowThreads();
5197 result = ((wxRect const *)arg1)->GetPosition();
5198
5199 wxPyEndAllowThreads(__tstate);
5200 if (PyErr_Occurred()) SWIG_fail;
5201 }
5202 {
5203 wxPoint * resultptr;
5204 resultptr = new wxPoint((wxPoint &)(result));
5205 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5206 }
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj;
5215 wxRect *arg1 = (wxRect *) 0 ;
5216 wxPoint *arg2 = 0 ;
5217 wxPoint temp2 ;
5218 PyObject * obj0 = 0 ;
5219 PyObject * obj1 = 0 ;
5220 char *kwnames[] = {
5221 (char *) "self",(char *) "p", NULL
5222 };
5223
5224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5226 if (SWIG_arg_fail(1)) SWIG_fail;
5227 {
5228 arg2 = &temp2;
5229 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5230 }
5231 {
5232 PyThreadState* __tstate = wxPyBeginAllowThreads();
5233 (arg1)->SetPosition((wxPoint const &)*arg2);
5234
5235 wxPyEndAllowThreads(__tstate);
5236 if (PyErr_Occurred()) SWIG_fail;
5237 }
5238 Py_INCREF(Py_None); resultobj = Py_None;
5239 return resultobj;
5240 fail:
5241 return NULL;
5242 }
5243
5244
5245 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5246 PyObject *resultobj;
5247 wxRect *arg1 = (wxRect *) 0 ;
5248 wxSize result;
5249 PyObject * obj0 = 0 ;
5250 char *kwnames[] = {
5251 (char *) "self", NULL
5252 };
5253
5254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5256 if (SWIG_arg_fail(1)) SWIG_fail;
5257 {
5258 PyThreadState* __tstate = wxPyBeginAllowThreads();
5259 result = ((wxRect const *)arg1)->GetSize();
5260
5261 wxPyEndAllowThreads(__tstate);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 {
5265 wxSize * resultptr;
5266 resultptr = new wxSize((wxSize &)(result));
5267 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5268 }
5269 return resultobj;
5270 fail:
5271 return NULL;
5272 }
5273
5274
5275 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5276 PyObject *resultobj;
5277 wxRect *arg1 = (wxRect *) 0 ;
5278 wxSize *arg2 = 0 ;
5279 wxSize temp2 ;
5280 PyObject * obj0 = 0 ;
5281 PyObject * obj1 = 0 ;
5282 char *kwnames[] = {
5283 (char *) "self",(char *) "s", NULL
5284 };
5285
5286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5288 if (SWIG_arg_fail(1)) SWIG_fail;
5289 {
5290 arg2 = &temp2;
5291 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5292 }
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 (arg1)->SetSize((wxSize const &)*arg2);
5296
5297 wxPyEndAllowThreads(__tstate);
5298 if (PyErr_Occurred()) SWIG_fail;
5299 }
5300 Py_INCREF(Py_None); resultobj = Py_None;
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj;
5309 wxRect *arg1 = (wxRect *) 0 ;
5310 bool result;
5311 PyObject * obj0 = 0 ;
5312 char *kwnames[] = {
5313 (char *) "self", NULL
5314 };
5315
5316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5318 if (SWIG_arg_fail(1)) SWIG_fail;
5319 {
5320 PyThreadState* __tstate = wxPyBeginAllowThreads();
5321 result = (bool)((wxRect const *)arg1)->IsEmpty();
5322
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 {
5327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5328 }
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5336 PyObject *resultobj;
5337 wxRect *arg1 = (wxRect *) 0 ;
5338 wxPoint result;
5339 PyObject * obj0 = 0 ;
5340 char *kwnames[] = {
5341 (char *) "self", NULL
5342 };
5343
5344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5346 if (SWIG_arg_fail(1)) SWIG_fail;
5347 {
5348 PyThreadState* __tstate = wxPyBeginAllowThreads();
5349 result = ((wxRect const *)arg1)->GetTopLeft();
5350
5351 wxPyEndAllowThreads(__tstate);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 wxPoint * resultptr;
5356 resultptr = new wxPoint((wxPoint &)(result));
5357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5358 }
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5366 PyObject *resultobj;
5367 wxRect *arg1 = (wxRect *) 0 ;
5368 wxPoint *arg2 = 0 ;
5369 wxPoint temp2 ;
5370 PyObject * obj0 = 0 ;
5371 PyObject * obj1 = 0 ;
5372 char *kwnames[] = {
5373 (char *) "self",(char *) "p", NULL
5374 };
5375
5376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5378 if (SWIG_arg_fail(1)) SWIG_fail;
5379 {
5380 arg2 = &temp2;
5381 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5382 }
5383 {
5384 PyThreadState* __tstate = wxPyBeginAllowThreads();
5385 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5386
5387 wxPyEndAllowThreads(__tstate);
5388 if (PyErr_Occurred()) SWIG_fail;
5389 }
5390 Py_INCREF(Py_None); resultobj = Py_None;
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5398 PyObject *resultobj;
5399 wxRect *arg1 = (wxRect *) 0 ;
5400 wxPoint result;
5401 PyObject * obj0 = 0 ;
5402 char *kwnames[] = {
5403 (char *) "self", NULL
5404 };
5405
5406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5408 if (SWIG_arg_fail(1)) SWIG_fail;
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = ((wxRect const *)arg1)->GetBottomRight();
5412
5413 wxPyEndAllowThreads(__tstate);
5414 if (PyErr_Occurred()) SWIG_fail;
5415 }
5416 {
5417 wxPoint * resultptr;
5418 resultptr = new wxPoint((wxPoint &)(result));
5419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5420 }
5421 return resultobj;
5422 fail:
5423 return NULL;
5424 }
5425
5426
5427 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5428 PyObject *resultobj;
5429 wxRect *arg1 = (wxRect *) 0 ;
5430 wxPoint *arg2 = 0 ;
5431 wxPoint temp2 ;
5432 PyObject * obj0 = 0 ;
5433 PyObject * obj1 = 0 ;
5434 char *kwnames[] = {
5435 (char *) "self",(char *) "p", NULL
5436 };
5437
5438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5440 if (SWIG_arg_fail(1)) SWIG_fail;
5441 {
5442 arg2 = &temp2;
5443 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5444 }
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5448
5449 wxPyEndAllowThreads(__tstate);
5450 if (PyErr_Occurred()) SWIG_fail;
5451 }
5452 Py_INCREF(Py_None); resultobj = Py_None;
5453 return resultobj;
5454 fail:
5455 return NULL;
5456 }
5457
5458
5459 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5460 PyObject *resultobj;
5461 wxRect *arg1 = (wxRect *) 0 ;
5462 int result;
5463 PyObject * obj0 = 0 ;
5464 char *kwnames[] = {
5465 (char *) "self", NULL
5466 };
5467
5468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5470 if (SWIG_arg_fail(1)) SWIG_fail;
5471 {
5472 PyThreadState* __tstate = wxPyBeginAllowThreads();
5473 result = (int)((wxRect const *)arg1)->GetLeft();
5474
5475 wxPyEndAllowThreads(__tstate);
5476 if (PyErr_Occurred()) SWIG_fail;
5477 }
5478 {
5479 resultobj = SWIG_From_int((int)(result));
5480 }
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5488 PyObject *resultobj;
5489 wxRect *arg1 = (wxRect *) 0 ;
5490 int result;
5491 PyObject * obj0 = 0 ;
5492 char *kwnames[] = {
5493 (char *) "self", NULL
5494 };
5495
5496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5498 if (SWIG_arg_fail(1)) SWIG_fail;
5499 {
5500 PyThreadState* __tstate = wxPyBeginAllowThreads();
5501 result = (int)((wxRect const *)arg1)->GetTop();
5502
5503 wxPyEndAllowThreads(__tstate);
5504 if (PyErr_Occurred()) SWIG_fail;
5505 }
5506 {
5507 resultobj = SWIG_From_int((int)(result));
5508 }
5509 return resultobj;
5510 fail:
5511 return NULL;
5512 }
5513
5514
5515 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5516 PyObject *resultobj;
5517 wxRect *arg1 = (wxRect *) 0 ;
5518 int result;
5519 PyObject * obj0 = 0 ;
5520 char *kwnames[] = {
5521 (char *) "self", NULL
5522 };
5523
5524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5526 if (SWIG_arg_fail(1)) SWIG_fail;
5527 {
5528 PyThreadState* __tstate = wxPyBeginAllowThreads();
5529 result = (int)((wxRect const *)arg1)->GetBottom();
5530
5531 wxPyEndAllowThreads(__tstate);
5532 if (PyErr_Occurred()) SWIG_fail;
5533 }
5534 {
5535 resultobj = SWIG_From_int((int)(result));
5536 }
5537 return resultobj;
5538 fail:
5539 return NULL;
5540 }
5541
5542
5543 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5544 PyObject *resultobj;
5545 wxRect *arg1 = (wxRect *) 0 ;
5546 int result;
5547 PyObject * obj0 = 0 ;
5548 char *kwnames[] = {
5549 (char *) "self", NULL
5550 };
5551
5552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5554 if (SWIG_arg_fail(1)) SWIG_fail;
5555 {
5556 PyThreadState* __tstate = wxPyBeginAllowThreads();
5557 result = (int)((wxRect const *)arg1)->GetRight();
5558
5559 wxPyEndAllowThreads(__tstate);
5560 if (PyErr_Occurred()) SWIG_fail;
5561 }
5562 {
5563 resultobj = SWIG_From_int((int)(result));
5564 }
5565 return resultobj;
5566 fail:
5567 return NULL;
5568 }
5569
5570
5571 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5572 PyObject *resultobj;
5573 wxRect *arg1 = (wxRect *) 0 ;
5574 int arg2 ;
5575 PyObject * obj0 = 0 ;
5576 PyObject * obj1 = 0 ;
5577 char *kwnames[] = {
5578 (char *) "self",(char *) "left", NULL
5579 };
5580
5581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5583 if (SWIG_arg_fail(1)) SWIG_fail;
5584 {
5585 arg2 = (int)(SWIG_As_int(obj1));
5586 if (SWIG_arg_fail(2)) SWIG_fail;
5587 }
5588 {
5589 PyThreadState* __tstate = wxPyBeginAllowThreads();
5590 (arg1)->SetLeft(arg2);
5591
5592 wxPyEndAllowThreads(__tstate);
5593 if (PyErr_Occurred()) SWIG_fail;
5594 }
5595 Py_INCREF(Py_None); resultobj = Py_None;
5596 return resultobj;
5597 fail:
5598 return NULL;
5599 }
5600
5601
5602 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5603 PyObject *resultobj;
5604 wxRect *arg1 = (wxRect *) 0 ;
5605 int arg2 ;
5606 PyObject * obj0 = 0 ;
5607 PyObject * obj1 = 0 ;
5608 char *kwnames[] = {
5609 (char *) "self",(char *) "right", NULL
5610 };
5611
5612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5614 if (SWIG_arg_fail(1)) SWIG_fail;
5615 {
5616 arg2 = (int)(SWIG_As_int(obj1));
5617 if (SWIG_arg_fail(2)) SWIG_fail;
5618 }
5619 {
5620 PyThreadState* __tstate = wxPyBeginAllowThreads();
5621 (arg1)->SetRight(arg2);
5622
5623 wxPyEndAllowThreads(__tstate);
5624 if (PyErr_Occurred()) SWIG_fail;
5625 }
5626 Py_INCREF(Py_None); resultobj = Py_None;
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5634 PyObject *resultobj;
5635 wxRect *arg1 = (wxRect *) 0 ;
5636 int arg2 ;
5637 PyObject * obj0 = 0 ;
5638 PyObject * obj1 = 0 ;
5639 char *kwnames[] = {
5640 (char *) "self",(char *) "top", NULL
5641 };
5642
5643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5645 if (SWIG_arg_fail(1)) SWIG_fail;
5646 {
5647 arg2 = (int)(SWIG_As_int(obj1));
5648 if (SWIG_arg_fail(2)) SWIG_fail;
5649 }
5650 {
5651 PyThreadState* __tstate = wxPyBeginAllowThreads();
5652 (arg1)->SetTop(arg2);
5653
5654 wxPyEndAllowThreads(__tstate);
5655 if (PyErr_Occurred()) SWIG_fail;
5656 }
5657 Py_INCREF(Py_None); resultobj = Py_None;
5658 return resultobj;
5659 fail:
5660 return NULL;
5661 }
5662
5663
5664 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5665 PyObject *resultobj;
5666 wxRect *arg1 = (wxRect *) 0 ;
5667 int arg2 ;
5668 PyObject * obj0 = 0 ;
5669 PyObject * obj1 = 0 ;
5670 char *kwnames[] = {
5671 (char *) "self",(char *) "bottom", NULL
5672 };
5673
5674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5676 if (SWIG_arg_fail(1)) SWIG_fail;
5677 {
5678 arg2 = (int)(SWIG_As_int(obj1));
5679 if (SWIG_arg_fail(2)) SWIG_fail;
5680 }
5681 {
5682 PyThreadState* __tstate = wxPyBeginAllowThreads();
5683 (arg1)->SetBottom(arg2);
5684
5685 wxPyEndAllowThreads(__tstate);
5686 if (PyErr_Occurred()) SWIG_fail;
5687 }
5688 Py_INCREF(Py_None); resultobj = Py_None;
5689 return resultobj;
5690 fail:
5691 return NULL;
5692 }
5693
5694
5695 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5696 PyObject *resultobj;
5697 wxRect *arg1 = (wxRect *) 0 ;
5698 int arg2 ;
5699 int arg3 ;
5700 wxRect *result;
5701 PyObject * obj0 = 0 ;
5702 PyObject * obj1 = 0 ;
5703 PyObject * obj2 = 0 ;
5704 char *kwnames[] = {
5705 (char *) "self",(char *) "dx",(char *) "dy", NULL
5706 };
5707
5708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5710 if (SWIG_arg_fail(1)) SWIG_fail;
5711 {
5712 arg2 = (int)(SWIG_As_int(obj1));
5713 if (SWIG_arg_fail(2)) SWIG_fail;
5714 }
5715 {
5716 arg3 = (int)(SWIG_As_int(obj2));
5717 if (SWIG_arg_fail(3)) SWIG_fail;
5718 }
5719 {
5720 PyThreadState* __tstate = wxPyBeginAllowThreads();
5721 {
5722 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5723 result = (wxRect *) &_result_ref;
5724 }
5725
5726 wxPyEndAllowThreads(__tstate);
5727 if (PyErr_Occurred()) SWIG_fail;
5728 }
5729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5730 return resultobj;
5731 fail:
5732 return NULL;
5733 }
5734
5735
5736 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5737 PyObject *resultobj;
5738 wxRect *arg1 = (wxRect *) 0 ;
5739 int arg2 ;
5740 int arg3 ;
5741 wxRect *result;
5742 PyObject * obj0 = 0 ;
5743 PyObject * obj1 = 0 ;
5744 PyObject * obj2 = 0 ;
5745 char *kwnames[] = {
5746 (char *) "self",(char *) "dx",(char *) "dy", NULL
5747 };
5748
5749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5751 if (SWIG_arg_fail(1)) SWIG_fail;
5752 {
5753 arg2 = (int)(SWIG_As_int(obj1));
5754 if (SWIG_arg_fail(2)) SWIG_fail;
5755 }
5756 {
5757 arg3 = (int)(SWIG_As_int(obj2));
5758 if (SWIG_arg_fail(3)) SWIG_fail;
5759 }
5760 {
5761 PyThreadState* __tstate = wxPyBeginAllowThreads();
5762 {
5763 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5764 result = (wxRect *) &_result_ref;
5765 }
5766
5767 wxPyEndAllowThreads(__tstate);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj;
5779 wxRect *arg1 = (wxRect *) 0 ;
5780 int arg2 ;
5781 int arg3 ;
5782 PyObject * obj0 = 0 ;
5783 PyObject * obj1 = 0 ;
5784 PyObject * obj2 = 0 ;
5785 char *kwnames[] = {
5786 (char *) "self",(char *) "dx",(char *) "dy", NULL
5787 };
5788
5789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5791 if (SWIG_arg_fail(1)) SWIG_fail;
5792 {
5793 arg2 = (int)(SWIG_As_int(obj1));
5794 if (SWIG_arg_fail(2)) SWIG_fail;
5795 }
5796 {
5797 arg3 = (int)(SWIG_As_int(obj2));
5798 if (SWIG_arg_fail(3)) SWIG_fail;
5799 }
5800 {
5801 PyThreadState* __tstate = wxPyBeginAllowThreads();
5802 (arg1)->Offset(arg2,arg3);
5803
5804 wxPyEndAllowThreads(__tstate);
5805 if (PyErr_Occurred()) SWIG_fail;
5806 }
5807 Py_INCREF(Py_None); resultobj = Py_None;
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj;
5816 wxRect *arg1 = (wxRect *) 0 ;
5817 wxPoint *arg2 = 0 ;
5818 wxPoint temp2 ;
5819 PyObject * obj0 = 0 ;
5820 PyObject * obj1 = 0 ;
5821 char *kwnames[] = {
5822 (char *) "self",(char *) "pt", NULL
5823 };
5824
5825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5827 if (SWIG_arg_fail(1)) SWIG_fail;
5828 {
5829 arg2 = &temp2;
5830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5831 }
5832 {
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 (arg1)->Offset((wxPoint const &)*arg2);
5835
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 Py_INCREF(Py_None); resultobj = Py_None;
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj;
5848 wxRect *arg1 = (wxRect *) 0 ;
5849 wxRect *arg2 = 0 ;
5850 wxRect result;
5851 wxRect temp2 ;
5852 PyObject * obj0 = 0 ;
5853 PyObject * obj1 = 0 ;
5854 char *kwnames[] = {
5855 (char *) "self",(char *) "rect", NULL
5856 };
5857
5858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5860 if (SWIG_arg_fail(1)) SWIG_fail;
5861 {
5862 arg2 = &temp2;
5863 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5864 }
5865 {
5866 PyThreadState* __tstate = wxPyBeginAllowThreads();
5867 result = (arg1)->Intersect((wxRect const &)*arg2);
5868
5869 wxPyEndAllowThreads(__tstate);
5870 if (PyErr_Occurred()) SWIG_fail;
5871 }
5872 {
5873 wxRect * resultptr;
5874 resultptr = new wxRect((wxRect &)(result));
5875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5876 }
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj;
5885 wxRect *arg1 = (wxRect *) 0 ;
5886 wxRect *arg2 = 0 ;
5887 wxRect result;
5888 wxRect temp2 ;
5889 PyObject * obj0 = 0 ;
5890 PyObject * obj1 = 0 ;
5891 char *kwnames[] = {
5892 (char *) "self",(char *) "rect", NULL
5893 };
5894
5895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5897 if (SWIG_arg_fail(1)) SWIG_fail;
5898 {
5899 arg2 = &temp2;
5900 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5901 }
5902 {
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 result = (arg1)->Union((wxRect const &)*arg2);
5905
5906 wxPyEndAllowThreads(__tstate);
5907 if (PyErr_Occurred()) SWIG_fail;
5908 }
5909 {
5910 wxRect * resultptr;
5911 resultptr = new wxRect((wxRect &)(result));
5912 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5913 }
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj;
5922 wxRect *arg1 = (wxRect *) 0 ;
5923 wxRect *arg2 = 0 ;
5924 wxRect result;
5925 wxRect temp2 ;
5926 PyObject * obj0 = 0 ;
5927 PyObject * obj1 = 0 ;
5928 char *kwnames[] = {
5929 (char *) "self",(char *) "rect", NULL
5930 };
5931
5932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5934 if (SWIG_arg_fail(1)) SWIG_fail;
5935 {
5936 arg2 = &temp2;
5937 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5938 }
5939 {
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5942
5943 wxPyEndAllowThreads(__tstate);
5944 if (PyErr_Occurred()) SWIG_fail;
5945 }
5946 {
5947 wxRect * resultptr;
5948 resultptr = new wxRect((wxRect &)(result));
5949 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5950 }
5951 return resultobj;
5952 fail:
5953 return NULL;
5954 }
5955
5956
5957 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5958 PyObject *resultobj;
5959 wxRect *arg1 = (wxRect *) 0 ;
5960 wxRect *arg2 = 0 ;
5961 wxRect *result;
5962 wxRect temp2 ;
5963 PyObject * obj0 = 0 ;
5964 PyObject * obj1 = 0 ;
5965 char *kwnames[] = {
5966 (char *) "self",(char *) "rect", NULL
5967 };
5968
5969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5971 if (SWIG_arg_fail(1)) SWIG_fail;
5972 {
5973 arg2 = &temp2;
5974 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5975 }
5976 {
5977 PyThreadState* __tstate = wxPyBeginAllowThreads();
5978 {
5979 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5980 result = (wxRect *) &_result_ref;
5981 }
5982
5983 wxPyEndAllowThreads(__tstate);
5984 if (PyErr_Occurred()) SWIG_fail;
5985 }
5986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5987 return resultobj;
5988 fail:
5989 return NULL;
5990 }
5991
5992
5993 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5994 PyObject *resultobj;
5995 wxRect *arg1 = (wxRect *) 0 ;
5996 wxRect *arg2 = 0 ;
5997 bool result;
5998 wxRect temp2 ;
5999 PyObject * obj0 = 0 ;
6000 PyObject * obj1 = 0 ;
6001 char *kwnames[] = {
6002 (char *) "self",(char *) "rect", NULL
6003 };
6004
6005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6007 if (SWIG_arg_fail(1)) SWIG_fail;
6008 {
6009 arg2 = &temp2;
6010 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6011 }
6012 {
6013 PyThreadState* __tstate = wxPyBeginAllowThreads();
6014 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6015
6016 wxPyEndAllowThreads(__tstate);
6017 if (PyErr_Occurred()) SWIG_fail;
6018 }
6019 {
6020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6021 }
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6029 PyObject *resultobj;
6030 wxRect *arg1 = (wxRect *) 0 ;
6031 wxRect *arg2 = 0 ;
6032 bool result;
6033 wxRect temp2 ;
6034 PyObject * obj0 = 0 ;
6035 PyObject * obj1 = 0 ;
6036 char *kwnames[] = {
6037 (char *) "self",(char *) "rect", NULL
6038 };
6039
6040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6042 if (SWIG_arg_fail(1)) SWIG_fail;
6043 {
6044 arg2 = &temp2;
6045 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6046 }
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6050
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 {
6055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6056 }
6057 return resultobj;
6058 fail:
6059 return NULL;
6060 }
6061
6062
6063 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6064 PyObject *resultobj;
6065 wxRect *arg1 = (wxRect *) 0 ;
6066 int arg2 ;
6067 int arg3 ;
6068 bool result;
6069 PyObject * obj0 = 0 ;
6070 PyObject * obj1 = 0 ;
6071 PyObject * obj2 = 0 ;
6072 char *kwnames[] = {
6073 (char *) "self",(char *) "x",(char *) "y", NULL
6074 };
6075
6076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6078 if (SWIG_arg_fail(1)) SWIG_fail;
6079 {
6080 arg2 = (int)(SWIG_As_int(obj1));
6081 if (SWIG_arg_fail(2)) SWIG_fail;
6082 }
6083 {
6084 arg3 = (int)(SWIG_As_int(obj2));
6085 if (SWIG_arg_fail(3)) SWIG_fail;
6086 }
6087 {
6088 PyThreadState* __tstate = wxPyBeginAllowThreads();
6089 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6090
6091 wxPyEndAllowThreads(__tstate);
6092 if (PyErr_Occurred()) SWIG_fail;
6093 }
6094 {
6095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6096 }
6097 return resultobj;
6098 fail:
6099 return NULL;
6100 }
6101
6102
6103 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6104 PyObject *resultobj;
6105 wxRect *arg1 = (wxRect *) 0 ;
6106 wxPoint *arg2 = 0 ;
6107 bool result;
6108 wxPoint temp2 ;
6109 PyObject * obj0 = 0 ;
6110 PyObject * obj1 = 0 ;
6111 char *kwnames[] = {
6112 (char *) "self",(char *) "pt", NULL
6113 };
6114
6115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6117 if (SWIG_arg_fail(1)) SWIG_fail;
6118 {
6119 arg2 = &temp2;
6120 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6121 }
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6125
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 {
6130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6131 }
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6139 PyObject *resultobj;
6140 wxRect *arg1 = (wxRect *) 0 ;
6141 wxRect *arg2 = 0 ;
6142 bool result;
6143 wxRect temp2 ;
6144 PyObject * obj0 = 0 ;
6145 PyObject * obj1 = 0 ;
6146 char *kwnames[] = {
6147 (char *) "self",(char *) "rect", NULL
6148 };
6149
6150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6152 if (SWIG_arg_fail(1)) SWIG_fail;
6153 {
6154 arg2 = &temp2;
6155 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6156 }
6157 {
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 {
6165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6166 }
6167 return resultobj;
6168 fail:
6169 return NULL;
6170 }
6171
6172
6173 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6174 PyObject *resultobj;
6175 wxRect *arg1 = (wxRect *) 0 ;
6176 int arg2 ;
6177 PyObject * obj0 = 0 ;
6178 PyObject * obj1 = 0 ;
6179 char *kwnames[] = {
6180 (char *) "self",(char *) "x", NULL
6181 };
6182
6183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6185 if (SWIG_arg_fail(1)) SWIG_fail;
6186 {
6187 arg2 = (int)(SWIG_As_int(obj1));
6188 if (SWIG_arg_fail(2)) SWIG_fail;
6189 }
6190 if (arg1) (arg1)->x = arg2;
6191
6192 Py_INCREF(Py_None); resultobj = Py_None;
6193 return resultobj;
6194 fail:
6195 return NULL;
6196 }
6197
6198
6199 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6200 PyObject *resultobj;
6201 wxRect *arg1 = (wxRect *) 0 ;
6202 int result;
6203 PyObject * obj0 = 0 ;
6204 char *kwnames[] = {
6205 (char *) "self", NULL
6206 };
6207
6208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6210 if (SWIG_arg_fail(1)) SWIG_fail;
6211 result = (int) ((arg1)->x);
6212
6213 {
6214 resultobj = SWIG_From_int((int)(result));
6215 }
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj;
6224 wxRect *arg1 = (wxRect *) 0 ;
6225 int arg2 ;
6226 PyObject * obj0 = 0 ;
6227 PyObject * obj1 = 0 ;
6228 char *kwnames[] = {
6229 (char *) "self",(char *) "y", NULL
6230 };
6231
6232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6234 if (SWIG_arg_fail(1)) SWIG_fail;
6235 {
6236 arg2 = (int)(SWIG_As_int(obj1));
6237 if (SWIG_arg_fail(2)) SWIG_fail;
6238 }
6239 if (arg1) (arg1)->y = arg2;
6240
6241 Py_INCREF(Py_None); resultobj = Py_None;
6242 return resultobj;
6243 fail:
6244 return NULL;
6245 }
6246
6247
6248 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6249 PyObject *resultobj;
6250 wxRect *arg1 = (wxRect *) 0 ;
6251 int result;
6252 PyObject * obj0 = 0 ;
6253 char *kwnames[] = {
6254 (char *) "self", NULL
6255 };
6256
6257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6259 if (SWIG_arg_fail(1)) SWIG_fail;
6260 result = (int) ((arg1)->y);
6261
6262 {
6263 resultobj = SWIG_From_int((int)(result));
6264 }
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj;
6273 wxRect *arg1 = (wxRect *) 0 ;
6274 int arg2 ;
6275 PyObject * obj0 = 0 ;
6276 PyObject * obj1 = 0 ;
6277 char *kwnames[] = {
6278 (char *) "self",(char *) "width", NULL
6279 };
6280
6281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6283 if (SWIG_arg_fail(1)) SWIG_fail;
6284 {
6285 arg2 = (int)(SWIG_As_int(obj1));
6286 if (SWIG_arg_fail(2)) SWIG_fail;
6287 }
6288 if (arg1) (arg1)->width = arg2;
6289
6290 Py_INCREF(Py_None); resultobj = Py_None;
6291 return resultobj;
6292 fail:
6293 return NULL;
6294 }
6295
6296
6297 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6298 PyObject *resultobj;
6299 wxRect *arg1 = (wxRect *) 0 ;
6300 int result;
6301 PyObject * obj0 = 0 ;
6302 char *kwnames[] = {
6303 (char *) "self", NULL
6304 };
6305
6306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6308 if (SWIG_arg_fail(1)) SWIG_fail;
6309 result = (int) ((arg1)->width);
6310
6311 {
6312 resultobj = SWIG_From_int((int)(result));
6313 }
6314 return resultobj;
6315 fail:
6316 return NULL;
6317 }
6318
6319
6320 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6321 PyObject *resultobj;
6322 wxRect *arg1 = (wxRect *) 0 ;
6323 int arg2 ;
6324 PyObject * obj0 = 0 ;
6325 PyObject * obj1 = 0 ;
6326 char *kwnames[] = {
6327 (char *) "self",(char *) "height", NULL
6328 };
6329
6330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6332 if (SWIG_arg_fail(1)) SWIG_fail;
6333 {
6334 arg2 = (int)(SWIG_As_int(obj1));
6335 if (SWIG_arg_fail(2)) SWIG_fail;
6336 }
6337 if (arg1) (arg1)->height = arg2;
6338
6339 Py_INCREF(Py_None); resultobj = Py_None;
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6347 PyObject *resultobj;
6348 wxRect *arg1 = (wxRect *) 0 ;
6349 int result;
6350 PyObject * obj0 = 0 ;
6351 char *kwnames[] = {
6352 (char *) "self", NULL
6353 };
6354
6355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6357 if (SWIG_arg_fail(1)) SWIG_fail;
6358 result = (int) ((arg1)->height);
6359
6360 {
6361 resultobj = SWIG_From_int((int)(result));
6362 }
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6370 PyObject *resultobj;
6371 wxRect *arg1 = (wxRect *) 0 ;
6372 int arg2 = (int) 0 ;
6373 int arg3 = (int) 0 ;
6374 int arg4 = (int) 0 ;
6375 int arg5 = (int) 0 ;
6376 PyObject * obj0 = 0 ;
6377 PyObject * obj1 = 0 ;
6378 PyObject * obj2 = 0 ;
6379 PyObject * obj3 = 0 ;
6380 PyObject * obj4 = 0 ;
6381 char *kwnames[] = {
6382 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6383 };
6384
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(1)) SWIG_fail;
6388 if (obj1) {
6389 {
6390 arg2 = (int)(SWIG_As_int(obj1));
6391 if (SWIG_arg_fail(2)) SWIG_fail;
6392 }
6393 }
6394 if (obj2) {
6395 {
6396 arg3 = (int)(SWIG_As_int(obj2));
6397 if (SWIG_arg_fail(3)) SWIG_fail;
6398 }
6399 }
6400 if (obj3) {
6401 {
6402 arg4 = (int)(SWIG_As_int(obj3));
6403 if (SWIG_arg_fail(4)) SWIG_fail;
6404 }
6405 }
6406 if (obj4) {
6407 {
6408 arg5 = (int)(SWIG_As_int(obj4));
6409 if (SWIG_arg_fail(5)) SWIG_fail;
6410 }
6411 }
6412 {
6413 PyThreadState* __tstate = wxPyBeginAllowThreads();
6414 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6415
6416 wxPyEndAllowThreads(__tstate);
6417 if (PyErr_Occurred()) SWIG_fail;
6418 }
6419 Py_INCREF(Py_None); resultobj = Py_None;
6420 return resultobj;
6421 fail:
6422 return NULL;
6423 }
6424
6425
6426 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6427 PyObject *resultobj;
6428 wxRect *arg1 = (wxRect *) 0 ;
6429 PyObject *result;
6430 PyObject * obj0 = 0 ;
6431 char *kwnames[] = {
6432 (char *) "self", NULL
6433 };
6434
6435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6437 if (SWIG_arg_fail(1)) SWIG_fail;
6438 {
6439 PyThreadState* __tstate = wxPyBeginAllowThreads();
6440 result = (PyObject *)wxRect_Get(arg1);
6441
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 resultobj = result;
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6453 PyObject *obj;
6454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6455 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6456 Py_INCREF(obj);
6457 return Py_BuildValue((char *)"");
6458 }
6459 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6460 PyObject *resultobj;
6461 wxRect *arg1 = (wxRect *) 0 ;
6462 wxRect *arg2 = (wxRect *) 0 ;
6463 PyObject *result;
6464 PyObject * obj0 = 0 ;
6465 PyObject * obj1 = 0 ;
6466 char *kwnames[] = {
6467 (char *) "r1",(char *) "r2", NULL
6468 };
6469
6470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6472 if (SWIG_arg_fail(1)) SWIG_fail;
6473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6474 if (SWIG_arg_fail(2)) SWIG_fail;
6475 {
6476 if (!wxPyCheckForApp()) SWIG_fail;
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (PyObject *)wxIntersectRect(arg1,arg2);
6479
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = result;
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj;
6492 double arg1 = (double) 0.0 ;
6493 double arg2 = (double) 0.0 ;
6494 wxPoint2D *result;
6495 PyObject * obj0 = 0 ;
6496 PyObject * obj1 = 0 ;
6497 char *kwnames[] = {
6498 (char *) "x",(char *) "y", NULL
6499 };
6500
6501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6502 if (obj0) {
6503 {
6504 arg1 = (double)(SWIG_As_double(obj0));
6505 if (SWIG_arg_fail(1)) SWIG_fail;
6506 }
6507 }
6508 if (obj1) {
6509 {
6510 arg2 = (double)(SWIG_As_double(obj1));
6511 if (SWIG_arg_fail(2)) SWIG_fail;
6512 }
6513 }
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6517
6518 wxPyEndAllowThreads(__tstate);
6519 if (PyErr_Occurred()) SWIG_fail;
6520 }
6521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6522 return resultobj;
6523 fail:
6524 return NULL;
6525 }
6526
6527
6528 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6529 PyObject *resultobj;
6530 wxPoint2D *arg1 = 0 ;
6531 wxPoint2D *result;
6532 wxPoint2D temp1 ;
6533 PyObject * obj0 = 0 ;
6534 char *kwnames[] = {
6535 (char *) "pt", NULL
6536 };
6537
6538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6539 {
6540 arg1 = &temp1;
6541 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6542 }
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6546
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj;
6559 wxPoint *arg1 = 0 ;
6560 wxPoint2D *result;
6561 wxPoint temp1 ;
6562 PyObject * obj0 = 0 ;
6563 char *kwnames[] = {
6564 (char *) "pt", NULL
6565 };
6566
6567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6568 {
6569 arg1 = &temp1;
6570 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6571 }
6572 {
6573 PyThreadState* __tstate = wxPyBeginAllowThreads();
6574 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6575
6576 wxPyEndAllowThreads(__tstate);
6577 if (PyErr_Occurred()) SWIG_fail;
6578 }
6579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6580 return resultobj;
6581 fail:
6582 return NULL;
6583 }
6584
6585
6586 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6587 PyObject *resultobj;
6588 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6589 int *arg2 = (int *) 0 ;
6590 int *arg3 = (int *) 0 ;
6591 int temp2 ;
6592 int res2 = 0 ;
6593 int temp3 ;
6594 int res3 = 0 ;
6595 PyObject * obj0 = 0 ;
6596 char *kwnames[] = {
6597 (char *) "self", NULL
6598 };
6599
6600 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6601 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6604 if (SWIG_arg_fail(1)) SWIG_fail;
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6608
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 Py_INCREF(Py_None); resultobj = Py_None;
6613 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6614 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6615 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6616 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6624 PyObject *resultobj;
6625 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6626 int *arg2 = (int *) 0 ;
6627 int *arg3 = (int *) 0 ;
6628 int temp2 ;
6629 int res2 = 0 ;
6630 int temp3 ;
6631 int res3 = 0 ;
6632 PyObject * obj0 = 0 ;
6633 char *kwnames[] = {
6634 (char *) "self", NULL
6635 };
6636
6637 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6638 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6641 if (SWIG_arg_fail(1)) SWIG_fail;
6642 {
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6645
6646 wxPyEndAllowThreads(__tstate);
6647 if (PyErr_Occurred()) SWIG_fail;
6648 }
6649 Py_INCREF(Py_None); resultobj = Py_None;
6650 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6651 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6652 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6653 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6654 return resultobj;
6655 fail:
6656 return NULL;
6657 }
6658
6659
6660 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6661 PyObject *resultobj;
6662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6663 double result;
6664 PyObject * obj0 = 0 ;
6665 char *kwnames[] = {
6666 (char *) "self", NULL
6667 };
6668
6669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6671 if (SWIG_arg_fail(1)) SWIG_fail;
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6675
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 {
6680 resultobj = SWIG_From_double((double)(result));
6681 }
6682 return resultobj;
6683 fail:
6684 return NULL;
6685 }
6686
6687
6688 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6689 PyObject *resultobj;
6690 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6691 double result;
6692 PyObject * obj0 = 0 ;
6693 char *kwnames[] = {
6694 (char *) "self", NULL
6695 };
6696
6697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6699 if (SWIG_arg_fail(1)) SWIG_fail;
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6703
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 {
6708 resultobj = SWIG_From_double((double)(result));
6709 }
6710 return resultobj;
6711 fail:
6712 return NULL;
6713 }
6714
6715
6716 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6717 PyObject *resultobj;
6718 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6719 double arg2 ;
6720 PyObject * obj0 = 0 ;
6721 PyObject * obj1 = 0 ;
6722 char *kwnames[] = {
6723 (char *) "self",(char *) "length", NULL
6724 };
6725
6726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6728 if (SWIG_arg_fail(1)) SWIG_fail;
6729 {
6730 arg2 = (double)(SWIG_As_double(obj1));
6731 if (SWIG_arg_fail(2)) SWIG_fail;
6732 }
6733 {
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 (arg1)->SetVectorLength(arg2);
6736
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 Py_INCREF(Py_None); resultobj = Py_None;
6741 return resultobj;
6742 fail:
6743 return NULL;
6744 }
6745
6746
6747 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6748 PyObject *resultobj;
6749 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6750 double arg2 ;
6751 PyObject * obj0 = 0 ;
6752 PyObject * obj1 = 0 ;
6753 char *kwnames[] = {
6754 (char *) "self",(char *) "degrees", NULL
6755 };
6756
6757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6759 if (SWIG_arg_fail(1)) SWIG_fail;
6760 {
6761 arg2 = (double)(SWIG_As_double(obj1));
6762 if (SWIG_arg_fail(2)) SWIG_fail;
6763 }
6764 {
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 (arg1)->SetVectorAngle(arg2);
6767
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 Py_INCREF(Py_None); resultobj = Py_None;
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6779 PyObject *resultobj;
6780 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6781 wxPoint2D *arg2 = 0 ;
6782 double result;
6783 wxPoint2D temp2 ;
6784 PyObject * obj0 = 0 ;
6785 PyObject * obj1 = 0 ;
6786 char *kwnames[] = {
6787 (char *) "self",(char *) "pt", NULL
6788 };
6789
6790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6792 if (SWIG_arg_fail(1)) SWIG_fail;
6793 {
6794 arg2 = &temp2;
6795 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6796 }
6797 {
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6800
6801 wxPyEndAllowThreads(__tstate);
6802 if (PyErr_Occurred()) SWIG_fail;
6803 }
6804 {
6805 resultobj = SWIG_From_double((double)(result));
6806 }
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj;
6815 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6816 wxPoint2D *arg2 = 0 ;
6817 double result;
6818 wxPoint2D temp2 ;
6819 PyObject * obj0 = 0 ;
6820 PyObject * obj1 = 0 ;
6821 char *kwnames[] = {
6822 (char *) "self",(char *) "pt", NULL
6823 };
6824
6825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6827 if (SWIG_arg_fail(1)) SWIG_fail;
6828 {
6829 arg2 = &temp2;
6830 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6831 }
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6835
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 {
6840 resultobj = SWIG_From_double((double)(result));
6841 }
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6849 PyObject *resultobj;
6850 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6851 wxPoint2D *arg2 = 0 ;
6852 double result;
6853 wxPoint2D temp2 ;
6854 PyObject * obj0 = 0 ;
6855 PyObject * obj1 = 0 ;
6856 char *kwnames[] = {
6857 (char *) "self",(char *) "vec", NULL
6858 };
6859
6860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6862 if (SWIG_arg_fail(1)) SWIG_fail;
6863 {
6864 arg2 = &temp2;
6865 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6866 }
6867 {
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6870
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 {
6875 resultobj = SWIG_From_double((double)(result));
6876 }
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj;
6885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6886 wxPoint2D *arg2 = 0 ;
6887 double result;
6888 wxPoint2D temp2 ;
6889 PyObject * obj0 = 0 ;
6890 PyObject * obj1 = 0 ;
6891 char *kwnames[] = {
6892 (char *) "self",(char *) "vec", NULL
6893 };
6894
6895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6897 if (SWIG_arg_fail(1)) SWIG_fail;
6898 {
6899 arg2 = &temp2;
6900 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6901 }
6902 {
6903 PyThreadState* __tstate = wxPyBeginAllowThreads();
6904 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6905
6906 wxPyEndAllowThreads(__tstate);
6907 if (PyErr_Occurred()) SWIG_fail;
6908 }
6909 {
6910 resultobj = SWIG_From_double((double)(result));
6911 }
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6919 PyObject *resultobj;
6920 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6921 wxPoint2D result;
6922 PyObject * obj0 = 0 ;
6923 char *kwnames[] = {
6924 (char *) "self", NULL
6925 };
6926
6927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6929 if (SWIG_arg_fail(1)) SWIG_fail;
6930 {
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 result = (arg1)->operator -();
6933
6934 wxPyEndAllowThreads(__tstate);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 {
6938 wxPoint2D * resultptr;
6939 resultptr = new wxPoint2D((wxPoint2D &)(result));
6940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6941 }
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj;
6950 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6951 wxPoint2D *arg2 = 0 ;
6952 wxPoint2D *result;
6953 wxPoint2D temp2 ;
6954 PyObject * obj0 = 0 ;
6955 PyObject * obj1 = 0 ;
6956 char *kwnames[] = {
6957 (char *) "self",(char *) "pt", NULL
6958 };
6959
6960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6962 if (SWIG_arg_fail(1)) SWIG_fail;
6963 {
6964 arg2 = &temp2;
6965 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6966 }
6967 {
6968 PyThreadState* __tstate = wxPyBeginAllowThreads();
6969 {
6970 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6971 result = (wxPoint2D *) &_result_ref;
6972 }
6973
6974 wxPyEndAllowThreads(__tstate);
6975 if (PyErr_Occurred()) SWIG_fail;
6976 }
6977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6978 return resultobj;
6979 fail:
6980 return NULL;
6981 }
6982
6983
6984 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6985 PyObject *resultobj;
6986 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6987 wxPoint2D *arg2 = 0 ;
6988 wxPoint2D *result;
6989 wxPoint2D temp2 ;
6990 PyObject * obj0 = 0 ;
6991 PyObject * obj1 = 0 ;
6992 char *kwnames[] = {
6993 (char *) "self",(char *) "pt", NULL
6994 };
6995
6996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6998 if (SWIG_arg_fail(1)) SWIG_fail;
6999 {
7000 arg2 = &temp2;
7001 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7002 }
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 {
7006 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7007 result = (wxPoint2D *) &_result_ref;
7008 }
7009
7010 wxPyEndAllowThreads(__tstate);
7011 if (PyErr_Occurred()) SWIG_fail;
7012 }
7013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7014 return resultobj;
7015 fail:
7016 return NULL;
7017 }
7018
7019
7020 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7021 PyObject *resultobj;
7022 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7023 wxPoint2D *arg2 = 0 ;
7024 wxPoint2D *result;
7025 wxPoint2D temp2 ;
7026 PyObject * obj0 = 0 ;
7027 PyObject * obj1 = 0 ;
7028 char *kwnames[] = {
7029 (char *) "self",(char *) "pt", NULL
7030 };
7031
7032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7034 if (SWIG_arg_fail(1)) SWIG_fail;
7035 {
7036 arg2 = &temp2;
7037 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7038 }
7039 {
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 {
7042 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7043 result = (wxPoint2D *) &_result_ref;
7044 }
7045
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7050 return resultobj;
7051 fail:
7052 return NULL;
7053 }
7054
7055
7056 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7057 PyObject *resultobj;
7058 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7059 wxPoint2D *arg2 = 0 ;
7060 wxPoint2D *result;
7061 wxPoint2D temp2 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char *kwnames[] = {
7065 (char *) "self",(char *) "pt", NULL
7066 };
7067
7068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7070 if (SWIG_arg_fail(1)) SWIG_fail;
7071 {
7072 arg2 = &temp2;
7073 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7074 }
7075 {
7076 PyThreadState* __tstate = wxPyBeginAllowThreads();
7077 {
7078 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7079 result = (wxPoint2D *) &_result_ref;
7080 }
7081
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7093 PyObject *resultobj;
7094 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7095 wxPoint2D *arg2 = 0 ;
7096 bool result;
7097 wxPoint2D temp2 ;
7098 PyObject * obj0 = 0 ;
7099 PyObject * obj1 = 0 ;
7100 char *kwnames[] = {
7101 (char *) "self",(char *) "pt", NULL
7102 };
7103
7104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7106 if (SWIG_arg_fail(1)) SWIG_fail;
7107 {
7108 arg2 = &temp2;
7109 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7110 }
7111 {
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7114
7115 wxPyEndAllowThreads(__tstate);
7116 if (PyErr_Occurred()) SWIG_fail;
7117 }
7118 {
7119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7120 }
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj;
7129 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7130 wxPoint2D *arg2 = 0 ;
7131 bool result;
7132 wxPoint2D temp2 ;
7133 PyObject * obj0 = 0 ;
7134 PyObject * obj1 = 0 ;
7135 char *kwnames[] = {
7136 (char *) "self",(char *) "pt", NULL
7137 };
7138
7139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7141 if (SWIG_arg_fail(1)) SWIG_fail;
7142 {
7143 arg2 = &temp2;
7144 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7145 }
7146 {
7147 PyThreadState* __tstate = wxPyBeginAllowThreads();
7148 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7149
7150 wxPyEndAllowThreads(__tstate);
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 {
7154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7155 }
7156 return resultobj;
7157 fail:
7158 return NULL;
7159 }
7160
7161
7162 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7163 PyObject *resultobj;
7164 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7165 double arg2 ;
7166 PyObject * obj0 = 0 ;
7167 PyObject * obj1 = 0 ;
7168 char *kwnames[] = {
7169 (char *) "self",(char *) "m_x", NULL
7170 };
7171
7172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7174 if (SWIG_arg_fail(1)) SWIG_fail;
7175 {
7176 arg2 = (double)(SWIG_As_double(obj1));
7177 if (SWIG_arg_fail(2)) SWIG_fail;
7178 }
7179 if (arg1) (arg1)->m_x = arg2;
7180
7181 Py_INCREF(Py_None); resultobj = Py_None;
7182 return resultobj;
7183 fail:
7184 return NULL;
7185 }
7186
7187
7188 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7189 PyObject *resultobj;
7190 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7191 double result;
7192 PyObject * obj0 = 0 ;
7193 char *kwnames[] = {
7194 (char *) "self", NULL
7195 };
7196
7197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7199 if (SWIG_arg_fail(1)) SWIG_fail;
7200 result = (double) ((arg1)->m_x);
7201
7202 {
7203 resultobj = SWIG_From_double((double)(result));
7204 }
7205 return resultobj;
7206 fail:
7207 return NULL;
7208 }
7209
7210
7211 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7212 PyObject *resultobj;
7213 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7214 double arg2 ;
7215 PyObject * obj0 = 0 ;
7216 PyObject * obj1 = 0 ;
7217 char *kwnames[] = {
7218 (char *) "self",(char *) "m_y", NULL
7219 };
7220
7221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7223 if (SWIG_arg_fail(1)) SWIG_fail;
7224 {
7225 arg2 = (double)(SWIG_As_double(obj1));
7226 if (SWIG_arg_fail(2)) SWIG_fail;
7227 }
7228 if (arg1) (arg1)->m_y = arg2;
7229
7230 Py_INCREF(Py_None); resultobj = Py_None;
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj;
7239 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7240 double result;
7241 PyObject * obj0 = 0 ;
7242 char *kwnames[] = {
7243 (char *) "self", NULL
7244 };
7245
7246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7248 if (SWIG_arg_fail(1)) SWIG_fail;
7249 result = (double) ((arg1)->m_y);
7250
7251 {
7252 resultobj = SWIG_From_double((double)(result));
7253 }
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj;
7262 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7263 double arg2 = (double) 0 ;
7264 double arg3 = (double) 0 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 PyObject * obj2 = 0 ;
7268 char *kwnames[] = {
7269 (char *) "self",(char *) "x",(char *) "y", NULL
7270 };
7271
7272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7274 if (SWIG_arg_fail(1)) SWIG_fail;
7275 if (obj1) {
7276 {
7277 arg2 = (double)(SWIG_As_double(obj1));
7278 if (SWIG_arg_fail(2)) SWIG_fail;
7279 }
7280 }
7281 if (obj2) {
7282 {
7283 arg3 = (double)(SWIG_As_double(obj2));
7284 if (SWIG_arg_fail(3)) SWIG_fail;
7285 }
7286 }
7287 {
7288 PyThreadState* __tstate = wxPyBeginAllowThreads();
7289 wxPoint2D_Set(arg1,arg2,arg3);
7290
7291 wxPyEndAllowThreads(__tstate);
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 Py_INCREF(Py_None); resultobj = Py_None;
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7302 PyObject *resultobj;
7303 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7304 PyObject *result;
7305 PyObject * obj0 = 0 ;
7306 char *kwnames[] = {
7307 (char *) "self", NULL
7308 };
7309
7310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7312 if (SWIG_arg_fail(1)) SWIG_fail;
7313 {
7314 PyThreadState* __tstate = wxPyBeginAllowThreads();
7315 result = (PyObject *)wxPoint2D_Get(arg1);
7316
7317 wxPyEndAllowThreads(__tstate);
7318 if (PyErr_Occurred()) SWIG_fail;
7319 }
7320 resultobj = result;
7321 return resultobj;
7322 fail:
7323 return NULL;
7324 }
7325
7326
7327 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7328 PyObject *obj;
7329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7330 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7331 Py_INCREF(obj);
7332 return Py_BuildValue((char *)"");
7333 }
7334 static int _wrap_DefaultPosition_set(PyObject *) {
7335 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7336 return 1;
7337 }
7338
7339
7340 static PyObject *_wrap_DefaultPosition_get(void) {
7341 PyObject *pyobj;
7342
7343 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7344 return pyobj;
7345 }
7346
7347
7348 static int _wrap_DefaultSize_set(PyObject *) {
7349 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7350 return 1;
7351 }
7352
7353
7354 static PyObject *_wrap_DefaultSize_get(void) {
7355 PyObject *pyobj;
7356
7357 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7358 return pyobj;
7359 }
7360
7361
7362 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7363 PyObject *resultobj;
7364 PyObject *arg1 = (PyObject *) 0 ;
7365 wxPyInputStream *result;
7366 PyObject * obj0 = 0 ;
7367 char *kwnames[] = {
7368 (char *) "p", NULL
7369 };
7370
7371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7372 arg1 = obj0;
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj;
7389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7390 PyObject * obj0 = 0 ;
7391 char *kwnames[] = {
7392 (char *) "self", NULL
7393 };
7394
7395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7397 if (SWIG_arg_fail(1)) SWIG_fail;
7398 {
7399 PyThreadState* __tstate = wxPyBeginAllowThreads();
7400 delete arg1;
7401
7402 wxPyEndAllowThreads(__tstate);
7403 if (PyErr_Occurred()) SWIG_fail;
7404 }
7405 Py_INCREF(Py_None); resultobj = Py_None;
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7413 PyObject *resultobj;
7414 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7415 PyObject * obj0 = 0 ;
7416 char *kwnames[] = {
7417 (char *) "self", NULL
7418 };
7419
7420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7422 if (SWIG_arg_fail(1)) SWIG_fail;
7423 {
7424 PyThreadState* __tstate = wxPyBeginAllowThreads();
7425 (arg1)->close();
7426
7427 wxPyEndAllowThreads(__tstate);
7428 if (PyErr_Occurred()) SWIG_fail;
7429 }
7430 Py_INCREF(Py_None); resultobj = Py_None;
7431 return resultobj;
7432 fail:
7433 return NULL;
7434 }
7435
7436
7437 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7438 PyObject *resultobj;
7439 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7440 PyObject * obj0 = 0 ;
7441 char *kwnames[] = {
7442 (char *) "self", NULL
7443 };
7444
7445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7447 if (SWIG_arg_fail(1)) SWIG_fail;
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 (arg1)->flush();
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 Py_INCREF(Py_None); resultobj = Py_None;
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj;
7464 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7465 bool result;
7466 PyObject * obj0 = 0 ;
7467 char *kwnames[] = {
7468 (char *) "self", NULL
7469 };
7470
7471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7473 if (SWIG_arg_fail(1)) SWIG_fail;
7474 {
7475 PyThreadState* __tstate = wxPyBeginAllowThreads();
7476 result = (bool)(arg1)->eof();
7477
7478 wxPyEndAllowThreads(__tstate);
7479 if (PyErr_Occurred()) SWIG_fail;
7480 }
7481 {
7482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7483 }
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7491 PyObject *resultobj;
7492 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7493 int arg2 = (int) -1 ;
7494 PyObject *result;
7495 PyObject * obj0 = 0 ;
7496 PyObject * obj1 = 0 ;
7497 char *kwnames[] = {
7498 (char *) "self",(char *) "size", NULL
7499 };
7500
7501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7503 if (SWIG_arg_fail(1)) SWIG_fail;
7504 if (obj1) {
7505 {
7506 arg2 = (int)(SWIG_As_int(obj1));
7507 if (SWIG_arg_fail(2)) SWIG_fail;
7508 }
7509 }
7510 {
7511 PyThreadState* __tstate = wxPyBeginAllowThreads();
7512 result = (PyObject *)(arg1)->read(arg2);
7513
7514 wxPyEndAllowThreads(__tstate);
7515 if (PyErr_Occurred()) SWIG_fail;
7516 }
7517 resultobj = result;
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7525 PyObject *resultobj;
7526 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7527 int arg2 = (int) -1 ;
7528 PyObject *result;
7529 PyObject * obj0 = 0 ;
7530 PyObject * obj1 = 0 ;
7531 char *kwnames[] = {
7532 (char *) "self",(char *) "size", NULL
7533 };
7534
7535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7537 if (SWIG_arg_fail(1)) SWIG_fail;
7538 if (obj1) {
7539 {
7540 arg2 = (int)(SWIG_As_int(obj1));
7541 if (SWIG_arg_fail(2)) SWIG_fail;
7542 }
7543 }
7544 {
7545 PyThreadState* __tstate = wxPyBeginAllowThreads();
7546 result = (PyObject *)(arg1)->readline(arg2);
7547
7548 wxPyEndAllowThreads(__tstate);
7549 if (PyErr_Occurred()) SWIG_fail;
7550 }
7551 resultobj = result;
7552 return resultobj;
7553 fail:
7554 return NULL;
7555 }
7556
7557
7558 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7559 PyObject *resultobj;
7560 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7561 int arg2 = (int) -1 ;
7562 PyObject *result;
7563 PyObject * obj0 = 0 ;
7564 PyObject * obj1 = 0 ;
7565 char *kwnames[] = {
7566 (char *) "self",(char *) "sizehint", NULL
7567 };
7568
7569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7571 if (SWIG_arg_fail(1)) SWIG_fail;
7572 if (obj1) {
7573 {
7574 arg2 = (int)(SWIG_As_int(obj1));
7575 if (SWIG_arg_fail(2)) SWIG_fail;
7576 }
7577 }
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = (PyObject *)(arg1)->readlines(arg2);
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = result;
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj;
7594 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7595 int arg2 ;
7596 int arg3 = (int) 0 ;
7597 PyObject * obj0 = 0 ;
7598 PyObject * obj1 = 0 ;
7599 PyObject * obj2 = 0 ;
7600 char *kwnames[] = {
7601 (char *) "self",(char *) "offset",(char *) "whence", NULL
7602 };
7603
7604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7606 if (SWIG_arg_fail(1)) SWIG_fail;
7607 {
7608 arg2 = (int)(SWIG_As_int(obj1));
7609 if (SWIG_arg_fail(2)) SWIG_fail;
7610 }
7611 if (obj2) {
7612 {
7613 arg3 = (int)(SWIG_As_int(obj2));
7614 if (SWIG_arg_fail(3)) SWIG_fail;
7615 }
7616 }
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 (arg1)->seek(arg2,arg3);
7620
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 Py_INCREF(Py_None); resultobj = Py_None;
7625 return resultobj;
7626 fail:
7627 return NULL;
7628 }
7629
7630
7631 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7632 PyObject *resultobj;
7633 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7634 int result;
7635 PyObject * obj0 = 0 ;
7636 char *kwnames[] = {
7637 (char *) "self", NULL
7638 };
7639
7640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7642 if (SWIG_arg_fail(1)) SWIG_fail;
7643 {
7644 PyThreadState* __tstate = wxPyBeginAllowThreads();
7645 result = (int)(arg1)->tell();
7646
7647 wxPyEndAllowThreads(__tstate);
7648 if (PyErr_Occurred()) SWIG_fail;
7649 }
7650 {
7651 resultobj = SWIG_From_int((int)(result));
7652 }
7653 return resultobj;
7654 fail:
7655 return NULL;
7656 }
7657
7658
7659 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7660 PyObject *resultobj;
7661 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7662 char result;
7663 PyObject * obj0 = 0 ;
7664 char *kwnames[] = {
7665 (char *) "self", NULL
7666 };
7667
7668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7670 if (SWIG_arg_fail(1)) SWIG_fail;
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 result = (char)(arg1)->Peek();
7674
7675 wxPyEndAllowThreads(__tstate);
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 {
7679 resultobj = SWIG_From_char((char)(result));
7680 }
7681 return resultobj;
7682 fail:
7683 return NULL;
7684 }
7685
7686
7687 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7688 PyObject *resultobj;
7689 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7690 char result;
7691 PyObject * obj0 = 0 ;
7692 char *kwnames[] = {
7693 (char *) "self", NULL
7694 };
7695
7696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7698 if (SWIG_arg_fail(1)) SWIG_fail;
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 result = (char)(arg1)->GetC();
7702
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 {
7707 resultobj = SWIG_From_char((char)(result));
7708 }
7709 return resultobj;
7710 fail:
7711 return NULL;
7712 }
7713
7714
7715 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7716 PyObject *resultobj;
7717 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7718 size_t result;
7719 PyObject * obj0 = 0 ;
7720 char *kwnames[] = {
7721 (char *) "self", NULL
7722 };
7723
7724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7726 if (SWIG_arg_fail(1)) SWIG_fail;
7727 {
7728 PyThreadState* __tstate = wxPyBeginAllowThreads();
7729 result = (size_t)(arg1)->LastRead();
7730
7731 wxPyEndAllowThreads(__tstate);
7732 if (PyErr_Occurred()) SWIG_fail;
7733 }
7734 {
7735 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7736 }
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj;
7745 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7746 bool result;
7747 PyObject * obj0 = 0 ;
7748 char *kwnames[] = {
7749 (char *) "self", NULL
7750 };
7751
7752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7754 if (SWIG_arg_fail(1)) SWIG_fail;
7755 {
7756 PyThreadState* __tstate = wxPyBeginAllowThreads();
7757 result = (bool)(arg1)->CanRead();
7758
7759 wxPyEndAllowThreads(__tstate);
7760 if (PyErr_Occurred()) SWIG_fail;
7761 }
7762 {
7763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7764 }
7765 return resultobj;
7766 fail:
7767 return NULL;
7768 }
7769
7770
7771 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7772 PyObject *resultobj;
7773 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7774 bool result;
7775 PyObject * obj0 = 0 ;
7776 char *kwnames[] = {
7777 (char *) "self", NULL
7778 };
7779
7780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7782 if (SWIG_arg_fail(1)) SWIG_fail;
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 result = (bool)(arg1)->Eof();
7786
7787 wxPyEndAllowThreads(__tstate);
7788 if (PyErr_Occurred()) SWIG_fail;
7789 }
7790 {
7791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7792 }
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7800 PyObject *resultobj;
7801 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7802 char arg2 ;
7803 bool result;
7804 PyObject * obj0 = 0 ;
7805 PyObject * obj1 = 0 ;
7806 char *kwnames[] = {
7807 (char *) "self",(char *) "c", NULL
7808 };
7809
7810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7812 if (SWIG_arg_fail(1)) SWIG_fail;
7813 {
7814 arg2 = (char)(SWIG_As_char(obj1));
7815 if (SWIG_arg_fail(2)) SWIG_fail;
7816 }
7817 {
7818 PyThreadState* __tstate = wxPyBeginAllowThreads();
7819 result = (bool)(arg1)->Ungetch(arg2);
7820
7821 wxPyEndAllowThreads(__tstate);
7822 if (PyErr_Occurred()) SWIG_fail;
7823 }
7824 {
7825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7826 }
7827 return resultobj;
7828 fail:
7829 return NULL;
7830 }
7831
7832
7833 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7834 PyObject *resultobj;
7835 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7836 long arg2 ;
7837 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7838 long result;
7839 PyObject * obj0 = 0 ;
7840 PyObject * obj1 = 0 ;
7841 PyObject * obj2 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "self",(char *) "pos",(char *) "mode", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 arg2 = (long)(SWIG_As_long(obj1));
7851 if (SWIG_arg_fail(2)) SWIG_fail;
7852 }
7853 if (obj2) {
7854 {
7855 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7856 if (SWIG_arg_fail(3)) SWIG_fail;
7857 }
7858 }
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7862
7863 wxPyEndAllowThreads(__tstate);
7864 if (PyErr_Occurred()) SWIG_fail;
7865 }
7866 {
7867 resultobj = SWIG_From_long((long)(result));
7868 }
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7876 PyObject *resultobj;
7877 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7878 long result;
7879 PyObject * obj0 = 0 ;
7880 char *kwnames[] = {
7881 (char *) "self", NULL
7882 };
7883
7884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7886 if (SWIG_arg_fail(1)) SWIG_fail;
7887 {
7888 PyThreadState* __tstate = wxPyBeginAllowThreads();
7889 result = (long)(arg1)->TellI();
7890
7891 wxPyEndAllowThreads(__tstate);
7892 if (PyErr_Occurred()) SWIG_fail;
7893 }
7894 {
7895 resultobj = SWIG_From_long((long)(result));
7896 }
7897 return resultobj;
7898 fail:
7899 return NULL;
7900 }
7901
7902
7903 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7904 PyObject *obj;
7905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7906 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7907 Py_INCREF(obj);
7908 return Py_BuildValue((char *)"");
7909 }
7910 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7911 PyObject *resultobj;
7912 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7913 PyObject *arg2 = (PyObject *) 0 ;
7914 PyObject * obj0 = 0 ;
7915 PyObject * obj1 = 0 ;
7916 char *kwnames[] = {
7917 (char *) "self",(char *) "obj", NULL
7918 };
7919
7920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7922 if (SWIG_arg_fail(1)) SWIG_fail;
7923 arg2 = obj1;
7924 {
7925 PyThreadState* __tstate = wxPyBeginAllowThreads();
7926 wxOutputStream_write(arg1,arg2);
7927
7928 wxPyEndAllowThreads(__tstate);
7929 if (PyErr_Occurred()) SWIG_fail;
7930 }
7931 Py_INCREF(Py_None); resultobj = Py_None;
7932 return resultobj;
7933 fail:
7934 return NULL;
7935 }
7936
7937
7938 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7939 PyObject *obj;
7940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7941 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7942 Py_INCREF(obj);
7943 return Py_BuildValue((char *)"");
7944 }
7945 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7946 PyObject *resultobj;
7947 wxInputStream *arg1 = (wxInputStream *) 0 ;
7948 wxString *arg2 = 0 ;
7949 wxString *arg3 = 0 ;
7950 wxString *arg4 = 0 ;
7951 wxDateTime arg5 ;
7952 wxFSFile *result;
7953 wxPyInputStream *temp1 ;
7954 bool temp2 = false ;
7955 bool temp3 = false ;
7956 bool temp4 = false ;
7957 PyObject * obj0 = 0 ;
7958 PyObject * obj1 = 0 ;
7959 PyObject * obj2 = 0 ;
7960 PyObject * obj3 = 0 ;
7961 PyObject * obj4 = 0 ;
7962 char *kwnames[] = {
7963 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7964 };
7965
7966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7967 {
7968 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7969 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7970 } else {
7971 PyErr_Clear(); // clear the failure of the wxPyConvert above
7972 arg1 = wxPyCBInputStream_create(obj0, true);
7973 if (arg1 == NULL) {
7974 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7975 SWIG_fail;
7976 }
7977 }
7978 }
7979 {
7980 arg2 = wxString_in_helper(obj1);
7981 if (arg2 == NULL) SWIG_fail;
7982 temp2 = true;
7983 }
7984 {
7985 arg3 = wxString_in_helper(obj2);
7986 if (arg3 == NULL) SWIG_fail;
7987 temp3 = true;
7988 }
7989 {
7990 arg4 = wxString_in_helper(obj3);
7991 if (arg4 == NULL) SWIG_fail;
7992 temp4 = true;
7993 }
7994 {
7995 wxDateTime * argp;
7996 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7997 if (SWIG_arg_fail(5)) SWIG_fail;
7998 if (argp == NULL) {
7999 SWIG_null_ref("wxDateTime");
8000 }
8001 if (SWIG_arg_fail(5)) SWIG_fail;
8002 arg5 = *argp;
8003 }
8004 {
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8007
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 {
8012 resultobj = wxPyMake_wxObject(result, 1);
8013 }
8014 {
8015 if (temp2)
8016 delete arg2;
8017 }
8018 {
8019 if (temp3)
8020 delete arg3;
8021 }
8022 {
8023 if (temp4)
8024 delete arg4;
8025 }
8026 return resultobj;
8027 fail:
8028 {
8029 if (temp2)
8030 delete arg2;
8031 }
8032 {
8033 if (temp3)
8034 delete arg3;
8035 }
8036 {
8037 if (temp4)
8038 delete arg4;
8039 }
8040 return NULL;
8041 }
8042
8043
8044 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8045 PyObject *resultobj;
8046 wxFSFile *arg1 = (wxFSFile *) 0 ;
8047 PyObject * obj0 = 0 ;
8048 char *kwnames[] = {
8049 (char *) "self", NULL
8050 };
8051
8052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8054 if (SWIG_arg_fail(1)) SWIG_fail;
8055 {
8056 PyThreadState* __tstate = wxPyBeginAllowThreads();
8057 delete arg1;
8058
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 Py_INCREF(Py_None); resultobj = Py_None;
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8070 PyObject *resultobj;
8071 wxFSFile *arg1 = (wxFSFile *) 0 ;
8072 wxInputStream *result;
8073 PyObject * obj0 = 0 ;
8074 char *kwnames[] = {
8075 (char *) "self", NULL
8076 };
8077
8078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8080 if (SWIG_arg_fail(1)) SWIG_fail;
8081 {
8082 PyThreadState* __tstate = wxPyBeginAllowThreads();
8083 result = (wxInputStream *)(arg1)->GetStream();
8084
8085 wxPyEndAllowThreads(__tstate);
8086 if (PyErr_Occurred()) SWIG_fail;
8087 }
8088 {
8089 wxPyInputStream * _ptr = NULL;
8090
8091 if (result) {
8092 _ptr = new wxPyInputStream(result);
8093 }
8094 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8095 }
8096 return resultobj;
8097 fail:
8098 return NULL;
8099 }
8100
8101
8102 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8103 PyObject *resultobj;
8104 wxFSFile *arg1 = (wxFSFile *) 0 ;
8105 wxString *result;
8106 PyObject * obj0 = 0 ;
8107 char *kwnames[] = {
8108 (char *) "self", NULL
8109 };
8110
8111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8113 if (SWIG_arg_fail(1)) SWIG_fail;
8114 {
8115 PyThreadState* __tstate = wxPyBeginAllowThreads();
8116 {
8117 wxString const &_result_ref = (arg1)->GetMimeType();
8118 result = (wxString *) &_result_ref;
8119 }
8120
8121 wxPyEndAllowThreads(__tstate);
8122 if (PyErr_Occurred()) SWIG_fail;
8123 }
8124 {
8125 #if wxUSE_UNICODE
8126 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8127 #else
8128 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8129 #endif
8130 }
8131 return resultobj;
8132 fail:
8133 return NULL;
8134 }
8135
8136
8137 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8138 PyObject *resultobj;
8139 wxFSFile *arg1 = (wxFSFile *) 0 ;
8140 wxString *result;
8141 PyObject * obj0 = 0 ;
8142 char *kwnames[] = {
8143 (char *) "self", NULL
8144 };
8145
8146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8148 if (SWIG_arg_fail(1)) SWIG_fail;
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 {
8152 wxString const &_result_ref = (arg1)->GetLocation();
8153 result = (wxString *) &_result_ref;
8154 }
8155
8156 wxPyEndAllowThreads(__tstate);
8157 if (PyErr_Occurred()) SWIG_fail;
8158 }
8159 {
8160 #if wxUSE_UNICODE
8161 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8162 #else
8163 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8164 #endif
8165 }
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8173 PyObject *resultobj;
8174 wxFSFile *arg1 = (wxFSFile *) 0 ;
8175 wxString *result;
8176 PyObject * obj0 = 0 ;
8177 char *kwnames[] = {
8178 (char *) "self", NULL
8179 };
8180
8181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8183 if (SWIG_arg_fail(1)) SWIG_fail;
8184 {
8185 PyThreadState* __tstate = wxPyBeginAllowThreads();
8186 {
8187 wxString const &_result_ref = (arg1)->GetAnchor();
8188 result = (wxString *) &_result_ref;
8189 }
8190
8191 wxPyEndAllowThreads(__tstate);
8192 if (PyErr_Occurred()) SWIG_fail;
8193 }
8194 {
8195 #if wxUSE_UNICODE
8196 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8197 #else
8198 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8199 #endif
8200 }
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj;
8209 wxFSFile *arg1 = (wxFSFile *) 0 ;
8210 wxDateTime result;
8211 PyObject * obj0 = 0 ;
8212 char *kwnames[] = {
8213 (char *) "self", NULL
8214 };
8215
8216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8218 if (SWIG_arg_fail(1)) SWIG_fail;
8219 {
8220 PyThreadState* __tstate = wxPyBeginAllowThreads();
8221 result = (arg1)->GetModificationTime();
8222
8223 wxPyEndAllowThreads(__tstate);
8224 if (PyErr_Occurred()) SWIG_fail;
8225 }
8226 {
8227 wxDateTime * resultptr;
8228 resultptr = new wxDateTime((wxDateTime &)(result));
8229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8230 }
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8238 PyObject *obj;
8239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8240 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8241 Py_INCREF(obj);
8242 return Py_BuildValue((char *)"");
8243 }
8244 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8245 PyObject *obj;
8246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8247 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8248 Py_INCREF(obj);
8249 return Py_BuildValue((char *)"");
8250 }
8251 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8252 PyObject *resultobj;
8253 wxPyFileSystemHandler *result;
8254 char *kwnames[] = {
8255 NULL
8256 };
8257
8258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8262
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8267 return resultobj;
8268 fail:
8269 return NULL;
8270 }
8271
8272
8273 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8274 PyObject *resultobj;
8275 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8276 PyObject *arg2 = (PyObject *) 0 ;
8277 PyObject *arg3 = (PyObject *) 0 ;
8278 PyObject * obj0 = 0 ;
8279 PyObject * obj1 = 0 ;
8280 PyObject * obj2 = 0 ;
8281 char *kwnames[] = {
8282 (char *) "self",(char *) "self",(char *) "_class", NULL
8283 };
8284
8285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8287 if (SWIG_arg_fail(1)) SWIG_fail;
8288 arg2 = obj1;
8289 arg3 = obj2;
8290 {
8291 PyThreadState* __tstate = wxPyBeginAllowThreads();
8292 (arg1)->_setCallbackInfo(arg2,arg3);
8293
8294 wxPyEndAllowThreads(__tstate);
8295 if (PyErr_Occurred()) SWIG_fail;
8296 }
8297 Py_INCREF(Py_None); resultobj = Py_None;
8298 return resultobj;
8299 fail:
8300 return NULL;
8301 }
8302
8303
8304 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8305 PyObject *resultobj;
8306 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8307 wxString *arg2 = 0 ;
8308 bool result;
8309 bool temp2 = false ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self",(char *) "location", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 {
8320 arg2 = wxString_in_helper(obj1);
8321 if (arg2 == NULL) SWIG_fail;
8322 temp2 = true;
8323 }
8324 {
8325 PyThreadState* __tstate = wxPyBeginAllowThreads();
8326 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8327
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 {
8332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8333 }
8334 {
8335 if (temp2)
8336 delete arg2;
8337 }
8338 return resultobj;
8339 fail:
8340 {
8341 if (temp2)
8342 delete arg2;
8343 }
8344 return NULL;
8345 }
8346
8347
8348 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj;
8350 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8351 wxFileSystem *arg2 = 0 ;
8352 wxString *arg3 = 0 ;
8353 wxFSFile *result;
8354 bool temp3 = false ;
8355 PyObject * obj0 = 0 ;
8356 PyObject * obj1 = 0 ;
8357 PyObject * obj2 = 0 ;
8358 char *kwnames[] = {
8359 (char *) "self",(char *) "fs",(char *) "location", NULL
8360 };
8361
8362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8364 if (SWIG_arg_fail(1)) SWIG_fail;
8365 {
8366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8367 if (SWIG_arg_fail(2)) SWIG_fail;
8368 if (arg2 == NULL) {
8369 SWIG_null_ref("wxFileSystem");
8370 }
8371 if (SWIG_arg_fail(2)) SWIG_fail;
8372 }
8373 {
8374 arg3 = wxString_in_helper(obj2);
8375 if (arg3 == NULL) SWIG_fail;
8376 temp3 = true;
8377 }
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8381
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 {
8386 resultobj = wxPyMake_wxObject(result, 1);
8387 }
8388 {
8389 if (temp3)
8390 delete arg3;
8391 }
8392 return resultobj;
8393 fail:
8394 {
8395 if (temp3)
8396 delete arg3;
8397 }
8398 return NULL;
8399 }
8400
8401
8402 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8403 PyObject *resultobj;
8404 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8405 wxString *arg2 = 0 ;
8406 int arg3 = (int) 0 ;
8407 wxString result;
8408 bool temp2 = false ;
8409 PyObject * obj0 = 0 ;
8410 PyObject * obj1 = 0 ;
8411 PyObject * obj2 = 0 ;
8412 char *kwnames[] = {
8413 (char *) "self",(char *) "spec",(char *) "flags", NULL
8414 };
8415
8416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8418 if (SWIG_arg_fail(1)) SWIG_fail;
8419 {
8420 arg2 = wxString_in_helper(obj1);
8421 if (arg2 == NULL) SWIG_fail;
8422 temp2 = true;
8423 }
8424 if (obj2) {
8425 {
8426 arg3 = (int)(SWIG_As_int(obj2));
8427 if (SWIG_arg_fail(3)) SWIG_fail;
8428 }
8429 }
8430 {
8431 PyThreadState* __tstate = wxPyBeginAllowThreads();
8432 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8433
8434 wxPyEndAllowThreads(__tstate);
8435 if (PyErr_Occurred()) SWIG_fail;
8436 }
8437 {
8438 #if wxUSE_UNICODE
8439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8440 #else
8441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8442 #endif
8443 }
8444 {
8445 if (temp2)
8446 delete arg2;
8447 }
8448 return resultobj;
8449 fail:
8450 {
8451 if (temp2)
8452 delete arg2;
8453 }
8454 return NULL;
8455 }
8456
8457
8458 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj;
8460 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8461 wxString result;
8462 PyObject * obj0 = 0 ;
8463 char *kwnames[] = {
8464 (char *) "self", NULL
8465 };
8466
8467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8469 if (SWIG_arg_fail(1)) SWIG_fail;
8470 {
8471 PyThreadState* __tstate = wxPyBeginAllowThreads();
8472 result = (arg1)->FindNext();
8473
8474 wxPyEndAllowThreads(__tstate);
8475 if (PyErr_Occurred()) SWIG_fail;
8476 }
8477 {
8478 #if wxUSE_UNICODE
8479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8480 #else
8481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8482 #endif
8483 }
8484 return resultobj;
8485 fail:
8486 return NULL;
8487 }
8488
8489
8490 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8491 PyObject *resultobj;
8492 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8493 wxString *arg2 = 0 ;
8494 wxString result;
8495 bool temp2 = false ;
8496 PyObject * obj0 = 0 ;
8497 PyObject * obj1 = 0 ;
8498 char *kwnames[] = {
8499 (char *) "self",(char *) "location", NULL
8500 };
8501
8502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8504 if (SWIG_arg_fail(1)) SWIG_fail;
8505 {
8506 arg2 = wxString_in_helper(obj1);
8507 if (arg2 == NULL) SWIG_fail;
8508 temp2 = true;
8509 }
8510 {
8511 PyThreadState* __tstate = wxPyBeginAllowThreads();
8512 result = (arg1)->GetProtocol((wxString const &)*arg2);
8513
8514 wxPyEndAllowThreads(__tstate);
8515 if (PyErr_Occurred()) SWIG_fail;
8516 }
8517 {
8518 #if wxUSE_UNICODE
8519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8520 #else
8521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8522 #endif
8523 }
8524 {
8525 if (temp2)
8526 delete arg2;
8527 }
8528 return resultobj;
8529 fail:
8530 {
8531 if (temp2)
8532 delete arg2;
8533 }
8534 return NULL;
8535 }
8536
8537
8538 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj;
8540 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8541 wxString *arg2 = 0 ;
8542 wxString result;
8543 bool temp2 = false ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char *kwnames[] = {
8547 (char *) "self",(char *) "location", NULL
8548 };
8549
8550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8552 if (SWIG_arg_fail(1)) SWIG_fail;
8553 {
8554 arg2 = wxString_in_helper(obj1);
8555 if (arg2 == NULL) SWIG_fail;
8556 temp2 = true;
8557 }
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8561
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 #if wxUSE_UNICODE
8567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8568 #else
8569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8570 #endif
8571 }
8572 {
8573 if (temp2)
8574 delete arg2;
8575 }
8576 return resultobj;
8577 fail:
8578 {
8579 if (temp2)
8580 delete arg2;
8581 }
8582 return NULL;
8583 }
8584
8585
8586 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8587 PyObject *resultobj;
8588 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8589 wxString *arg2 = 0 ;
8590 wxString result;
8591 bool temp2 = false ;
8592 PyObject * obj0 = 0 ;
8593 PyObject * obj1 = 0 ;
8594 char *kwnames[] = {
8595 (char *) "self",(char *) "location", NULL
8596 };
8597
8598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8600 if (SWIG_arg_fail(1)) SWIG_fail;
8601 {
8602 arg2 = wxString_in_helper(obj1);
8603 if (arg2 == NULL) SWIG_fail;
8604 temp2 = true;
8605 }
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 result = (arg1)->GetAnchor((wxString const &)*arg2);
8609
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 {
8614 #if wxUSE_UNICODE
8615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8616 #else
8617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8618 #endif
8619 }
8620 {
8621 if (temp2)
8622 delete arg2;
8623 }
8624 return resultobj;
8625 fail:
8626 {
8627 if (temp2)
8628 delete arg2;
8629 }
8630 return NULL;
8631 }
8632
8633
8634 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj;
8636 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8637 wxString *arg2 = 0 ;
8638 wxString result;
8639 bool temp2 = false ;
8640 PyObject * obj0 = 0 ;
8641 PyObject * obj1 = 0 ;
8642 char *kwnames[] = {
8643 (char *) "self",(char *) "location", NULL
8644 };
8645
8646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8648 if (SWIG_arg_fail(1)) SWIG_fail;
8649 {
8650 arg2 = wxString_in_helper(obj1);
8651 if (arg2 == NULL) SWIG_fail;
8652 temp2 = true;
8653 }
8654 {
8655 PyThreadState* __tstate = wxPyBeginAllowThreads();
8656 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8657
8658 wxPyEndAllowThreads(__tstate);
8659 if (PyErr_Occurred()) SWIG_fail;
8660 }
8661 {
8662 #if wxUSE_UNICODE
8663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8664 #else
8665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8666 #endif
8667 }
8668 {
8669 if (temp2)
8670 delete arg2;
8671 }
8672 return resultobj;
8673 fail:
8674 {
8675 if (temp2)
8676 delete arg2;
8677 }
8678 return NULL;
8679 }
8680
8681
8682 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8683 PyObject *resultobj;
8684 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8685 wxString *arg2 = 0 ;
8686 wxString result;
8687 bool temp2 = false ;
8688 PyObject * obj0 = 0 ;
8689 PyObject * obj1 = 0 ;
8690 char *kwnames[] = {
8691 (char *) "self",(char *) "location", NULL
8692 };
8693
8694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8696 if (SWIG_arg_fail(1)) SWIG_fail;
8697 {
8698 arg2 = wxString_in_helper(obj1);
8699 if (arg2 == NULL) SWIG_fail;
8700 temp2 = true;
8701 }
8702 {
8703 PyThreadState* __tstate = wxPyBeginAllowThreads();
8704 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8705
8706 wxPyEndAllowThreads(__tstate);
8707 if (PyErr_Occurred()) SWIG_fail;
8708 }
8709 {
8710 #if wxUSE_UNICODE
8711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8712 #else
8713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8714 #endif
8715 }
8716 {
8717 if (temp2)
8718 delete arg2;
8719 }
8720 return resultobj;
8721 fail:
8722 {
8723 if (temp2)
8724 delete arg2;
8725 }
8726 return NULL;
8727 }
8728
8729
8730 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8731 PyObject *obj;
8732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8733 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8734 Py_INCREF(obj);
8735 return Py_BuildValue((char *)"");
8736 }
8737 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8738 PyObject *resultobj;
8739 wxFileSystem *result;
8740 char *kwnames[] = {
8741 NULL
8742 };
8743
8744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8745 {
8746 PyThreadState* __tstate = wxPyBeginAllowThreads();
8747 result = (wxFileSystem *)new wxFileSystem();
8748
8749 wxPyEndAllowThreads(__tstate);
8750 if (PyErr_Occurred()) SWIG_fail;
8751 }
8752 {
8753 resultobj = wxPyMake_wxObject(result, 1);
8754 }
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj;
8763 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8764 PyObject * obj0 = 0 ;
8765 char *kwnames[] = {
8766 (char *) "self", NULL
8767 };
8768
8769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8771 if (SWIG_arg_fail(1)) SWIG_fail;
8772 {
8773 PyThreadState* __tstate = wxPyBeginAllowThreads();
8774 delete arg1;
8775
8776 wxPyEndAllowThreads(__tstate);
8777 if (PyErr_Occurred()) SWIG_fail;
8778 }
8779 Py_INCREF(Py_None); resultobj = Py_None;
8780 return resultobj;
8781 fail:
8782 return NULL;
8783 }
8784
8785
8786 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8787 PyObject *resultobj;
8788 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8789 wxString *arg2 = 0 ;
8790 bool arg3 = (bool) false ;
8791 bool temp2 = false ;
8792 PyObject * obj0 = 0 ;
8793 PyObject * obj1 = 0 ;
8794 PyObject * obj2 = 0 ;
8795 char *kwnames[] = {
8796 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8797 };
8798
8799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8801 if (SWIG_arg_fail(1)) SWIG_fail;
8802 {
8803 arg2 = wxString_in_helper(obj1);
8804 if (arg2 == NULL) SWIG_fail;
8805 temp2 = true;
8806 }
8807 if (obj2) {
8808 {
8809 arg3 = (bool)(SWIG_As_bool(obj2));
8810 if (SWIG_arg_fail(3)) SWIG_fail;
8811 }
8812 }
8813 {
8814 PyThreadState* __tstate = wxPyBeginAllowThreads();
8815 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8816
8817 wxPyEndAllowThreads(__tstate);
8818 if (PyErr_Occurred()) SWIG_fail;
8819 }
8820 Py_INCREF(Py_None); resultobj = Py_None;
8821 {
8822 if (temp2)
8823 delete arg2;
8824 }
8825 return resultobj;
8826 fail:
8827 {
8828 if (temp2)
8829 delete arg2;
8830 }
8831 return NULL;
8832 }
8833
8834
8835 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj;
8837 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8838 wxString result;
8839 PyObject * obj0 = 0 ;
8840 char *kwnames[] = {
8841 (char *) "self", NULL
8842 };
8843
8844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8846 if (SWIG_arg_fail(1)) SWIG_fail;
8847 {
8848 PyThreadState* __tstate = wxPyBeginAllowThreads();
8849 result = (arg1)->GetPath();
8850
8851 wxPyEndAllowThreads(__tstate);
8852 if (PyErr_Occurred()) SWIG_fail;
8853 }
8854 {
8855 #if wxUSE_UNICODE
8856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8857 #else
8858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8859 #endif
8860 }
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8868 PyObject *resultobj;
8869 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8870 wxString *arg2 = 0 ;
8871 wxFSFile *result;
8872 bool temp2 = false ;
8873 PyObject * obj0 = 0 ;
8874 PyObject * obj1 = 0 ;
8875 char *kwnames[] = {
8876 (char *) "self",(char *) "location", NULL
8877 };
8878
8879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8881 if (SWIG_arg_fail(1)) SWIG_fail;
8882 {
8883 arg2 = wxString_in_helper(obj1);
8884 if (arg2 == NULL) SWIG_fail;
8885 temp2 = true;
8886 }
8887 {
8888 PyThreadState* __tstate = wxPyBeginAllowThreads();
8889 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8890
8891 wxPyEndAllowThreads(__tstate);
8892 if (PyErr_Occurred()) SWIG_fail;
8893 }
8894 {
8895 resultobj = wxPyMake_wxObject(result, 1);
8896 }
8897 {
8898 if (temp2)
8899 delete arg2;
8900 }
8901 return resultobj;
8902 fail:
8903 {
8904 if (temp2)
8905 delete arg2;
8906 }
8907 return NULL;
8908 }
8909
8910
8911 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8912 PyObject *resultobj;
8913 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8914 wxString *arg2 = 0 ;
8915 int arg3 = (int) 0 ;
8916 wxString result;
8917 bool temp2 = false ;
8918 PyObject * obj0 = 0 ;
8919 PyObject * obj1 = 0 ;
8920 PyObject * obj2 = 0 ;
8921 char *kwnames[] = {
8922 (char *) "self",(char *) "spec",(char *) "flags", NULL
8923 };
8924
8925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8927 if (SWIG_arg_fail(1)) SWIG_fail;
8928 {
8929 arg2 = wxString_in_helper(obj1);
8930 if (arg2 == NULL) SWIG_fail;
8931 temp2 = true;
8932 }
8933 if (obj2) {
8934 {
8935 arg3 = (int)(SWIG_As_int(obj2));
8936 if (SWIG_arg_fail(3)) SWIG_fail;
8937 }
8938 }
8939 {
8940 PyThreadState* __tstate = wxPyBeginAllowThreads();
8941 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8942
8943 wxPyEndAllowThreads(__tstate);
8944 if (PyErr_Occurred()) SWIG_fail;
8945 }
8946 {
8947 #if wxUSE_UNICODE
8948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8949 #else
8950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8951 #endif
8952 }
8953 {
8954 if (temp2)
8955 delete arg2;
8956 }
8957 return resultobj;
8958 fail:
8959 {
8960 if (temp2)
8961 delete arg2;
8962 }
8963 return NULL;
8964 }
8965
8966
8967 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8968 PyObject *resultobj;
8969 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8970 wxString result;
8971 PyObject * obj0 = 0 ;
8972 char *kwnames[] = {
8973 (char *) "self", NULL
8974 };
8975
8976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8978 if (SWIG_arg_fail(1)) SWIG_fail;
8979 {
8980 PyThreadState* __tstate = wxPyBeginAllowThreads();
8981 result = (arg1)->FindNext();
8982
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 {
8987 #if wxUSE_UNICODE
8988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8989 #else
8990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8991 #endif
8992 }
8993 return resultobj;
8994 fail:
8995 return NULL;
8996 }
8997
8998
8999 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9000 PyObject *resultobj;
9001 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9002 PyObject * obj0 = 0 ;
9003 char *kwnames[] = {
9004 (char *) "handler", NULL
9005 };
9006
9007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9009 if (SWIG_arg_fail(1)) SWIG_fail;
9010 {
9011 PyThreadState* __tstate = wxPyBeginAllowThreads();
9012 wxFileSystem::AddHandler(arg1);
9013
9014 wxPyEndAllowThreads(__tstate);
9015 if (PyErr_Occurred()) SWIG_fail;
9016 }
9017 Py_INCREF(Py_None); resultobj = Py_None;
9018 return resultobj;
9019 fail:
9020 return NULL;
9021 }
9022
9023
9024 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj;
9026 char *kwnames[] = {
9027 NULL
9028 };
9029
9030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 wxFileSystem::CleanUpHandlers();
9034
9035 wxPyEndAllowThreads(__tstate);
9036 if (PyErr_Occurred()) SWIG_fail;
9037 }
9038 Py_INCREF(Py_None); resultobj = Py_None;
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj;
9047 wxString *arg1 = 0 ;
9048 wxString result;
9049 bool temp1 = false ;
9050 PyObject * obj0 = 0 ;
9051 char *kwnames[] = {
9052 (char *) "filename", NULL
9053 };
9054
9055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9056 {
9057 arg1 = wxString_in_helper(obj0);
9058 if (arg1 == NULL) SWIG_fail;
9059 temp1 = true;
9060 }
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 {
9069 #if wxUSE_UNICODE
9070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9071 #else
9072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9073 #endif
9074 }
9075 {
9076 if (temp1)
9077 delete arg1;
9078 }
9079 return resultobj;
9080 fail:
9081 {
9082 if (temp1)
9083 delete arg1;
9084 }
9085 return NULL;
9086 }
9087
9088
9089 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9090 PyObject *resultobj;
9091 wxString *arg1 = 0 ;
9092 wxString result;
9093 bool temp1 = false ;
9094 PyObject * obj0 = 0 ;
9095 char *kwnames[] = {
9096 (char *) "url", NULL
9097 };
9098
9099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9100 {
9101 arg1 = wxString_in_helper(obj0);
9102 if (arg1 == NULL) SWIG_fail;
9103 temp1 = true;
9104 }
9105 {
9106 PyThreadState* __tstate = wxPyBeginAllowThreads();
9107 result = FileSystem_URLToFileName((wxString const &)*arg1);
9108
9109 wxPyEndAllowThreads(__tstate);
9110 if (PyErr_Occurred()) SWIG_fail;
9111 }
9112 {
9113 #if wxUSE_UNICODE
9114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9115 #else
9116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9117 #endif
9118 }
9119 {
9120 if (temp1)
9121 delete arg1;
9122 }
9123 return resultobj;
9124 fail:
9125 {
9126 if (temp1)
9127 delete arg1;
9128 }
9129 return NULL;
9130 }
9131
9132
9133 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9134 PyObject *obj;
9135 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9136 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9137 Py_INCREF(obj);
9138 return Py_BuildValue((char *)"");
9139 }
9140 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9141 PyObject *resultobj;
9142 wxInternetFSHandler *result;
9143 char *kwnames[] = {
9144 NULL
9145 };
9146
9147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9148 {
9149 PyThreadState* __tstate = wxPyBeginAllowThreads();
9150 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9151
9152 wxPyEndAllowThreads(__tstate);
9153 if (PyErr_Occurred()) SWIG_fail;
9154 }
9155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9156 return resultobj;
9157 fail:
9158 return NULL;
9159 }
9160
9161
9162 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9163 PyObject *resultobj;
9164 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9165 wxString *arg2 = 0 ;
9166 bool result;
9167 bool temp2 = false ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 char *kwnames[] = {
9171 (char *) "self",(char *) "location", NULL
9172 };
9173
9174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9176 if (SWIG_arg_fail(1)) SWIG_fail;
9177 {
9178 arg2 = wxString_in_helper(obj1);
9179 if (arg2 == NULL) SWIG_fail;
9180 temp2 = true;
9181 }
9182 {
9183 PyThreadState* __tstate = wxPyBeginAllowThreads();
9184 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9185
9186 wxPyEndAllowThreads(__tstate);
9187 if (PyErr_Occurred()) SWIG_fail;
9188 }
9189 {
9190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9191 }
9192 {
9193 if (temp2)
9194 delete arg2;
9195 }
9196 return resultobj;
9197 fail:
9198 {
9199 if (temp2)
9200 delete arg2;
9201 }
9202 return NULL;
9203 }
9204
9205
9206 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9207 PyObject *resultobj;
9208 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9209 wxFileSystem *arg2 = 0 ;
9210 wxString *arg3 = 0 ;
9211 wxFSFile *result;
9212 bool temp3 = false ;
9213 PyObject * obj0 = 0 ;
9214 PyObject * obj1 = 0 ;
9215 PyObject * obj2 = 0 ;
9216 char *kwnames[] = {
9217 (char *) "self",(char *) "fs",(char *) "location", NULL
9218 };
9219
9220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9222 if (SWIG_arg_fail(1)) SWIG_fail;
9223 {
9224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9225 if (SWIG_arg_fail(2)) SWIG_fail;
9226 if (arg2 == NULL) {
9227 SWIG_null_ref("wxFileSystem");
9228 }
9229 if (SWIG_arg_fail(2)) SWIG_fail;
9230 }
9231 {
9232 arg3 = wxString_in_helper(obj2);
9233 if (arg3 == NULL) SWIG_fail;
9234 temp3 = true;
9235 }
9236 {
9237 PyThreadState* __tstate = wxPyBeginAllowThreads();
9238 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9239
9240 wxPyEndAllowThreads(__tstate);
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 {
9244 resultobj = wxPyMake_wxObject(result, 1);
9245 }
9246 {
9247 if (temp3)
9248 delete arg3;
9249 }
9250 return resultobj;
9251 fail:
9252 {
9253 if (temp3)
9254 delete arg3;
9255 }
9256 return NULL;
9257 }
9258
9259
9260 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9261 PyObject *obj;
9262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9263 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9264 Py_INCREF(obj);
9265 return Py_BuildValue((char *)"");
9266 }
9267 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj;
9269 wxZipFSHandler *result;
9270 char *kwnames[] = {
9271 NULL
9272 };
9273
9274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 result = (wxZipFSHandler *)new wxZipFSHandler();
9278
9279 wxPyEndAllowThreads(__tstate);
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9283 return resultobj;
9284 fail:
9285 return NULL;
9286 }
9287
9288
9289 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9290 PyObject *resultobj;
9291 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9292 wxString *arg2 = 0 ;
9293 bool result;
9294 bool temp2 = false ;
9295 PyObject * obj0 = 0 ;
9296 PyObject * obj1 = 0 ;
9297 char *kwnames[] = {
9298 (char *) "self",(char *) "location", NULL
9299 };
9300
9301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9303 if (SWIG_arg_fail(1)) SWIG_fail;
9304 {
9305 arg2 = wxString_in_helper(obj1);
9306 if (arg2 == NULL) SWIG_fail;
9307 temp2 = true;
9308 }
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9312
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 {
9317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9318 }
9319 {
9320 if (temp2)
9321 delete arg2;
9322 }
9323 return resultobj;
9324 fail:
9325 {
9326 if (temp2)
9327 delete arg2;
9328 }
9329 return NULL;
9330 }
9331
9332
9333 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj;
9335 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9336 wxFileSystem *arg2 = 0 ;
9337 wxString *arg3 = 0 ;
9338 wxFSFile *result;
9339 bool temp3 = false ;
9340 PyObject * obj0 = 0 ;
9341 PyObject * obj1 = 0 ;
9342 PyObject * obj2 = 0 ;
9343 char *kwnames[] = {
9344 (char *) "self",(char *) "fs",(char *) "location", NULL
9345 };
9346
9347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9349 if (SWIG_arg_fail(1)) SWIG_fail;
9350 {
9351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9352 if (SWIG_arg_fail(2)) SWIG_fail;
9353 if (arg2 == NULL) {
9354 SWIG_null_ref("wxFileSystem");
9355 }
9356 if (SWIG_arg_fail(2)) SWIG_fail;
9357 }
9358 {
9359 arg3 = wxString_in_helper(obj2);
9360 if (arg3 == NULL) SWIG_fail;
9361 temp3 = true;
9362 }
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9366
9367 wxPyEndAllowThreads(__tstate);
9368 if (PyErr_Occurred()) SWIG_fail;
9369 }
9370 {
9371 resultobj = wxPyMake_wxObject(result, 1);
9372 }
9373 {
9374 if (temp3)
9375 delete arg3;
9376 }
9377 return resultobj;
9378 fail:
9379 {
9380 if (temp3)
9381 delete arg3;
9382 }
9383 return NULL;
9384 }
9385
9386
9387 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj;
9389 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9390 wxString *arg2 = 0 ;
9391 int arg3 = (int) 0 ;
9392 wxString result;
9393 bool temp2 = false ;
9394 PyObject * obj0 = 0 ;
9395 PyObject * obj1 = 0 ;
9396 PyObject * obj2 = 0 ;
9397 char *kwnames[] = {
9398 (char *) "self",(char *) "spec",(char *) "flags", NULL
9399 };
9400
9401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9403 if (SWIG_arg_fail(1)) SWIG_fail;
9404 {
9405 arg2 = wxString_in_helper(obj1);
9406 if (arg2 == NULL) SWIG_fail;
9407 temp2 = true;
9408 }
9409 if (obj2) {
9410 {
9411 arg3 = (int)(SWIG_As_int(obj2));
9412 if (SWIG_arg_fail(3)) SWIG_fail;
9413 }
9414 }
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9418
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 {
9423 #if wxUSE_UNICODE
9424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9425 #else
9426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9427 #endif
9428 }
9429 {
9430 if (temp2)
9431 delete arg2;
9432 }
9433 return resultobj;
9434 fail:
9435 {
9436 if (temp2)
9437 delete arg2;
9438 }
9439 return NULL;
9440 }
9441
9442
9443 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9444 PyObject *resultobj;
9445 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9446 wxString result;
9447 PyObject * obj0 = 0 ;
9448 char *kwnames[] = {
9449 (char *) "self", NULL
9450 };
9451
9452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9454 if (SWIG_arg_fail(1)) SWIG_fail;
9455 {
9456 PyThreadState* __tstate = wxPyBeginAllowThreads();
9457 result = (arg1)->FindNext();
9458
9459 wxPyEndAllowThreads(__tstate);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 {
9463 #if wxUSE_UNICODE
9464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9465 #else
9466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9467 #endif
9468 }
9469 return resultobj;
9470 fail:
9471 return NULL;
9472 }
9473
9474
9475 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9476 PyObject *obj;
9477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9478 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9479 Py_INCREF(obj);
9480 return Py_BuildValue((char *)"");
9481 }
9482 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9483 PyObject *resultobj;
9484 wxString *arg1 = 0 ;
9485 wxImage *arg2 = 0 ;
9486 long arg3 ;
9487 bool temp1 = false ;
9488 PyObject * obj0 = 0 ;
9489 PyObject * obj1 = 0 ;
9490 PyObject * obj2 = 0 ;
9491 char *kwnames[] = {
9492 (char *) "filename",(char *) "image",(char *) "type", NULL
9493 };
9494
9495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9496 {
9497 arg1 = wxString_in_helper(obj0);
9498 if (arg1 == NULL) SWIG_fail;
9499 temp1 = true;
9500 }
9501 {
9502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9503 if (SWIG_arg_fail(2)) SWIG_fail;
9504 if (arg2 == NULL) {
9505 SWIG_null_ref("wxImage");
9506 }
9507 if (SWIG_arg_fail(2)) SWIG_fail;
9508 }
9509 {
9510 arg3 = (long)(SWIG_As_long(obj2));
9511 if (SWIG_arg_fail(3)) SWIG_fail;
9512 }
9513 {
9514 PyThreadState* __tstate = wxPyBeginAllowThreads();
9515 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9516
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 Py_INCREF(Py_None); resultobj = Py_None;
9521 {
9522 if (temp1)
9523 delete arg1;
9524 }
9525 return resultobj;
9526 fail:
9527 {
9528 if (temp1)
9529 delete arg1;
9530 }
9531 return NULL;
9532 }
9533
9534
9535 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj;
9537 wxString *arg1 = 0 ;
9538 wxBitmap *arg2 = 0 ;
9539 long arg3 ;
9540 bool temp1 = false ;
9541 PyObject * obj0 = 0 ;
9542 PyObject * obj1 = 0 ;
9543 PyObject * obj2 = 0 ;
9544 char *kwnames[] = {
9545 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9546 };
9547
9548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9549 {
9550 arg1 = wxString_in_helper(obj0);
9551 if (arg1 == NULL) SWIG_fail;
9552 temp1 = true;
9553 }
9554 {
9555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9556 if (SWIG_arg_fail(2)) SWIG_fail;
9557 if (arg2 == NULL) {
9558 SWIG_null_ref("wxBitmap");
9559 }
9560 if (SWIG_arg_fail(2)) SWIG_fail;
9561 }
9562 {
9563 arg3 = (long)(SWIG_As_long(obj2));
9564 if (SWIG_arg_fail(3)) SWIG_fail;
9565 }
9566 {
9567 PyThreadState* __tstate = wxPyBeginAllowThreads();
9568 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9569
9570 wxPyEndAllowThreads(__tstate);
9571 if (PyErr_Occurred()) SWIG_fail;
9572 }
9573 Py_INCREF(Py_None); resultobj = Py_None;
9574 {
9575 if (temp1)
9576 delete arg1;
9577 }
9578 return resultobj;
9579 fail:
9580 {
9581 if (temp1)
9582 delete arg1;
9583 }
9584 return NULL;
9585 }
9586
9587
9588 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9589 PyObject *resultobj;
9590 wxString *arg1 = 0 ;
9591 PyObject *arg2 = (PyObject *) 0 ;
9592 bool temp1 = false ;
9593 PyObject * obj0 = 0 ;
9594 PyObject * obj1 = 0 ;
9595 char *kwnames[] = {
9596 (char *) "filename",(char *) "data", NULL
9597 };
9598
9599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9600 {
9601 arg1 = wxString_in_helper(obj0);
9602 if (arg1 == NULL) SWIG_fail;
9603 temp1 = true;
9604 }
9605 arg2 = obj1;
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9609
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 Py_INCREF(Py_None); resultobj = Py_None;
9614 {
9615 if (temp1)
9616 delete arg1;
9617 }
9618 return resultobj;
9619 fail:
9620 {
9621 if (temp1)
9622 delete arg1;
9623 }
9624 return NULL;
9625 }
9626
9627
9628 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9629 PyObject *resultobj;
9630 wxMemoryFSHandler *result;
9631 char *kwnames[] = {
9632 NULL
9633 };
9634
9635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9636 {
9637 PyThreadState* __tstate = wxPyBeginAllowThreads();
9638 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9639
9640 wxPyEndAllowThreads(__tstate);
9641 if (PyErr_Occurred()) SWIG_fail;
9642 }
9643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9644 return resultobj;
9645 fail:
9646 return NULL;
9647 }
9648
9649
9650 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9651 PyObject *resultobj;
9652 wxString *arg1 = 0 ;
9653 bool temp1 = false ;
9654 PyObject * obj0 = 0 ;
9655 char *kwnames[] = {
9656 (char *) "filename", NULL
9657 };
9658
9659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9660 {
9661 arg1 = wxString_in_helper(obj0);
9662 if (arg1 == NULL) SWIG_fail;
9663 temp1 = true;
9664 }
9665 {
9666 PyThreadState* __tstate = wxPyBeginAllowThreads();
9667 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9668
9669 wxPyEndAllowThreads(__tstate);
9670 if (PyErr_Occurred()) SWIG_fail;
9671 }
9672 Py_INCREF(Py_None); resultobj = Py_None;
9673 {
9674 if (temp1)
9675 delete arg1;
9676 }
9677 return resultobj;
9678 fail:
9679 {
9680 if (temp1)
9681 delete arg1;
9682 }
9683 return NULL;
9684 }
9685
9686
9687 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9688 PyObject *resultobj;
9689 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9690 wxString *arg2 = 0 ;
9691 bool result;
9692 bool temp2 = false ;
9693 PyObject * obj0 = 0 ;
9694 PyObject * obj1 = 0 ;
9695 char *kwnames[] = {
9696 (char *) "self",(char *) "location", NULL
9697 };
9698
9699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9701 if (SWIG_arg_fail(1)) SWIG_fail;
9702 {
9703 arg2 = wxString_in_helper(obj1);
9704 if (arg2 == NULL) SWIG_fail;
9705 temp2 = true;
9706 }
9707 {
9708 PyThreadState* __tstate = wxPyBeginAllowThreads();
9709 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9710
9711 wxPyEndAllowThreads(__tstate);
9712 if (PyErr_Occurred()) SWIG_fail;
9713 }
9714 {
9715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9716 }
9717 {
9718 if (temp2)
9719 delete arg2;
9720 }
9721 return resultobj;
9722 fail:
9723 {
9724 if (temp2)
9725 delete arg2;
9726 }
9727 return NULL;
9728 }
9729
9730
9731 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj;
9733 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9734 wxFileSystem *arg2 = 0 ;
9735 wxString *arg3 = 0 ;
9736 wxFSFile *result;
9737 bool temp3 = false ;
9738 PyObject * obj0 = 0 ;
9739 PyObject * obj1 = 0 ;
9740 PyObject * obj2 = 0 ;
9741 char *kwnames[] = {
9742 (char *) "self",(char *) "fs",(char *) "location", NULL
9743 };
9744
9745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9747 if (SWIG_arg_fail(1)) SWIG_fail;
9748 {
9749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9750 if (SWIG_arg_fail(2)) SWIG_fail;
9751 if (arg2 == NULL) {
9752 SWIG_null_ref("wxFileSystem");
9753 }
9754 if (SWIG_arg_fail(2)) SWIG_fail;
9755 }
9756 {
9757 arg3 = wxString_in_helper(obj2);
9758 if (arg3 == NULL) SWIG_fail;
9759 temp3 = true;
9760 }
9761 {
9762 PyThreadState* __tstate = wxPyBeginAllowThreads();
9763 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9764
9765 wxPyEndAllowThreads(__tstate);
9766 if (PyErr_Occurred()) SWIG_fail;
9767 }
9768 {
9769 resultobj = wxPyMake_wxObject(result, 1);
9770 }
9771 {
9772 if (temp3)
9773 delete arg3;
9774 }
9775 return resultobj;
9776 fail:
9777 {
9778 if (temp3)
9779 delete arg3;
9780 }
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj;
9787 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9788 wxString *arg2 = 0 ;
9789 int arg3 = (int) 0 ;
9790 wxString result;
9791 bool temp2 = false ;
9792 PyObject * obj0 = 0 ;
9793 PyObject * obj1 = 0 ;
9794 PyObject * obj2 = 0 ;
9795 char *kwnames[] = {
9796 (char *) "self",(char *) "spec",(char *) "flags", NULL
9797 };
9798
9799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9801 if (SWIG_arg_fail(1)) SWIG_fail;
9802 {
9803 arg2 = wxString_in_helper(obj1);
9804 if (arg2 == NULL) SWIG_fail;
9805 temp2 = true;
9806 }
9807 if (obj2) {
9808 {
9809 arg3 = (int)(SWIG_As_int(obj2));
9810 if (SWIG_arg_fail(3)) SWIG_fail;
9811 }
9812 }
9813 {
9814 PyThreadState* __tstate = wxPyBeginAllowThreads();
9815 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9816
9817 wxPyEndAllowThreads(__tstate);
9818 if (PyErr_Occurred()) SWIG_fail;
9819 }
9820 {
9821 #if wxUSE_UNICODE
9822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9823 #else
9824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9825 #endif
9826 }
9827 {
9828 if (temp2)
9829 delete arg2;
9830 }
9831 return resultobj;
9832 fail:
9833 {
9834 if (temp2)
9835 delete arg2;
9836 }
9837 return NULL;
9838 }
9839
9840
9841 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9842 PyObject *resultobj;
9843 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9844 wxString result;
9845 PyObject * obj0 = 0 ;
9846 char *kwnames[] = {
9847 (char *) "self", NULL
9848 };
9849
9850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9852 if (SWIG_arg_fail(1)) SWIG_fail;
9853 {
9854 PyThreadState* __tstate = wxPyBeginAllowThreads();
9855 result = (arg1)->FindNext();
9856
9857 wxPyEndAllowThreads(__tstate);
9858 if (PyErr_Occurred()) SWIG_fail;
9859 }
9860 {
9861 #if wxUSE_UNICODE
9862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9863 #else
9864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9865 #endif
9866 }
9867 return resultobj;
9868 fail:
9869 return NULL;
9870 }
9871
9872
9873 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9874 PyObject *obj;
9875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9876 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9877 Py_INCREF(obj);
9878 return Py_BuildValue((char *)"");
9879 }
9880 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj;
9882 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9883 wxString result;
9884 PyObject * obj0 = 0 ;
9885 char *kwnames[] = {
9886 (char *) "self", NULL
9887 };
9888
9889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9891 if (SWIG_arg_fail(1)) SWIG_fail;
9892 {
9893 PyThreadState* __tstate = wxPyBeginAllowThreads();
9894 result = (arg1)->GetName();
9895
9896 wxPyEndAllowThreads(__tstate);
9897 if (PyErr_Occurred()) SWIG_fail;
9898 }
9899 {
9900 #if wxUSE_UNICODE
9901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9902 #else
9903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9904 #endif
9905 }
9906 return resultobj;
9907 fail:
9908 return NULL;
9909 }
9910
9911
9912 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9913 PyObject *resultobj;
9914 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9915 wxString result;
9916 PyObject * obj0 = 0 ;
9917 char *kwnames[] = {
9918 (char *) "self", NULL
9919 };
9920
9921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9923 if (SWIG_arg_fail(1)) SWIG_fail;
9924 {
9925 PyThreadState* __tstate = wxPyBeginAllowThreads();
9926 result = (arg1)->GetExtension();
9927
9928 wxPyEndAllowThreads(__tstate);
9929 if (PyErr_Occurred()) SWIG_fail;
9930 }
9931 {
9932 #if wxUSE_UNICODE
9933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9934 #else
9935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9936 #endif
9937 }
9938 return resultobj;
9939 fail:
9940 return NULL;
9941 }
9942
9943
9944 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9945 PyObject *resultobj;
9946 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9947 long result;
9948 PyObject * obj0 = 0 ;
9949 char *kwnames[] = {
9950 (char *) "self", NULL
9951 };
9952
9953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9955 if (SWIG_arg_fail(1)) SWIG_fail;
9956 {
9957 PyThreadState* __tstate = wxPyBeginAllowThreads();
9958 result = (long)(arg1)->GetType();
9959
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 {
9964 resultobj = SWIG_From_long((long)(result));
9965 }
9966 return resultobj;
9967 fail:
9968 return NULL;
9969 }
9970
9971
9972 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9973 PyObject *resultobj;
9974 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9975 wxString result;
9976 PyObject * obj0 = 0 ;
9977 char *kwnames[] = {
9978 (char *) "self", NULL
9979 };
9980
9981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9983 if (SWIG_arg_fail(1)) SWIG_fail;
9984 {
9985 PyThreadState* __tstate = wxPyBeginAllowThreads();
9986 result = (arg1)->GetMimeType();
9987
9988 wxPyEndAllowThreads(__tstate);
9989 if (PyErr_Occurred()) SWIG_fail;
9990 }
9991 {
9992 #if wxUSE_UNICODE
9993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9994 #else
9995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9996 #endif
9997 }
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj;
10006 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10007 wxString *arg2 = 0 ;
10008 bool result;
10009 bool temp2 = false ;
10010 PyObject * obj0 = 0 ;
10011 PyObject * obj1 = 0 ;
10012 char *kwnames[] = {
10013 (char *) "self",(char *) "name", NULL
10014 };
10015
10016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10018 if (SWIG_arg_fail(1)) SWIG_fail;
10019 {
10020 arg2 = wxString_in_helper(obj1);
10021 if (arg2 == NULL) SWIG_fail;
10022 temp2 = true;
10023 }
10024 {
10025 PyThreadState* __tstate = wxPyBeginAllowThreads();
10026 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10027
10028 wxPyEndAllowThreads(__tstate);
10029 if (PyErr_Occurred()) SWIG_fail;
10030 }
10031 {
10032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10033 }
10034 {
10035 if (temp2)
10036 delete arg2;
10037 }
10038 return resultobj;
10039 fail:
10040 {
10041 if (temp2)
10042 delete arg2;
10043 }
10044 return NULL;
10045 }
10046
10047
10048 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10049 PyObject *resultobj;
10050 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10051 wxString *arg2 = 0 ;
10052 bool temp2 = false ;
10053 PyObject * obj0 = 0 ;
10054 PyObject * obj1 = 0 ;
10055 char *kwnames[] = {
10056 (char *) "self",(char *) "name", NULL
10057 };
10058
10059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10061 if (SWIG_arg_fail(1)) SWIG_fail;
10062 {
10063 arg2 = wxString_in_helper(obj1);
10064 if (arg2 == NULL) SWIG_fail;
10065 temp2 = true;
10066 }
10067 {
10068 PyThreadState* __tstate = wxPyBeginAllowThreads();
10069 (arg1)->SetName((wxString const &)*arg2);
10070
10071 wxPyEndAllowThreads(__tstate);
10072 if (PyErr_Occurred()) SWIG_fail;
10073 }
10074 Py_INCREF(Py_None); resultobj = Py_None;
10075 {
10076 if (temp2)
10077 delete arg2;
10078 }
10079 return resultobj;
10080 fail:
10081 {
10082 if (temp2)
10083 delete arg2;
10084 }
10085 return NULL;
10086 }
10087
10088
10089 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10090 PyObject *resultobj;
10091 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10092 wxString *arg2 = 0 ;
10093 bool temp2 = false ;
10094 PyObject * obj0 = 0 ;
10095 PyObject * obj1 = 0 ;
10096 char *kwnames[] = {
10097 (char *) "self",(char *) "extension", NULL
10098 };
10099
10100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10102 if (SWIG_arg_fail(1)) SWIG_fail;
10103 {
10104 arg2 = wxString_in_helper(obj1);
10105 if (arg2 == NULL) SWIG_fail;
10106 temp2 = true;
10107 }
10108 {
10109 PyThreadState* __tstate = wxPyBeginAllowThreads();
10110 (arg1)->SetExtension((wxString const &)*arg2);
10111
10112 wxPyEndAllowThreads(__tstate);
10113 if (PyErr_Occurred()) SWIG_fail;
10114 }
10115 Py_INCREF(Py_None); resultobj = Py_None;
10116 {
10117 if (temp2)
10118 delete arg2;
10119 }
10120 return resultobj;
10121 fail:
10122 {
10123 if (temp2)
10124 delete arg2;
10125 }
10126 return NULL;
10127 }
10128
10129
10130 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj;
10132 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10133 long arg2 ;
10134 PyObject * obj0 = 0 ;
10135 PyObject * obj1 = 0 ;
10136 char *kwnames[] = {
10137 (char *) "self",(char *) "type", NULL
10138 };
10139
10140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10142 if (SWIG_arg_fail(1)) SWIG_fail;
10143 {
10144 arg2 = (long)(SWIG_As_long(obj1));
10145 if (SWIG_arg_fail(2)) SWIG_fail;
10146 }
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 (arg1)->SetType(arg2);
10150
10151 wxPyEndAllowThreads(__tstate);
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 Py_INCREF(Py_None); resultobj = Py_None;
10155 return resultobj;
10156 fail:
10157 return NULL;
10158 }
10159
10160
10161 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10162 PyObject *resultobj;
10163 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10164 wxString *arg2 = 0 ;
10165 bool temp2 = false ;
10166 PyObject * obj0 = 0 ;
10167 PyObject * obj1 = 0 ;
10168 char *kwnames[] = {
10169 (char *) "self",(char *) "mimetype", NULL
10170 };
10171
10172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10174 if (SWIG_arg_fail(1)) SWIG_fail;
10175 {
10176 arg2 = wxString_in_helper(obj1);
10177 if (arg2 == NULL) SWIG_fail;
10178 temp2 = true;
10179 }
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 (arg1)->SetMimeType((wxString const &)*arg2);
10183
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 Py_INCREF(Py_None); resultobj = Py_None;
10188 {
10189 if (temp2)
10190 delete arg2;
10191 }
10192 return resultobj;
10193 fail:
10194 {
10195 if (temp2)
10196 delete arg2;
10197 }
10198 return NULL;
10199 }
10200
10201
10202 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10203 PyObject *obj;
10204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10205 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10206 Py_INCREF(obj);
10207 return Py_BuildValue((char *)"");
10208 }
10209 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10210 PyObject *resultobj;
10211 wxImageHistogram *result;
10212 char *kwnames[] = {
10213 NULL
10214 };
10215
10216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 result = (wxImageHistogram *)new wxImageHistogram();
10220
10221 wxPyEndAllowThreads(__tstate);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10225 return resultobj;
10226 fail:
10227 return NULL;
10228 }
10229
10230
10231 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10232 PyObject *resultobj;
10233 byte arg1 ;
10234 byte arg2 ;
10235 byte arg3 ;
10236 unsigned long result;
10237 PyObject * obj0 = 0 ;
10238 PyObject * obj1 = 0 ;
10239 PyObject * obj2 = 0 ;
10240 char *kwnames[] = {
10241 (char *) "r",(char *) "g",(char *) "b", NULL
10242 };
10243
10244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10245 {
10246 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10247 if (SWIG_arg_fail(1)) SWIG_fail;
10248 }
10249 {
10250 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10251 if (SWIG_arg_fail(2)) SWIG_fail;
10252 }
10253 {
10254 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10255 if (SWIG_arg_fail(3)) SWIG_fail;
10256 }
10257 {
10258 PyThreadState* __tstate = wxPyBeginAllowThreads();
10259 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10260
10261 wxPyEndAllowThreads(__tstate);
10262 if (PyErr_Occurred()) SWIG_fail;
10263 }
10264 {
10265 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10266 }
10267 return resultobj;
10268 fail:
10269 return NULL;
10270 }
10271
10272
10273 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10274 PyObject *resultobj;
10275 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10276 byte *arg2 = (byte *) 0 ;
10277 byte *arg3 = (byte *) 0 ;
10278 byte *arg4 = (byte *) 0 ;
10279 byte arg5 = (byte) 1 ;
10280 byte arg6 = (byte) 0 ;
10281 byte arg7 = (byte) 0 ;
10282 bool result;
10283 byte temp2 ;
10284 int res2 = 0 ;
10285 byte temp3 ;
10286 int res3 = 0 ;
10287 byte temp4 ;
10288 int res4 = 0 ;
10289 PyObject * obj0 = 0 ;
10290 PyObject * obj1 = 0 ;
10291 PyObject * obj2 = 0 ;
10292 PyObject * obj3 = 0 ;
10293 char *kwnames[] = {
10294 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10295 };
10296
10297 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10298 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10299 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10302 if (SWIG_arg_fail(1)) SWIG_fail;
10303 if (obj1) {
10304 {
10305 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10306 if (SWIG_arg_fail(5)) SWIG_fail;
10307 }
10308 }
10309 if (obj2) {
10310 {
10311 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10312 if (SWIG_arg_fail(6)) SWIG_fail;
10313 }
10314 }
10315 if (obj3) {
10316 {
10317 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10318 if (SWIG_arg_fail(7)) SWIG_fail;
10319 }
10320 }
10321 {
10322 PyThreadState* __tstate = wxPyBeginAllowThreads();
10323 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10324
10325 wxPyEndAllowThreads(__tstate);
10326 if (PyErr_Occurred()) SWIG_fail;
10327 }
10328 {
10329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10330 }
10331 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10332 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10333 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10334 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10335 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10336 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10337 return resultobj;
10338 fail:
10339 return NULL;
10340 }
10341
10342
10343 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10344 PyObject *resultobj;
10345 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10346 unsigned long arg2 ;
10347 unsigned long result;
10348 PyObject * obj0 = 0 ;
10349 PyObject * obj1 = 0 ;
10350 char *kwnames[] = {
10351 (char *) "self",(char *) "key", NULL
10352 };
10353
10354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10356 if (SWIG_arg_fail(1)) SWIG_fail;
10357 {
10358 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10359 if (SWIG_arg_fail(2)) SWIG_fail;
10360 }
10361 {
10362 PyThreadState* __tstate = wxPyBeginAllowThreads();
10363 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10364
10365 wxPyEndAllowThreads(__tstate);
10366 if (PyErr_Occurred()) SWIG_fail;
10367 }
10368 {
10369 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10370 }
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj;
10379 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10380 byte arg2 ;
10381 byte arg3 ;
10382 byte arg4 ;
10383 unsigned long result;
10384 PyObject * obj0 = 0 ;
10385 PyObject * obj1 = 0 ;
10386 PyObject * obj2 = 0 ;
10387 PyObject * obj3 = 0 ;
10388 char *kwnames[] = {
10389 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10390 };
10391
10392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10394 if (SWIG_arg_fail(1)) SWIG_fail;
10395 {
10396 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10397 if (SWIG_arg_fail(2)) SWIG_fail;
10398 }
10399 {
10400 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10401 if (SWIG_arg_fail(3)) SWIG_fail;
10402 }
10403 {
10404 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10405 if (SWIG_arg_fail(4)) SWIG_fail;
10406 }
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10410
10411 wxPyEndAllowThreads(__tstate);
10412 if (PyErr_Occurred()) SWIG_fail;
10413 }
10414 {
10415 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10416 }
10417 return resultobj;
10418 fail:
10419 return NULL;
10420 }
10421
10422
10423 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj;
10425 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10426 wxColour *arg2 = 0 ;
10427 unsigned long result;
10428 wxColour temp2 ;
10429 PyObject * obj0 = 0 ;
10430 PyObject * obj1 = 0 ;
10431 char *kwnames[] = {
10432 (char *) "self",(char *) "colour", NULL
10433 };
10434
10435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10437 if (SWIG_arg_fail(1)) SWIG_fail;
10438 {
10439 arg2 = &temp2;
10440 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10441 }
10442 {
10443 PyThreadState* __tstate = wxPyBeginAllowThreads();
10444 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10445
10446 wxPyEndAllowThreads(__tstate);
10447 if (PyErr_Occurred()) SWIG_fail;
10448 }
10449 {
10450 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10451 }
10452 return resultobj;
10453 fail:
10454 return NULL;
10455 }
10456
10457
10458 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10459 PyObject *obj;
10460 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10461 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10462 Py_INCREF(obj);
10463 return Py_BuildValue((char *)"");
10464 }
10465 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10466 PyObject *resultobj;
10467 wxString *arg1 = 0 ;
10468 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10469 int arg3 = (int) -1 ;
10470 wxImage *result;
10471 bool temp1 = false ;
10472 PyObject * obj0 = 0 ;
10473 PyObject * obj1 = 0 ;
10474 PyObject * obj2 = 0 ;
10475 char *kwnames[] = {
10476 (char *) "name",(char *) "type",(char *) "index", NULL
10477 };
10478
10479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10480 {
10481 arg1 = wxString_in_helper(obj0);
10482 if (arg1 == NULL) SWIG_fail;
10483 temp1 = true;
10484 }
10485 if (obj1) {
10486 {
10487 arg2 = (long)(SWIG_As_long(obj1));
10488 if (SWIG_arg_fail(2)) SWIG_fail;
10489 }
10490 }
10491 if (obj2) {
10492 {
10493 arg3 = (int)(SWIG_As_int(obj2));
10494 if (SWIG_arg_fail(3)) SWIG_fail;
10495 }
10496 }
10497 {
10498 PyThreadState* __tstate = wxPyBeginAllowThreads();
10499 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10500
10501 wxPyEndAllowThreads(__tstate);
10502 if (PyErr_Occurred()) SWIG_fail;
10503 }
10504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10505 {
10506 if (temp1)
10507 delete arg1;
10508 }
10509 return resultobj;
10510 fail:
10511 {
10512 if (temp1)
10513 delete arg1;
10514 }
10515 return NULL;
10516 }
10517
10518
10519 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10520 PyObject *resultobj;
10521 wxImage *arg1 = (wxImage *) 0 ;
10522 PyObject * obj0 = 0 ;
10523 char *kwnames[] = {
10524 (char *) "self", NULL
10525 };
10526
10527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10529 if (SWIG_arg_fail(1)) SWIG_fail;
10530 {
10531 PyThreadState* __tstate = wxPyBeginAllowThreads();
10532 delete arg1;
10533
10534 wxPyEndAllowThreads(__tstate);
10535 if (PyErr_Occurred()) SWIG_fail;
10536 }
10537 Py_INCREF(Py_None); resultobj = Py_None;
10538 return resultobj;
10539 fail:
10540 return NULL;
10541 }
10542
10543
10544 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10545 PyObject *resultobj;
10546 wxString *arg1 = 0 ;
10547 wxString *arg2 = 0 ;
10548 int arg3 = (int) -1 ;
10549 wxImage *result;
10550 bool temp1 = false ;
10551 bool temp2 = false ;
10552 PyObject * obj0 = 0 ;
10553 PyObject * obj1 = 0 ;
10554 PyObject * obj2 = 0 ;
10555 char *kwnames[] = {
10556 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10557 };
10558
10559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10560 {
10561 arg1 = wxString_in_helper(obj0);
10562 if (arg1 == NULL) SWIG_fail;
10563 temp1 = true;
10564 }
10565 {
10566 arg2 = wxString_in_helper(obj1);
10567 if (arg2 == NULL) SWIG_fail;
10568 temp2 = true;
10569 }
10570 if (obj2) {
10571 {
10572 arg3 = (int)(SWIG_As_int(obj2));
10573 if (SWIG_arg_fail(3)) SWIG_fail;
10574 }
10575 }
10576 {
10577 PyThreadState* __tstate = wxPyBeginAllowThreads();
10578 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10579
10580 wxPyEndAllowThreads(__tstate);
10581 if (PyErr_Occurred()) SWIG_fail;
10582 }
10583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10584 {
10585 if (temp1)
10586 delete arg1;
10587 }
10588 {
10589 if (temp2)
10590 delete arg2;
10591 }
10592 return resultobj;
10593 fail:
10594 {
10595 if (temp1)
10596 delete arg1;
10597 }
10598 {
10599 if (temp2)
10600 delete arg2;
10601 }
10602 return NULL;
10603 }
10604
10605
10606 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10607 PyObject *resultobj;
10608 wxInputStream *arg1 = 0 ;
10609 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10610 int arg3 = (int) -1 ;
10611 wxImage *result;
10612 wxPyInputStream *temp1 ;
10613 bool created1 ;
10614 PyObject * obj0 = 0 ;
10615 PyObject * obj1 = 0 ;
10616 PyObject * obj2 = 0 ;
10617 char *kwnames[] = {
10618 (char *) "stream",(char *) "type",(char *) "index", NULL
10619 };
10620
10621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10622 {
10623 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10624 arg1 = temp1->m_wxis;
10625 created1 = false;
10626 } else {
10627 PyErr_Clear(); // clear the failure of the wxPyConvert above
10628 arg1 = wxPyCBInputStream_create(obj0, false);
10629 if (arg1 == NULL) {
10630 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10631 SWIG_fail;
10632 }
10633 created1 = true;
10634 }
10635 }
10636 if (obj1) {
10637 {
10638 arg2 = (long)(SWIG_As_long(obj1));
10639 if (SWIG_arg_fail(2)) SWIG_fail;
10640 }
10641 }
10642 if (obj2) {
10643 {
10644 arg3 = (int)(SWIG_As_int(obj2));
10645 if (SWIG_arg_fail(3)) SWIG_fail;
10646 }
10647 }
10648 {
10649 PyThreadState* __tstate = wxPyBeginAllowThreads();
10650 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10651
10652 wxPyEndAllowThreads(__tstate);
10653 if (PyErr_Occurred()) SWIG_fail;
10654 }
10655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10656 {
10657 if (created1) delete arg1;
10658 }
10659 return resultobj;
10660 fail:
10661 {
10662 if (created1) delete arg1;
10663 }
10664 return NULL;
10665 }
10666
10667
10668 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10669 PyObject *resultobj;
10670 wxInputStream *arg1 = 0 ;
10671 wxString *arg2 = 0 ;
10672 int arg3 = (int) -1 ;
10673 wxImage *result;
10674 wxPyInputStream *temp1 ;
10675 bool created1 ;
10676 bool temp2 = false ;
10677 PyObject * obj0 = 0 ;
10678 PyObject * obj1 = 0 ;
10679 PyObject * obj2 = 0 ;
10680 char *kwnames[] = {
10681 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10682 };
10683
10684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10685 {
10686 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10687 arg1 = temp1->m_wxis;
10688 created1 = false;
10689 } else {
10690 PyErr_Clear(); // clear the failure of the wxPyConvert above
10691 arg1 = wxPyCBInputStream_create(obj0, false);
10692 if (arg1 == NULL) {
10693 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10694 SWIG_fail;
10695 }
10696 created1 = true;
10697 }
10698 }
10699 {
10700 arg2 = wxString_in_helper(obj1);
10701 if (arg2 == NULL) SWIG_fail;
10702 temp2 = true;
10703 }
10704 if (obj2) {
10705 {
10706 arg3 = (int)(SWIG_As_int(obj2));
10707 if (SWIG_arg_fail(3)) SWIG_fail;
10708 }
10709 }
10710 {
10711 PyThreadState* __tstate = wxPyBeginAllowThreads();
10712 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10713
10714 wxPyEndAllowThreads(__tstate);
10715 if (PyErr_Occurred()) SWIG_fail;
10716 }
10717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10718 {
10719 if (created1) delete arg1;
10720 }
10721 {
10722 if (temp2)
10723 delete arg2;
10724 }
10725 return resultobj;
10726 fail:
10727 {
10728 if (created1) delete arg1;
10729 }
10730 {
10731 if (temp2)
10732 delete arg2;
10733 }
10734 return NULL;
10735 }
10736
10737
10738 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10739 PyObject *resultobj;
10740 int arg1 = (int) 0 ;
10741 int arg2 = (int) 0 ;
10742 bool arg3 = (bool) true ;
10743 wxImage *result;
10744 PyObject * obj0 = 0 ;
10745 PyObject * obj1 = 0 ;
10746 PyObject * obj2 = 0 ;
10747 char *kwnames[] = {
10748 (char *) "width",(char *) "height",(char *) "clear", NULL
10749 };
10750
10751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10752 if (obj0) {
10753 {
10754 arg1 = (int)(SWIG_As_int(obj0));
10755 if (SWIG_arg_fail(1)) SWIG_fail;
10756 }
10757 }
10758 if (obj1) {
10759 {
10760 arg2 = (int)(SWIG_As_int(obj1));
10761 if (SWIG_arg_fail(2)) SWIG_fail;
10762 }
10763 }
10764 if (obj2) {
10765 {
10766 arg3 = (bool)(SWIG_As_bool(obj2));
10767 if (SWIG_arg_fail(3)) SWIG_fail;
10768 }
10769 }
10770 {
10771 PyThreadState* __tstate = wxPyBeginAllowThreads();
10772 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10773
10774 wxPyEndAllowThreads(__tstate);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10778 return resultobj;
10779 fail:
10780 return NULL;
10781 }
10782
10783
10784 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10785 PyObject *resultobj;
10786 wxBitmap *arg1 = 0 ;
10787 wxImage *result;
10788 PyObject * obj0 = 0 ;
10789 char *kwnames[] = {
10790 (char *) "bitmap", NULL
10791 };
10792
10793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10794 {
10795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10796 if (SWIG_arg_fail(1)) SWIG_fail;
10797 if (arg1 == NULL) {
10798 SWIG_null_ref("wxBitmap");
10799 }
10800 if (SWIG_arg_fail(1)) SWIG_fail;
10801 }
10802 {
10803 if (!wxPyCheckForApp()) SWIG_fail;
10804 PyThreadState* __tstate = wxPyBeginAllowThreads();
10805 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10806
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10811 return resultobj;
10812 fail:
10813 return NULL;
10814 }
10815
10816
10817 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10818 PyObject *resultobj;
10819 int arg1 ;
10820 int arg2 ;
10821 buffer arg3 ;
10822 int arg4 ;
10823 wxImage *result;
10824 PyObject * obj0 = 0 ;
10825 PyObject * obj1 = 0 ;
10826 PyObject * obj2 = 0 ;
10827 char *kwnames[] = {
10828 (char *) "width",(char *) "height",(char *) "data", NULL
10829 };
10830
10831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10832 {
10833 arg1 = (int)(SWIG_As_int(obj0));
10834 if (SWIG_arg_fail(1)) SWIG_fail;
10835 }
10836 {
10837 arg2 = (int)(SWIG_As_int(obj1));
10838 if (SWIG_arg_fail(2)) SWIG_fail;
10839 }
10840 {
10841 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10842 }
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10846
10847 wxPyEndAllowThreads(__tstate);
10848 if (PyErr_Occurred()) SWIG_fail;
10849 }
10850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10851 return resultobj;
10852 fail:
10853 return NULL;
10854 }
10855
10856
10857 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj;
10859 int arg1 ;
10860 int arg2 ;
10861 buffer arg3 ;
10862 int arg4 ;
10863 buffer arg5 ;
10864 int arg6 ;
10865 wxImage *result;
10866 PyObject * obj0 = 0 ;
10867 PyObject * obj1 = 0 ;
10868 PyObject * obj2 = 0 ;
10869 PyObject * obj3 = 0 ;
10870 char *kwnames[] = {
10871 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10872 };
10873
10874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10875 {
10876 arg1 = (int)(SWIG_As_int(obj0));
10877 if (SWIG_arg_fail(1)) SWIG_fail;
10878 }
10879 {
10880 arg2 = (int)(SWIG_As_int(obj1));
10881 if (SWIG_arg_fail(2)) SWIG_fail;
10882 }
10883 {
10884 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10885 }
10886 {
10887 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10888 }
10889 {
10890 PyThreadState* __tstate = wxPyBeginAllowThreads();
10891 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10892
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj;
10905 wxImage *arg1 = (wxImage *) 0 ;
10906 int arg2 ;
10907 int arg3 ;
10908 bool arg4 = (bool) true ;
10909 PyObject * obj0 = 0 ;
10910 PyObject * obj1 = 0 ;
10911 PyObject * obj2 = 0 ;
10912 PyObject * obj3 = 0 ;
10913 char *kwnames[] = {
10914 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
10915 };
10916
10917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10919 if (SWIG_arg_fail(1)) SWIG_fail;
10920 {
10921 arg2 = (int)(SWIG_As_int(obj1));
10922 if (SWIG_arg_fail(2)) SWIG_fail;
10923 }
10924 {
10925 arg3 = (int)(SWIG_As_int(obj2));
10926 if (SWIG_arg_fail(3)) SWIG_fail;
10927 }
10928 if (obj3) {
10929 {
10930 arg4 = (bool)(SWIG_As_bool(obj3));
10931 if (SWIG_arg_fail(4)) SWIG_fail;
10932 }
10933 }
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 (arg1)->Create(arg2,arg3,arg4);
10937
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 Py_INCREF(Py_None); resultobj = Py_None;
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj;
10950 wxImage *arg1 = (wxImage *) 0 ;
10951 PyObject * obj0 = 0 ;
10952 char *kwnames[] = {
10953 (char *) "self", NULL
10954 };
10955
10956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10958 if (SWIG_arg_fail(1)) SWIG_fail;
10959 {
10960 PyThreadState* __tstate = wxPyBeginAllowThreads();
10961 (arg1)->Destroy();
10962
10963 wxPyEndAllowThreads(__tstate);
10964 if (PyErr_Occurred()) SWIG_fail;
10965 }
10966 Py_INCREF(Py_None); resultobj = Py_None;
10967 return resultobj;
10968 fail:
10969 return NULL;
10970 }
10971
10972
10973 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10974 PyObject *resultobj;
10975 wxImage *arg1 = (wxImage *) 0 ;
10976 int arg2 ;
10977 int arg3 ;
10978 SwigValueWrapper<wxImage > result;
10979 PyObject * obj0 = 0 ;
10980 PyObject * obj1 = 0 ;
10981 PyObject * obj2 = 0 ;
10982 char *kwnames[] = {
10983 (char *) "self",(char *) "width",(char *) "height", NULL
10984 };
10985
10986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10988 if (SWIG_arg_fail(1)) SWIG_fail;
10989 {
10990 arg2 = (int)(SWIG_As_int(obj1));
10991 if (SWIG_arg_fail(2)) SWIG_fail;
10992 }
10993 {
10994 arg3 = (int)(SWIG_As_int(obj2));
10995 if (SWIG_arg_fail(3)) SWIG_fail;
10996 }
10997 {
10998 PyThreadState* __tstate = wxPyBeginAllowThreads();
10999 result = (arg1)->Scale(arg2,arg3);
11000
11001 wxPyEndAllowThreads(__tstate);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 {
11005 wxImage * resultptr;
11006 resultptr = new wxImage((wxImage &)(result));
11007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11008 }
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj;
11017 wxImage *arg1 = (wxImage *) 0 ;
11018 int arg2 ;
11019 int arg3 ;
11020 SwigValueWrapper<wxImage > result;
11021 PyObject * obj0 = 0 ;
11022 PyObject * obj1 = 0 ;
11023 PyObject * obj2 = 0 ;
11024 char *kwnames[] = {
11025 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11026 };
11027
11028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11030 if (SWIG_arg_fail(1)) SWIG_fail;
11031 {
11032 arg2 = (int)(SWIG_As_int(obj1));
11033 if (SWIG_arg_fail(2)) SWIG_fail;
11034 }
11035 {
11036 arg3 = (int)(SWIG_As_int(obj2));
11037 if (SWIG_arg_fail(3)) SWIG_fail;
11038 }
11039 {
11040 PyThreadState* __tstate = wxPyBeginAllowThreads();
11041 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11042
11043 wxPyEndAllowThreads(__tstate);
11044 if (PyErr_Occurred()) SWIG_fail;
11045 }
11046 {
11047 wxImage * resultptr;
11048 resultptr = new wxImage((wxImage &)(result));
11049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11050 }
11051 return resultobj;
11052 fail:
11053 return NULL;
11054 }
11055
11056
11057 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11058 PyObject *resultobj;
11059 wxImage *arg1 = (wxImage *) 0 ;
11060 int arg2 ;
11061 int arg3 ;
11062 wxImage *result;
11063 PyObject * obj0 = 0 ;
11064 PyObject * obj1 = 0 ;
11065 PyObject * obj2 = 0 ;
11066 char *kwnames[] = {
11067 (char *) "self",(char *) "width",(char *) "height", NULL
11068 };
11069
11070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11072 if (SWIG_arg_fail(1)) SWIG_fail;
11073 {
11074 arg2 = (int)(SWIG_As_int(obj1));
11075 if (SWIG_arg_fail(2)) SWIG_fail;
11076 }
11077 {
11078 arg3 = (int)(SWIG_As_int(obj2));
11079 if (SWIG_arg_fail(3)) SWIG_fail;
11080 }
11081 {
11082 PyThreadState* __tstate = wxPyBeginAllowThreads();
11083 {
11084 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11085 result = (wxImage *) &_result_ref;
11086 }
11087
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11092 return resultobj;
11093 fail:
11094 return NULL;
11095 }
11096
11097
11098 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11099 PyObject *resultobj;
11100 wxImage *arg1 = (wxImage *) 0 ;
11101 wxSize *arg2 = 0 ;
11102 wxPoint *arg3 = 0 ;
11103 int arg4 = (int) -1 ;
11104 int arg5 = (int) -1 ;
11105 int arg6 = (int) -1 ;
11106 wxImage *result;
11107 wxSize temp2 ;
11108 wxPoint temp3 ;
11109 PyObject * obj0 = 0 ;
11110 PyObject * obj1 = 0 ;
11111 PyObject * obj2 = 0 ;
11112 PyObject * obj3 = 0 ;
11113 PyObject * obj4 = 0 ;
11114 PyObject * obj5 = 0 ;
11115 char *kwnames[] = {
11116 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11117 };
11118
11119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11121 if (SWIG_arg_fail(1)) SWIG_fail;
11122 {
11123 arg2 = &temp2;
11124 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11125 }
11126 {
11127 arg3 = &temp3;
11128 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11129 }
11130 if (obj3) {
11131 {
11132 arg4 = (int)(SWIG_As_int(obj3));
11133 if (SWIG_arg_fail(4)) SWIG_fail;
11134 }
11135 }
11136 if (obj4) {
11137 {
11138 arg5 = (int)(SWIG_As_int(obj4));
11139 if (SWIG_arg_fail(5)) SWIG_fail;
11140 }
11141 }
11142 if (obj5) {
11143 {
11144 arg6 = (int)(SWIG_As_int(obj5));
11145 if (SWIG_arg_fail(6)) SWIG_fail;
11146 }
11147 }
11148 {
11149 PyThreadState* __tstate = wxPyBeginAllowThreads();
11150 {
11151 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11152 result = (wxImage *) &_result_ref;
11153 }
11154
11155 wxPyEndAllowThreads(__tstate);
11156 if (PyErr_Occurred()) SWIG_fail;
11157 }
11158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11166 PyObject *resultobj;
11167 wxImage *arg1 = (wxImage *) 0 ;
11168 int arg2 ;
11169 int arg3 ;
11170 byte arg4 ;
11171 byte arg5 ;
11172 byte arg6 ;
11173 PyObject * obj0 = 0 ;
11174 PyObject * obj1 = 0 ;
11175 PyObject * obj2 = 0 ;
11176 PyObject * obj3 = 0 ;
11177 PyObject * obj4 = 0 ;
11178 PyObject * obj5 = 0 ;
11179 char *kwnames[] = {
11180 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11181 };
11182
11183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11185 if (SWIG_arg_fail(1)) SWIG_fail;
11186 {
11187 arg2 = (int)(SWIG_As_int(obj1));
11188 if (SWIG_arg_fail(2)) SWIG_fail;
11189 }
11190 {
11191 arg3 = (int)(SWIG_As_int(obj2));
11192 if (SWIG_arg_fail(3)) SWIG_fail;
11193 }
11194 {
11195 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11196 if (SWIG_arg_fail(4)) SWIG_fail;
11197 }
11198 {
11199 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11200 if (SWIG_arg_fail(5)) SWIG_fail;
11201 }
11202 {
11203 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11204 if (SWIG_arg_fail(6)) SWIG_fail;
11205 }
11206 {
11207 PyThreadState* __tstate = wxPyBeginAllowThreads();
11208 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11209
11210 wxPyEndAllowThreads(__tstate);
11211 if (PyErr_Occurred()) SWIG_fail;
11212 }
11213 Py_INCREF(Py_None); resultobj = Py_None;
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11221 PyObject *resultobj;
11222 wxImage *arg1 = (wxImage *) 0 ;
11223 wxRect *arg2 = 0 ;
11224 byte arg3 ;
11225 byte arg4 ;
11226 byte arg5 ;
11227 wxRect temp2 ;
11228 PyObject * obj0 = 0 ;
11229 PyObject * obj1 = 0 ;
11230 PyObject * obj2 = 0 ;
11231 PyObject * obj3 = 0 ;
11232 PyObject * obj4 = 0 ;
11233 char *kwnames[] = {
11234 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11235 };
11236
11237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11239 if (SWIG_arg_fail(1)) SWIG_fail;
11240 {
11241 arg2 = &temp2;
11242 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11243 }
11244 {
11245 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11246 if (SWIG_arg_fail(3)) SWIG_fail;
11247 }
11248 {
11249 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11250 if (SWIG_arg_fail(4)) SWIG_fail;
11251 }
11252 {
11253 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11254 if (SWIG_arg_fail(5)) SWIG_fail;
11255 }
11256 {
11257 PyThreadState* __tstate = wxPyBeginAllowThreads();
11258 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11259
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 Py_INCREF(Py_None); resultobj = Py_None;
11264 return resultobj;
11265 fail:
11266 return NULL;
11267 }
11268
11269
11270 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11271 PyObject *resultobj;
11272 wxImage *arg1 = (wxImage *) 0 ;
11273 int arg2 ;
11274 int arg3 ;
11275 byte result;
11276 PyObject * obj0 = 0 ;
11277 PyObject * obj1 = 0 ;
11278 PyObject * obj2 = 0 ;
11279 char *kwnames[] = {
11280 (char *) "self",(char *) "x",(char *) "y", NULL
11281 };
11282
11283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11285 if (SWIG_arg_fail(1)) SWIG_fail;
11286 {
11287 arg2 = (int)(SWIG_As_int(obj1));
11288 if (SWIG_arg_fail(2)) SWIG_fail;
11289 }
11290 {
11291 arg3 = (int)(SWIG_As_int(obj2));
11292 if (SWIG_arg_fail(3)) SWIG_fail;
11293 }
11294 {
11295 PyThreadState* __tstate = wxPyBeginAllowThreads();
11296 result = (byte)(arg1)->GetRed(arg2,arg3);
11297
11298 wxPyEndAllowThreads(__tstate);
11299 if (PyErr_Occurred()) SWIG_fail;
11300 }
11301 {
11302 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11303 }
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11311 PyObject *resultobj;
11312 wxImage *arg1 = (wxImage *) 0 ;
11313 int arg2 ;
11314 int arg3 ;
11315 byte result;
11316 PyObject * obj0 = 0 ;
11317 PyObject * obj1 = 0 ;
11318 PyObject * obj2 = 0 ;
11319 char *kwnames[] = {
11320 (char *) "self",(char *) "x",(char *) "y", NULL
11321 };
11322
11323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11325 if (SWIG_arg_fail(1)) SWIG_fail;
11326 {
11327 arg2 = (int)(SWIG_As_int(obj1));
11328 if (SWIG_arg_fail(2)) SWIG_fail;
11329 }
11330 {
11331 arg3 = (int)(SWIG_As_int(obj2));
11332 if (SWIG_arg_fail(3)) SWIG_fail;
11333 }
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 result = (byte)(arg1)->GetGreen(arg2,arg3);
11337
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 {
11342 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11343 }
11344 return resultobj;
11345 fail:
11346 return NULL;
11347 }
11348
11349
11350 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11351 PyObject *resultobj;
11352 wxImage *arg1 = (wxImage *) 0 ;
11353 int arg2 ;
11354 int arg3 ;
11355 byte result;
11356 PyObject * obj0 = 0 ;
11357 PyObject * obj1 = 0 ;
11358 PyObject * obj2 = 0 ;
11359 char *kwnames[] = {
11360 (char *) "self",(char *) "x",(char *) "y", NULL
11361 };
11362
11363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11365 if (SWIG_arg_fail(1)) SWIG_fail;
11366 {
11367 arg2 = (int)(SWIG_As_int(obj1));
11368 if (SWIG_arg_fail(2)) SWIG_fail;
11369 }
11370 {
11371 arg3 = (int)(SWIG_As_int(obj2));
11372 if (SWIG_arg_fail(3)) SWIG_fail;
11373 }
11374 {
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 result = (byte)(arg1)->GetBlue(arg2,arg3);
11377
11378 wxPyEndAllowThreads(__tstate);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 {
11382 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11383 }
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj;
11392 wxImage *arg1 = (wxImage *) 0 ;
11393 int arg2 ;
11394 int arg3 ;
11395 byte arg4 ;
11396 PyObject * obj0 = 0 ;
11397 PyObject * obj1 = 0 ;
11398 PyObject * obj2 = 0 ;
11399 PyObject * obj3 = 0 ;
11400 char *kwnames[] = {
11401 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11402 };
11403
11404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11406 if (SWIG_arg_fail(1)) SWIG_fail;
11407 {
11408 arg2 = (int)(SWIG_As_int(obj1));
11409 if (SWIG_arg_fail(2)) SWIG_fail;
11410 }
11411 {
11412 arg3 = (int)(SWIG_As_int(obj2));
11413 if (SWIG_arg_fail(3)) SWIG_fail;
11414 }
11415 {
11416 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11417 if (SWIG_arg_fail(4)) SWIG_fail;
11418 }
11419 {
11420 PyThreadState* __tstate = wxPyBeginAllowThreads();
11421 (arg1)->SetAlpha(arg2,arg3,arg4);
11422
11423 wxPyEndAllowThreads(__tstate);
11424 if (PyErr_Occurred()) SWIG_fail;
11425 }
11426 Py_INCREF(Py_None); resultobj = Py_None;
11427 return resultobj;
11428 fail:
11429 return NULL;
11430 }
11431
11432
11433 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11434 PyObject *resultobj;
11435 wxImage *arg1 = (wxImage *) 0 ;
11436 int arg2 ;
11437 int arg3 ;
11438 byte result;
11439 PyObject * obj0 = 0 ;
11440 PyObject * obj1 = 0 ;
11441 PyObject * obj2 = 0 ;
11442 char *kwnames[] = {
11443 (char *) "self",(char *) "x",(char *) "y", NULL
11444 };
11445
11446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11448 if (SWIG_arg_fail(1)) SWIG_fail;
11449 {
11450 arg2 = (int)(SWIG_As_int(obj1));
11451 if (SWIG_arg_fail(2)) SWIG_fail;
11452 }
11453 {
11454 arg3 = (int)(SWIG_As_int(obj2));
11455 if (SWIG_arg_fail(3)) SWIG_fail;
11456 }
11457 {
11458 PyThreadState* __tstate = wxPyBeginAllowThreads();
11459 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11460
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 {
11465 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11466 }
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj;
11475 wxImage *arg1 = (wxImage *) 0 ;
11476 bool result;
11477 PyObject * obj0 = 0 ;
11478 char *kwnames[] = {
11479 (char *) "self", NULL
11480 };
11481
11482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 result = (bool)(arg1)->HasAlpha();
11488
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 {
11493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11494 }
11495 return resultobj;
11496 fail:
11497 return NULL;
11498 }
11499
11500
11501 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj;
11503 wxImage *arg1 = (wxImage *) 0 ;
11504 PyObject * obj0 = 0 ;
11505 char *kwnames[] = {
11506 (char *) "self", NULL
11507 };
11508
11509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11511 if (SWIG_arg_fail(1)) SWIG_fail;
11512 {
11513 PyThreadState* __tstate = wxPyBeginAllowThreads();
11514 (arg1)->InitAlpha();
11515
11516 wxPyEndAllowThreads(__tstate);
11517 if (PyErr_Occurred()) SWIG_fail;
11518 }
11519 Py_INCREF(Py_None); resultobj = Py_None;
11520 return resultobj;
11521 fail:
11522 return NULL;
11523 }
11524
11525
11526 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11527 PyObject *resultobj;
11528 wxImage *arg1 = (wxImage *) 0 ;
11529 int arg2 ;
11530 int arg3 ;
11531 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11532 bool result;
11533 PyObject * obj0 = 0 ;
11534 PyObject * obj1 = 0 ;
11535 PyObject * obj2 = 0 ;
11536 PyObject * obj3 = 0 ;
11537 char *kwnames[] = {
11538 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11539 };
11540
11541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11543 if (SWIG_arg_fail(1)) SWIG_fail;
11544 {
11545 arg2 = (int)(SWIG_As_int(obj1));
11546 if (SWIG_arg_fail(2)) SWIG_fail;
11547 }
11548 {
11549 arg3 = (int)(SWIG_As_int(obj2));
11550 if (SWIG_arg_fail(3)) SWIG_fail;
11551 }
11552 if (obj3) {
11553 {
11554 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11555 if (SWIG_arg_fail(4)) SWIG_fail;
11556 }
11557 }
11558 {
11559 PyThreadState* __tstate = wxPyBeginAllowThreads();
11560 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11561
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 {
11566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11567 }
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj;
11576 wxImage *arg1 = (wxImage *) 0 ;
11577 byte *arg2 = (byte *) 0 ;
11578 byte *arg3 = (byte *) 0 ;
11579 byte *arg4 = (byte *) 0 ;
11580 byte arg5 = (byte) 0 ;
11581 byte arg6 = (byte) 0 ;
11582 byte arg7 = (byte) 0 ;
11583 bool result;
11584 byte temp2 ;
11585 int res2 = 0 ;
11586 byte temp3 ;
11587 int res3 = 0 ;
11588 byte temp4 ;
11589 int res4 = 0 ;
11590 PyObject * obj0 = 0 ;
11591 PyObject * obj1 = 0 ;
11592 PyObject * obj2 = 0 ;
11593 PyObject * obj3 = 0 ;
11594 char *kwnames[] = {
11595 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11596 };
11597
11598 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11599 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11600 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11603 if (SWIG_arg_fail(1)) SWIG_fail;
11604 if (obj1) {
11605 {
11606 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11607 if (SWIG_arg_fail(5)) SWIG_fail;
11608 }
11609 }
11610 if (obj2) {
11611 {
11612 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11613 if (SWIG_arg_fail(6)) SWIG_fail;
11614 }
11615 }
11616 if (obj3) {
11617 {
11618 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11619 if (SWIG_arg_fail(7)) SWIG_fail;
11620 }
11621 }
11622 {
11623 PyThreadState* __tstate = wxPyBeginAllowThreads();
11624 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11625
11626 wxPyEndAllowThreads(__tstate);
11627 if (PyErr_Occurred()) SWIG_fail;
11628 }
11629 {
11630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11631 }
11632 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11633 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11634 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11635 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11636 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11637 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11638 return resultobj;
11639 fail:
11640 return NULL;
11641 }
11642
11643
11644 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11645 PyObject *resultobj;
11646 wxImage *arg1 = (wxImage *) 0 ;
11647 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11648 bool result;
11649 PyObject * obj0 = 0 ;
11650 PyObject * obj1 = 0 ;
11651 char *kwnames[] = {
11652 (char *) "self",(char *) "threshold", NULL
11653 };
11654
11655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11657 if (SWIG_arg_fail(1)) SWIG_fail;
11658 if (obj1) {
11659 {
11660 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11661 if (SWIG_arg_fail(2)) SWIG_fail;
11662 }
11663 }
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11667
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 {
11672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11673 }
11674 return resultobj;
11675 fail:
11676 return NULL;
11677 }
11678
11679
11680 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11681 PyObject *resultobj;
11682 wxImage *arg1 = (wxImage *) 0 ;
11683 byte arg2 ;
11684 byte arg3 ;
11685 byte arg4 ;
11686 bool result;
11687 PyObject * obj0 = 0 ;
11688 PyObject * obj1 = 0 ;
11689 PyObject * obj2 = 0 ;
11690 PyObject * obj3 = 0 ;
11691 char *kwnames[] = {
11692 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11693 };
11694
11695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11697 if (SWIG_arg_fail(1)) SWIG_fail;
11698 {
11699 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11700 if (SWIG_arg_fail(2)) SWIG_fail;
11701 }
11702 {
11703 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11704 if (SWIG_arg_fail(3)) SWIG_fail;
11705 }
11706 {
11707 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11708 if (SWIG_arg_fail(4)) SWIG_fail;
11709 }
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11713
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 {
11718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11719 }
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11727 PyObject *resultobj;
11728 wxImage *arg1 = (wxImage *) 0 ;
11729 wxImage *arg2 = 0 ;
11730 byte arg3 ;
11731 byte arg4 ;
11732 byte arg5 ;
11733 bool result;
11734 PyObject * obj0 = 0 ;
11735 PyObject * obj1 = 0 ;
11736 PyObject * obj2 = 0 ;
11737 PyObject * obj3 = 0 ;
11738 PyObject * obj4 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11745 if (SWIG_arg_fail(1)) SWIG_fail;
11746 {
11747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11748 if (SWIG_arg_fail(2)) SWIG_fail;
11749 if (arg2 == NULL) {
11750 SWIG_null_ref("wxImage");
11751 }
11752 if (SWIG_arg_fail(2)) SWIG_fail;
11753 }
11754 {
11755 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11756 if (SWIG_arg_fail(3)) SWIG_fail;
11757 }
11758 {
11759 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11760 if (SWIG_arg_fail(4)) SWIG_fail;
11761 }
11762 {
11763 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11764 if (SWIG_arg_fail(5)) SWIG_fail;
11765 }
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11769
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11775 }
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11783 PyObject *resultobj;
11784 wxString *arg1 = 0 ;
11785 bool result;
11786 bool temp1 = false ;
11787 PyObject * obj0 = 0 ;
11788 char *kwnames[] = {
11789 (char *) "filename", NULL
11790 };
11791
11792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11793 {
11794 arg1 = wxString_in_helper(obj0);
11795 if (arg1 == NULL) SWIG_fail;
11796 temp1 = true;
11797 }
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11801
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 {
11806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11807 }
11808 {
11809 if (temp1)
11810 delete arg1;
11811 }
11812 return resultobj;
11813 fail:
11814 {
11815 if (temp1)
11816 delete arg1;
11817 }
11818 return NULL;
11819 }
11820
11821
11822 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11823 PyObject *resultobj;
11824 wxString *arg1 = 0 ;
11825 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11826 int result;
11827 bool temp1 = false ;
11828 PyObject * obj0 = 0 ;
11829 PyObject * obj1 = 0 ;
11830 char *kwnames[] = {
11831 (char *) "filename",(char *) "type", NULL
11832 };
11833
11834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11835 {
11836 arg1 = wxString_in_helper(obj0);
11837 if (arg1 == NULL) SWIG_fail;
11838 temp1 = true;
11839 }
11840 if (obj1) {
11841 {
11842 arg2 = (long)(SWIG_As_long(obj1));
11843 if (SWIG_arg_fail(2)) SWIG_fail;
11844 }
11845 }
11846 {
11847 PyThreadState* __tstate = wxPyBeginAllowThreads();
11848 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11849
11850 wxPyEndAllowThreads(__tstate);
11851 if (PyErr_Occurred()) SWIG_fail;
11852 }
11853 {
11854 resultobj = SWIG_From_int((int)(result));
11855 }
11856 {
11857 if (temp1)
11858 delete arg1;
11859 }
11860 return resultobj;
11861 fail:
11862 {
11863 if (temp1)
11864 delete arg1;
11865 }
11866 return NULL;
11867 }
11868
11869
11870 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11871 PyObject *resultobj;
11872 wxImage *arg1 = (wxImage *) 0 ;
11873 wxString *arg2 = 0 ;
11874 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11875 int arg4 = (int) -1 ;
11876 bool result;
11877 bool temp2 = false ;
11878 PyObject * obj0 = 0 ;
11879 PyObject * obj1 = 0 ;
11880 PyObject * obj2 = 0 ;
11881 PyObject * obj3 = 0 ;
11882 char *kwnames[] = {
11883 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11884 };
11885
11886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11888 if (SWIG_arg_fail(1)) SWIG_fail;
11889 {
11890 arg2 = wxString_in_helper(obj1);
11891 if (arg2 == NULL) SWIG_fail;
11892 temp2 = true;
11893 }
11894 if (obj2) {
11895 {
11896 arg3 = (long)(SWIG_As_long(obj2));
11897 if (SWIG_arg_fail(3)) SWIG_fail;
11898 }
11899 }
11900 if (obj3) {
11901 {
11902 arg4 = (int)(SWIG_As_int(obj3));
11903 if (SWIG_arg_fail(4)) SWIG_fail;
11904 }
11905 }
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11909
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 {
11914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11915 }
11916 {
11917 if (temp2)
11918 delete arg2;
11919 }
11920 return resultobj;
11921 fail:
11922 {
11923 if (temp2)
11924 delete arg2;
11925 }
11926 return NULL;
11927 }
11928
11929
11930 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11931 PyObject *resultobj;
11932 wxImage *arg1 = (wxImage *) 0 ;
11933 wxString *arg2 = 0 ;
11934 wxString *arg3 = 0 ;
11935 int arg4 = (int) -1 ;
11936 bool result;
11937 bool temp2 = false ;
11938 bool temp3 = false ;
11939 PyObject * obj0 = 0 ;
11940 PyObject * obj1 = 0 ;
11941 PyObject * obj2 = 0 ;
11942 PyObject * obj3 = 0 ;
11943 char *kwnames[] = {
11944 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11945 };
11946
11947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11949 if (SWIG_arg_fail(1)) SWIG_fail;
11950 {
11951 arg2 = wxString_in_helper(obj1);
11952 if (arg2 == NULL) SWIG_fail;
11953 temp2 = true;
11954 }
11955 {
11956 arg3 = wxString_in_helper(obj2);
11957 if (arg3 == NULL) SWIG_fail;
11958 temp3 = true;
11959 }
11960 if (obj3) {
11961 {
11962 arg4 = (int)(SWIG_As_int(obj3));
11963 if (SWIG_arg_fail(4)) SWIG_fail;
11964 }
11965 }
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11969
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 {
11974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11975 }
11976 {
11977 if (temp2)
11978 delete arg2;
11979 }
11980 {
11981 if (temp3)
11982 delete arg3;
11983 }
11984 return resultobj;
11985 fail:
11986 {
11987 if (temp2)
11988 delete arg2;
11989 }
11990 {
11991 if (temp3)
11992 delete arg3;
11993 }
11994 return NULL;
11995 }
11996
11997
11998 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11999 PyObject *resultobj;
12000 wxImage *arg1 = (wxImage *) 0 ;
12001 wxString *arg2 = 0 ;
12002 int arg3 ;
12003 bool result;
12004 bool temp2 = false ;
12005 PyObject * obj0 = 0 ;
12006 PyObject * obj1 = 0 ;
12007 PyObject * obj2 = 0 ;
12008 char *kwnames[] = {
12009 (char *) "self",(char *) "name",(char *) "type", NULL
12010 };
12011
12012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12014 if (SWIG_arg_fail(1)) SWIG_fail;
12015 {
12016 arg2 = wxString_in_helper(obj1);
12017 if (arg2 == NULL) SWIG_fail;
12018 temp2 = true;
12019 }
12020 {
12021 arg3 = (int)(SWIG_As_int(obj2));
12022 if (SWIG_arg_fail(3)) SWIG_fail;
12023 }
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12027
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 {
12032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12033 }
12034 {
12035 if (temp2)
12036 delete arg2;
12037 }
12038 return resultobj;
12039 fail:
12040 {
12041 if (temp2)
12042 delete arg2;
12043 }
12044 return NULL;
12045 }
12046
12047
12048 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12049 PyObject *resultobj;
12050 wxImage *arg1 = (wxImage *) 0 ;
12051 wxString *arg2 = 0 ;
12052 wxString *arg3 = 0 ;
12053 bool result;
12054 bool temp2 = false ;
12055 bool temp3 = false ;
12056 PyObject * obj0 = 0 ;
12057 PyObject * obj1 = 0 ;
12058 PyObject * obj2 = 0 ;
12059 char *kwnames[] = {
12060 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12061 };
12062
12063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12065 if (SWIG_arg_fail(1)) SWIG_fail;
12066 {
12067 arg2 = wxString_in_helper(obj1);
12068 if (arg2 == NULL) SWIG_fail;
12069 temp2 = true;
12070 }
12071 {
12072 arg3 = wxString_in_helper(obj2);
12073 if (arg3 == NULL) SWIG_fail;
12074 temp3 = true;
12075 }
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12079
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 {
12084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12085 }
12086 {
12087 if (temp2)
12088 delete arg2;
12089 }
12090 {
12091 if (temp3)
12092 delete arg3;
12093 }
12094 return resultobj;
12095 fail:
12096 {
12097 if (temp2)
12098 delete arg2;
12099 }
12100 {
12101 if (temp3)
12102 delete arg3;
12103 }
12104 return NULL;
12105 }
12106
12107
12108 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12109 PyObject *resultobj;
12110 wxInputStream *arg1 = 0 ;
12111 bool result;
12112 wxPyInputStream *temp1 ;
12113 bool created1 ;
12114 PyObject * obj0 = 0 ;
12115 char *kwnames[] = {
12116 (char *) "stream", NULL
12117 };
12118
12119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12120 {
12121 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12122 arg1 = temp1->m_wxis;
12123 created1 = false;
12124 } else {
12125 PyErr_Clear(); // clear the failure of the wxPyConvert above
12126 arg1 = wxPyCBInputStream_create(obj0, false);
12127 if (arg1 == NULL) {
12128 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12129 SWIG_fail;
12130 }
12131 created1 = true;
12132 }
12133 }
12134 {
12135 PyThreadState* __tstate = wxPyBeginAllowThreads();
12136 result = (bool)wxImage::CanRead(*arg1);
12137
12138 wxPyEndAllowThreads(__tstate);
12139 if (PyErr_Occurred()) SWIG_fail;
12140 }
12141 {
12142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12143 }
12144 {
12145 if (created1) delete arg1;
12146 }
12147 return resultobj;
12148 fail:
12149 {
12150 if (created1) delete arg1;
12151 }
12152 return NULL;
12153 }
12154
12155
12156 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12157 PyObject *resultobj;
12158 wxImage *arg1 = (wxImage *) 0 ;
12159 wxInputStream *arg2 = 0 ;
12160 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12161 int arg4 = (int) -1 ;
12162 bool result;
12163 wxPyInputStream *temp2 ;
12164 bool created2 ;
12165 PyObject * obj0 = 0 ;
12166 PyObject * obj1 = 0 ;
12167 PyObject * obj2 = 0 ;
12168 PyObject * obj3 = 0 ;
12169 char *kwnames[] = {
12170 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12171 };
12172
12173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12175 if (SWIG_arg_fail(1)) SWIG_fail;
12176 {
12177 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12178 arg2 = temp2->m_wxis;
12179 created2 = false;
12180 } else {
12181 PyErr_Clear(); // clear the failure of the wxPyConvert above
12182 arg2 = wxPyCBInputStream_create(obj1, false);
12183 if (arg2 == NULL) {
12184 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12185 SWIG_fail;
12186 }
12187 created2 = true;
12188 }
12189 }
12190 if (obj2) {
12191 {
12192 arg3 = (long)(SWIG_As_long(obj2));
12193 if (SWIG_arg_fail(3)) SWIG_fail;
12194 }
12195 }
12196 if (obj3) {
12197 {
12198 arg4 = (int)(SWIG_As_int(obj3));
12199 if (SWIG_arg_fail(4)) SWIG_fail;
12200 }
12201 }
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12205
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 {
12210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12211 }
12212 {
12213 if (created2) delete arg2;
12214 }
12215 return resultobj;
12216 fail:
12217 {
12218 if (created2) delete arg2;
12219 }
12220 return NULL;
12221 }
12222
12223
12224 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12225 PyObject *resultobj;
12226 wxImage *arg1 = (wxImage *) 0 ;
12227 wxInputStream *arg2 = 0 ;
12228 wxString *arg3 = 0 ;
12229 int arg4 = (int) -1 ;
12230 bool result;
12231 wxPyInputStream *temp2 ;
12232 bool created2 ;
12233 bool temp3 = false ;
12234 PyObject * obj0 = 0 ;
12235 PyObject * obj1 = 0 ;
12236 PyObject * obj2 = 0 ;
12237 PyObject * obj3 = 0 ;
12238 char *kwnames[] = {
12239 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12240 };
12241
12242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12244 if (SWIG_arg_fail(1)) SWIG_fail;
12245 {
12246 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12247 arg2 = temp2->m_wxis;
12248 created2 = false;
12249 } else {
12250 PyErr_Clear(); // clear the failure of the wxPyConvert above
12251 arg2 = wxPyCBInputStream_create(obj1, false);
12252 if (arg2 == NULL) {
12253 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12254 SWIG_fail;
12255 }
12256 created2 = true;
12257 }
12258 }
12259 {
12260 arg3 = wxString_in_helper(obj2);
12261 if (arg3 == NULL) SWIG_fail;
12262 temp3 = true;
12263 }
12264 if (obj3) {
12265 {
12266 arg4 = (int)(SWIG_As_int(obj3));
12267 if (SWIG_arg_fail(4)) SWIG_fail;
12268 }
12269 }
12270 {
12271 PyThreadState* __tstate = wxPyBeginAllowThreads();
12272 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12273
12274 wxPyEndAllowThreads(__tstate);
12275 if (PyErr_Occurred()) SWIG_fail;
12276 }
12277 {
12278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12279 }
12280 {
12281 if (created2) delete arg2;
12282 }
12283 {
12284 if (temp3)
12285 delete arg3;
12286 }
12287 return resultobj;
12288 fail:
12289 {
12290 if (created2) delete arg2;
12291 }
12292 {
12293 if (temp3)
12294 delete arg3;
12295 }
12296 return NULL;
12297 }
12298
12299
12300 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj;
12302 wxImage *arg1 = (wxImage *) 0 ;
12303 bool result;
12304 PyObject * obj0 = 0 ;
12305 char *kwnames[] = {
12306 (char *) "self", NULL
12307 };
12308
12309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12311 if (SWIG_arg_fail(1)) SWIG_fail;
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 result = (bool)(arg1)->Ok();
12315
12316 wxPyEndAllowThreads(__tstate);
12317 if (PyErr_Occurred()) SWIG_fail;
12318 }
12319 {
12320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12321 }
12322 return resultobj;
12323 fail:
12324 return NULL;
12325 }
12326
12327
12328 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12329 PyObject *resultobj;
12330 wxImage *arg1 = (wxImage *) 0 ;
12331 int result;
12332 PyObject * obj0 = 0 ;
12333 char *kwnames[] = {
12334 (char *) "self", NULL
12335 };
12336
12337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12339 if (SWIG_arg_fail(1)) SWIG_fail;
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 result = (int)(arg1)->GetWidth();
12343
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 {
12348 resultobj = SWIG_From_int((int)(result));
12349 }
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12357 PyObject *resultobj;
12358 wxImage *arg1 = (wxImage *) 0 ;
12359 int result;
12360 PyObject * obj0 = 0 ;
12361 char *kwnames[] = {
12362 (char *) "self", NULL
12363 };
12364
12365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12367 if (SWIG_arg_fail(1)) SWIG_fail;
12368 {
12369 PyThreadState* __tstate = wxPyBeginAllowThreads();
12370 result = (int)(arg1)->GetHeight();
12371
12372 wxPyEndAllowThreads(__tstate);
12373 if (PyErr_Occurred()) SWIG_fail;
12374 }
12375 {
12376 resultobj = SWIG_From_int((int)(result));
12377 }
12378 return resultobj;
12379 fail:
12380 return NULL;
12381 }
12382
12383
12384 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj;
12386 wxImage *arg1 = (wxImage *) 0 ;
12387 wxSize result;
12388 PyObject * obj0 = 0 ;
12389 char *kwnames[] = {
12390 (char *) "self", NULL
12391 };
12392
12393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12395 if (SWIG_arg_fail(1)) SWIG_fail;
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 result = wxImage_GetSize(arg1);
12399
12400 wxPyEndAllowThreads(__tstate);
12401 if (PyErr_Occurred()) SWIG_fail;
12402 }
12403 {
12404 wxSize * resultptr;
12405 resultptr = new wxSize((wxSize &)(result));
12406 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12407 }
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj;
12416 wxImage *arg1 = (wxImage *) 0 ;
12417 wxRect *arg2 = 0 ;
12418 SwigValueWrapper<wxImage > result;
12419 wxRect temp2 ;
12420 PyObject * obj0 = 0 ;
12421 PyObject * obj1 = 0 ;
12422 char *kwnames[] = {
12423 (char *) "self",(char *) "rect", NULL
12424 };
12425
12426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12428 if (SWIG_arg_fail(1)) SWIG_fail;
12429 {
12430 arg2 = &temp2;
12431 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12432 }
12433 {
12434 PyThreadState* __tstate = wxPyBeginAllowThreads();
12435 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12436
12437 wxPyEndAllowThreads(__tstate);
12438 if (PyErr_Occurred()) SWIG_fail;
12439 }
12440 {
12441 wxImage * resultptr;
12442 resultptr = new wxImage((wxImage &)(result));
12443 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12444 }
12445 return resultobj;
12446 fail:
12447 return NULL;
12448 }
12449
12450
12451 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj;
12453 wxImage *arg1 = (wxImage *) 0 ;
12454 wxSize *arg2 = 0 ;
12455 wxPoint *arg3 = 0 ;
12456 int arg4 = (int) -1 ;
12457 int arg5 = (int) -1 ;
12458 int arg6 = (int) -1 ;
12459 SwigValueWrapper<wxImage > result;
12460 wxSize temp2 ;
12461 wxPoint temp3 ;
12462 PyObject * obj0 = 0 ;
12463 PyObject * obj1 = 0 ;
12464 PyObject * obj2 = 0 ;
12465 PyObject * obj3 = 0 ;
12466 PyObject * obj4 = 0 ;
12467 PyObject * obj5 = 0 ;
12468 char *kwnames[] = {
12469 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12470 };
12471
12472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12474 if (SWIG_arg_fail(1)) SWIG_fail;
12475 {
12476 arg2 = &temp2;
12477 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12478 }
12479 {
12480 arg3 = &temp3;
12481 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12482 }
12483 if (obj3) {
12484 {
12485 arg4 = (int)(SWIG_As_int(obj3));
12486 if (SWIG_arg_fail(4)) SWIG_fail;
12487 }
12488 }
12489 if (obj4) {
12490 {
12491 arg5 = (int)(SWIG_As_int(obj4));
12492 if (SWIG_arg_fail(5)) SWIG_fail;
12493 }
12494 }
12495 if (obj5) {
12496 {
12497 arg6 = (int)(SWIG_As_int(obj5));
12498 if (SWIG_arg_fail(6)) SWIG_fail;
12499 }
12500 }
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12504
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 {
12509 wxImage * resultptr;
12510 resultptr = new wxImage((wxImage &)(result));
12511 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12512 }
12513 return resultobj;
12514 fail:
12515 return NULL;
12516 }
12517
12518
12519 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj;
12521 wxImage *arg1 = (wxImage *) 0 ;
12522 SwigValueWrapper<wxImage > result;
12523 PyObject * obj0 = 0 ;
12524 char *kwnames[] = {
12525 (char *) "self", NULL
12526 };
12527
12528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12530 if (SWIG_arg_fail(1)) SWIG_fail;
12531 {
12532 PyThreadState* __tstate = wxPyBeginAllowThreads();
12533 result = (arg1)->Copy();
12534
12535 wxPyEndAllowThreads(__tstate);
12536 if (PyErr_Occurred()) SWIG_fail;
12537 }
12538 {
12539 wxImage * resultptr;
12540 resultptr = new wxImage((wxImage &)(result));
12541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12542 }
12543 return resultobj;
12544 fail:
12545 return NULL;
12546 }
12547
12548
12549 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12550 PyObject *resultobj;
12551 wxImage *arg1 = (wxImage *) 0 ;
12552 wxImage *arg2 = 0 ;
12553 int arg3 ;
12554 int arg4 ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 PyObject * obj2 = 0 ;
12558 PyObject * obj3 = 0 ;
12559 char *kwnames[] = {
12560 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12561 };
12562
12563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12565 if (SWIG_arg_fail(1)) SWIG_fail;
12566 {
12567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12568 if (SWIG_arg_fail(2)) SWIG_fail;
12569 if (arg2 == NULL) {
12570 SWIG_null_ref("wxImage");
12571 }
12572 if (SWIG_arg_fail(2)) SWIG_fail;
12573 }
12574 {
12575 arg3 = (int)(SWIG_As_int(obj2));
12576 if (SWIG_arg_fail(3)) SWIG_fail;
12577 }
12578 {
12579 arg4 = (int)(SWIG_As_int(obj3));
12580 if (SWIG_arg_fail(4)) SWIG_fail;
12581 }
12582 {
12583 PyThreadState* __tstate = wxPyBeginAllowThreads();
12584 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12585
12586 wxPyEndAllowThreads(__tstate);
12587 if (PyErr_Occurred()) SWIG_fail;
12588 }
12589 Py_INCREF(Py_None); resultobj = Py_None;
12590 return resultobj;
12591 fail:
12592 return NULL;
12593 }
12594
12595
12596 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12597 PyObject *resultobj;
12598 wxImage *arg1 = (wxImage *) 0 ;
12599 PyObject *result;
12600 PyObject * obj0 = 0 ;
12601 char *kwnames[] = {
12602 (char *) "self", NULL
12603 };
12604
12605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12607 if (SWIG_arg_fail(1)) SWIG_fail;
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 result = (PyObject *)wxImage_GetData(arg1);
12611
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 resultobj = result;
12616 return resultobj;
12617 fail:
12618 return NULL;
12619 }
12620
12621
12622 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12623 PyObject *resultobj;
12624 wxImage *arg1 = (wxImage *) 0 ;
12625 buffer arg2 ;
12626 int arg3 ;
12627 PyObject * obj0 = 0 ;
12628 PyObject * obj1 = 0 ;
12629 char *kwnames[] = {
12630 (char *) "self",(char *) "data", NULL
12631 };
12632
12633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12635 if (SWIG_arg_fail(1)) SWIG_fail;
12636 {
12637 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12638 }
12639 {
12640 PyThreadState* __tstate = wxPyBeginAllowThreads();
12641 wxImage_SetData(arg1,arg2,arg3);
12642
12643 wxPyEndAllowThreads(__tstate);
12644 if (PyErr_Occurred()) SWIG_fail;
12645 }
12646 Py_INCREF(Py_None); resultobj = Py_None;
12647 return resultobj;
12648 fail:
12649 return NULL;
12650 }
12651
12652
12653 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12654 PyObject *resultobj;
12655 wxImage *arg1 = (wxImage *) 0 ;
12656 PyObject *result;
12657 PyObject * obj0 = 0 ;
12658 char *kwnames[] = {
12659 (char *) "self", NULL
12660 };
12661
12662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12664 if (SWIG_arg_fail(1)) SWIG_fail;
12665 {
12666 PyThreadState* __tstate = wxPyBeginAllowThreads();
12667 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12668
12669 wxPyEndAllowThreads(__tstate);
12670 if (PyErr_Occurred()) SWIG_fail;
12671 }
12672 resultobj = result;
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj;
12681 wxImage *arg1 = (wxImage *) 0 ;
12682 buffer arg2 ;
12683 int arg3 ;
12684 PyObject * obj0 = 0 ;
12685 PyObject * obj1 = 0 ;
12686 char *kwnames[] = {
12687 (char *) "self",(char *) "data", NULL
12688 };
12689
12690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12692 if (SWIG_arg_fail(1)) SWIG_fail;
12693 {
12694 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12695 }
12696 {
12697 PyThreadState* __tstate = wxPyBeginAllowThreads();
12698 wxImage_SetDataBuffer(arg1,arg2,arg3);
12699
12700 wxPyEndAllowThreads(__tstate);
12701 if (PyErr_Occurred()) SWIG_fail;
12702 }
12703 Py_INCREF(Py_None); resultobj = Py_None;
12704 return resultobj;
12705 fail:
12706 return NULL;
12707 }
12708
12709
12710 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12711 PyObject *resultobj;
12712 wxImage *arg1 = (wxImage *) 0 ;
12713 PyObject *result;
12714 PyObject * obj0 = 0 ;
12715 char *kwnames[] = {
12716 (char *) "self", NULL
12717 };
12718
12719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12721 if (SWIG_arg_fail(1)) SWIG_fail;
12722 {
12723 PyThreadState* __tstate = wxPyBeginAllowThreads();
12724 result = (PyObject *)wxImage_GetAlphaData(arg1);
12725
12726 wxPyEndAllowThreads(__tstate);
12727 if (PyErr_Occurred()) SWIG_fail;
12728 }
12729 resultobj = result;
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12737 PyObject *resultobj;
12738 wxImage *arg1 = (wxImage *) 0 ;
12739 buffer arg2 ;
12740 int arg3 ;
12741 PyObject * obj0 = 0 ;
12742 PyObject * obj1 = 0 ;
12743 char *kwnames[] = {
12744 (char *) "self",(char *) "alpha", NULL
12745 };
12746
12747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12749 if (SWIG_arg_fail(1)) SWIG_fail;
12750 {
12751 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12752 }
12753 {
12754 PyThreadState* __tstate = wxPyBeginAllowThreads();
12755 wxImage_SetAlphaData(arg1,arg2,arg3);
12756
12757 wxPyEndAllowThreads(__tstate);
12758 if (PyErr_Occurred()) SWIG_fail;
12759 }
12760 Py_INCREF(Py_None); resultobj = Py_None;
12761 return resultobj;
12762 fail:
12763 return NULL;
12764 }
12765
12766
12767 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12768 PyObject *resultobj;
12769 wxImage *arg1 = (wxImage *) 0 ;
12770 PyObject *result;
12771 PyObject * obj0 = 0 ;
12772 char *kwnames[] = {
12773 (char *) "self", NULL
12774 };
12775
12776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12778 if (SWIG_arg_fail(1)) SWIG_fail;
12779 {
12780 PyThreadState* __tstate = wxPyBeginAllowThreads();
12781 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12782
12783 wxPyEndAllowThreads(__tstate);
12784 if (PyErr_Occurred()) SWIG_fail;
12785 }
12786 resultobj = result;
12787 return resultobj;
12788 fail:
12789 return NULL;
12790 }
12791
12792
12793 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12794 PyObject *resultobj;
12795 wxImage *arg1 = (wxImage *) 0 ;
12796 buffer arg2 ;
12797 int arg3 ;
12798 PyObject * obj0 = 0 ;
12799 PyObject * obj1 = 0 ;
12800 char *kwnames[] = {
12801 (char *) "self",(char *) "alpha", NULL
12802 };
12803
12804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12806 if (SWIG_arg_fail(1)) SWIG_fail;
12807 {
12808 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12809 }
12810 {
12811 PyThreadState* __tstate = wxPyBeginAllowThreads();
12812 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12813
12814 wxPyEndAllowThreads(__tstate);
12815 if (PyErr_Occurred()) SWIG_fail;
12816 }
12817 Py_INCREF(Py_None); resultobj = Py_None;
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12825 PyObject *resultobj;
12826 wxImage *arg1 = (wxImage *) 0 ;
12827 byte arg2 ;
12828 byte arg3 ;
12829 byte arg4 ;
12830 PyObject * obj0 = 0 ;
12831 PyObject * obj1 = 0 ;
12832 PyObject * obj2 = 0 ;
12833 PyObject * obj3 = 0 ;
12834 char *kwnames[] = {
12835 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12836 };
12837
12838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12840 if (SWIG_arg_fail(1)) SWIG_fail;
12841 {
12842 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12843 if (SWIG_arg_fail(2)) SWIG_fail;
12844 }
12845 {
12846 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12847 if (SWIG_arg_fail(3)) SWIG_fail;
12848 }
12849 {
12850 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12851 if (SWIG_arg_fail(4)) SWIG_fail;
12852 }
12853 {
12854 PyThreadState* __tstate = wxPyBeginAllowThreads();
12855 (arg1)->SetMaskColour(arg2,arg3,arg4);
12856
12857 wxPyEndAllowThreads(__tstate);
12858 if (PyErr_Occurred()) SWIG_fail;
12859 }
12860 Py_INCREF(Py_None); resultobj = Py_None;
12861 return resultobj;
12862 fail:
12863 return NULL;
12864 }
12865
12866
12867 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12868 PyObject *resultobj;
12869 wxImage *arg1 = (wxImage *) 0 ;
12870 byte *arg2 = (byte *) 0 ;
12871 byte *arg3 = (byte *) 0 ;
12872 byte *arg4 = (byte *) 0 ;
12873 byte temp2 ;
12874 int res2 = 0 ;
12875 byte temp3 ;
12876 int res3 = 0 ;
12877 byte temp4 ;
12878 int res4 = 0 ;
12879 PyObject * obj0 = 0 ;
12880 char *kwnames[] = {
12881 (char *) "self", NULL
12882 };
12883
12884 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12885 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12886 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12889 if (SWIG_arg_fail(1)) SWIG_fail;
12890 {
12891 PyThreadState* __tstate = wxPyBeginAllowThreads();
12892 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12893
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 Py_INCREF(Py_None); resultobj = Py_None;
12898 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12899 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12900 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12901 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12902 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12903 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12904 return resultobj;
12905 fail:
12906 return NULL;
12907 }
12908
12909
12910 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12911 PyObject *resultobj;
12912 wxImage *arg1 = (wxImage *) 0 ;
12913 byte result;
12914 PyObject * obj0 = 0 ;
12915 char *kwnames[] = {
12916 (char *) "self", NULL
12917 };
12918
12919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12921 if (SWIG_arg_fail(1)) SWIG_fail;
12922 {
12923 PyThreadState* __tstate = wxPyBeginAllowThreads();
12924 result = (byte)(arg1)->GetMaskRed();
12925
12926 wxPyEndAllowThreads(__tstate);
12927 if (PyErr_Occurred()) SWIG_fail;
12928 }
12929 {
12930 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12931 }
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12939 PyObject *resultobj;
12940 wxImage *arg1 = (wxImage *) 0 ;
12941 byte result;
12942 PyObject * obj0 = 0 ;
12943 char *kwnames[] = {
12944 (char *) "self", NULL
12945 };
12946
12947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12949 if (SWIG_arg_fail(1)) SWIG_fail;
12950 {
12951 PyThreadState* __tstate = wxPyBeginAllowThreads();
12952 result = (byte)(arg1)->GetMaskGreen();
12953
12954 wxPyEndAllowThreads(__tstate);
12955 if (PyErr_Occurred()) SWIG_fail;
12956 }
12957 {
12958 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12959 }
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12967 PyObject *resultobj;
12968 wxImage *arg1 = (wxImage *) 0 ;
12969 byte result;
12970 PyObject * obj0 = 0 ;
12971 char *kwnames[] = {
12972 (char *) "self", NULL
12973 };
12974
12975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12977 if (SWIG_arg_fail(1)) SWIG_fail;
12978 {
12979 PyThreadState* __tstate = wxPyBeginAllowThreads();
12980 result = (byte)(arg1)->GetMaskBlue();
12981
12982 wxPyEndAllowThreads(__tstate);
12983 if (PyErr_Occurred()) SWIG_fail;
12984 }
12985 {
12986 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12987 }
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12995 PyObject *resultobj;
12996 wxImage *arg1 = (wxImage *) 0 ;
12997 bool arg2 = (bool) true ;
12998 PyObject * obj0 = 0 ;
12999 PyObject * obj1 = 0 ;
13000 char *kwnames[] = {
13001 (char *) "self",(char *) "mask", NULL
13002 };
13003
13004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13006 if (SWIG_arg_fail(1)) SWIG_fail;
13007 if (obj1) {
13008 {
13009 arg2 = (bool)(SWIG_As_bool(obj1));
13010 if (SWIG_arg_fail(2)) SWIG_fail;
13011 }
13012 }
13013 {
13014 PyThreadState* __tstate = wxPyBeginAllowThreads();
13015 (arg1)->SetMask(arg2);
13016
13017 wxPyEndAllowThreads(__tstate);
13018 if (PyErr_Occurred()) SWIG_fail;
13019 }
13020 Py_INCREF(Py_None); resultobj = Py_None;
13021 return resultobj;
13022 fail:
13023 return NULL;
13024 }
13025
13026
13027 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13028 PyObject *resultobj;
13029 wxImage *arg1 = (wxImage *) 0 ;
13030 bool result;
13031 PyObject * obj0 = 0 ;
13032 char *kwnames[] = {
13033 (char *) "self", NULL
13034 };
13035
13036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13038 if (SWIG_arg_fail(1)) SWIG_fail;
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 result = (bool)(arg1)->HasMask();
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 {
13047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13048 }
13049 return resultobj;
13050 fail:
13051 return NULL;
13052 }
13053
13054
13055 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13056 PyObject *resultobj;
13057 wxImage *arg1 = (wxImage *) 0 ;
13058 double arg2 ;
13059 wxPoint *arg3 = 0 ;
13060 bool arg4 = (bool) true ;
13061 wxPoint *arg5 = (wxPoint *) NULL ;
13062 SwigValueWrapper<wxImage > result;
13063 wxPoint temp3 ;
13064 PyObject * obj0 = 0 ;
13065 PyObject * obj1 = 0 ;
13066 PyObject * obj2 = 0 ;
13067 PyObject * obj3 = 0 ;
13068 PyObject * obj4 = 0 ;
13069 char *kwnames[] = {
13070 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13071 };
13072
13073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13075 if (SWIG_arg_fail(1)) SWIG_fail;
13076 {
13077 arg2 = (double)(SWIG_As_double(obj1));
13078 if (SWIG_arg_fail(2)) SWIG_fail;
13079 }
13080 {
13081 arg3 = &temp3;
13082 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13083 }
13084 if (obj3) {
13085 {
13086 arg4 = (bool)(SWIG_As_bool(obj3));
13087 if (SWIG_arg_fail(4)) SWIG_fail;
13088 }
13089 }
13090 if (obj4) {
13091 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13092 if (SWIG_arg_fail(5)) SWIG_fail;
13093 }
13094 {
13095 PyThreadState* __tstate = wxPyBeginAllowThreads();
13096 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13097
13098 wxPyEndAllowThreads(__tstate);
13099 if (PyErr_Occurred()) SWIG_fail;
13100 }
13101 {
13102 wxImage * resultptr;
13103 resultptr = new wxImage((wxImage &)(result));
13104 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13105 }
13106 return resultobj;
13107 fail:
13108 return NULL;
13109 }
13110
13111
13112 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13113 PyObject *resultobj;
13114 wxImage *arg1 = (wxImage *) 0 ;
13115 bool arg2 = (bool) true ;
13116 SwigValueWrapper<wxImage > result;
13117 PyObject * obj0 = 0 ;
13118 PyObject * obj1 = 0 ;
13119 char *kwnames[] = {
13120 (char *) "self",(char *) "clockwise", NULL
13121 };
13122
13123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13125 if (SWIG_arg_fail(1)) SWIG_fail;
13126 if (obj1) {
13127 {
13128 arg2 = (bool)(SWIG_As_bool(obj1));
13129 if (SWIG_arg_fail(2)) SWIG_fail;
13130 }
13131 }
13132 {
13133 PyThreadState* __tstate = wxPyBeginAllowThreads();
13134 result = (arg1)->Rotate90(arg2);
13135
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 {
13140 wxImage * resultptr;
13141 resultptr = new wxImage((wxImage &)(result));
13142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13143 }
13144 return resultobj;
13145 fail:
13146 return NULL;
13147 }
13148
13149
13150 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13151 PyObject *resultobj;
13152 wxImage *arg1 = (wxImage *) 0 ;
13153 bool arg2 = (bool) true ;
13154 SwigValueWrapper<wxImage > result;
13155 PyObject * obj0 = 0 ;
13156 PyObject * obj1 = 0 ;
13157 char *kwnames[] = {
13158 (char *) "self",(char *) "horizontally", NULL
13159 };
13160
13161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13163 if (SWIG_arg_fail(1)) SWIG_fail;
13164 if (obj1) {
13165 {
13166 arg2 = (bool)(SWIG_As_bool(obj1));
13167 if (SWIG_arg_fail(2)) SWIG_fail;
13168 }
13169 }
13170 {
13171 PyThreadState* __tstate = wxPyBeginAllowThreads();
13172 result = (arg1)->Mirror(arg2);
13173
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 {
13178 wxImage * resultptr;
13179 resultptr = new wxImage((wxImage &)(result));
13180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13181 }
13182 return resultobj;
13183 fail:
13184 return NULL;
13185 }
13186
13187
13188 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13189 PyObject *resultobj;
13190 wxImage *arg1 = (wxImage *) 0 ;
13191 byte arg2 ;
13192 byte arg3 ;
13193 byte arg4 ;
13194 byte arg5 ;
13195 byte arg6 ;
13196 byte arg7 ;
13197 PyObject * obj0 = 0 ;
13198 PyObject * obj1 = 0 ;
13199 PyObject * obj2 = 0 ;
13200 PyObject * obj3 = 0 ;
13201 PyObject * obj4 = 0 ;
13202 PyObject * obj5 = 0 ;
13203 PyObject * obj6 = 0 ;
13204 char *kwnames[] = {
13205 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13206 };
13207
13208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13210 if (SWIG_arg_fail(1)) SWIG_fail;
13211 {
13212 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13213 if (SWIG_arg_fail(2)) SWIG_fail;
13214 }
13215 {
13216 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13217 if (SWIG_arg_fail(3)) SWIG_fail;
13218 }
13219 {
13220 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13221 if (SWIG_arg_fail(4)) SWIG_fail;
13222 }
13223 {
13224 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13225 if (SWIG_arg_fail(5)) SWIG_fail;
13226 }
13227 {
13228 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13229 if (SWIG_arg_fail(6)) SWIG_fail;
13230 }
13231 {
13232 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13233 if (SWIG_arg_fail(7)) SWIG_fail;
13234 }
13235 {
13236 PyThreadState* __tstate = wxPyBeginAllowThreads();
13237 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13238
13239 wxPyEndAllowThreads(__tstate);
13240 if (PyErr_Occurred()) SWIG_fail;
13241 }
13242 Py_INCREF(Py_None); resultobj = Py_None;
13243 return resultobj;
13244 fail:
13245 return NULL;
13246 }
13247
13248
13249 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13250 PyObject *resultobj;
13251 wxImage *arg1 = (wxImage *) 0 ;
13252 byte arg2 ;
13253 byte arg3 ;
13254 byte arg4 ;
13255 SwigValueWrapper<wxImage > result;
13256 PyObject * obj0 = 0 ;
13257 PyObject * obj1 = 0 ;
13258 PyObject * obj2 = 0 ;
13259 PyObject * obj3 = 0 ;
13260 char *kwnames[] = {
13261 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13262 };
13263
13264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13266 if (SWIG_arg_fail(1)) SWIG_fail;
13267 {
13268 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13269 if (SWIG_arg_fail(2)) SWIG_fail;
13270 }
13271 {
13272 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13273 if (SWIG_arg_fail(3)) SWIG_fail;
13274 }
13275 {
13276 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13277 if (SWIG_arg_fail(4)) SWIG_fail;
13278 }
13279 {
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13282
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 {
13287 wxImage * resultptr;
13288 resultptr = new wxImage((wxImage &)(result));
13289 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13290 }
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj;
13299 wxImage *arg1 = (wxImage *) 0 ;
13300 wxString *arg2 = 0 ;
13301 wxString *arg3 = 0 ;
13302 bool temp2 = false ;
13303 bool temp3 = false ;
13304 PyObject * obj0 = 0 ;
13305 PyObject * obj1 = 0 ;
13306 PyObject * obj2 = 0 ;
13307 char *kwnames[] = {
13308 (char *) "self",(char *) "name",(char *) "value", NULL
13309 };
13310
13311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13313 if (SWIG_arg_fail(1)) SWIG_fail;
13314 {
13315 arg2 = wxString_in_helper(obj1);
13316 if (arg2 == NULL) SWIG_fail;
13317 temp2 = true;
13318 }
13319 {
13320 arg3 = wxString_in_helper(obj2);
13321 if (arg3 == NULL) SWIG_fail;
13322 temp3 = true;
13323 }
13324 {
13325 PyThreadState* __tstate = wxPyBeginAllowThreads();
13326 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13327
13328 wxPyEndAllowThreads(__tstate);
13329 if (PyErr_Occurred()) SWIG_fail;
13330 }
13331 Py_INCREF(Py_None); resultobj = Py_None;
13332 {
13333 if (temp2)
13334 delete arg2;
13335 }
13336 {
13337 if (temp3)
13338 delete arg3;
13339 }
13340 return resultobj;
13341 fail:
13342 {
13343 if (temp2)
13344 delete arg2;
13345 }
13346 {
13347 if (temp3)
13348 delete arg3;
13349 }
13350 return NULL;
13351 }
13352
13353
13354 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13355 PyObject *resultobj;
13356 wxImage *arg1 = (wxImage *) 0 ;
13357 wxString *arg2 = 0 ;
13358 int arg3 ;
13359 bool temp2 = false ;
13360 PyObject * obj0 = 0 ;
13361 PyObject * obj1 = 0 ;
13362 PyObject * obj2 = 0 ;
13363 char *kwnames[] = {
13364 (char *) "self",(char *) "name",(char *) "value", NULL
13365 };
13366
13367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13369 if (SWIG_arg_fail(1)) SWIG_fail;
13370 {
13371 arg2 = wxString_in_helper(obj1);
13372 if (arg2 == NULL) SWIG_fail;
13373 temp2 = true;
13374 }
13375 {
13376 arg3 = (int)(SWIG_As_int(obj2));
13377 if (SWIG_arg_fail(3)) SWIG_fail;
13378 }
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 (arg1)->SetOption((wxString const &)*arg2,arg3);
13382
13383 wxPyEndAllowThreads(__tstate);
13384 if (PyErr_Occurred()) SWIG_fail;
13385 }
13386 Py_INCREF(Py_None); resultobj = Py_None;
13387 {
13388 if (temp2)
13389 delete arg2;
13390 }
13391 return resultobj;
13392 fail:
13393 {
13394 if (temp2)
13395 delete arg2;
13396 }
13397 return NULL;
13398 }
13399
13400
13401 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13402 PyObject *resultobj;
13403 wxImage *arg1 = (wxImage *) 0 ;
13404 wxString *arg2 = 0 ;
13405 wxString result;
13406 bool temp2 = false ;
13407 PyObject * obj0 = 0 ;
13408 PyObject * obj1 = 0 ;
13409 char *kwnames[] = {
13410 (char *) "self",(char *) "name", NULL
13411 };
13412
13413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13415 if (SWIG_arg_fail(1)) SWIG_fail;
13416 {
13417 arg2 = wxString_in_helper(obj1);
13418 if (arg2 == NULL) SWIG_fail;
13419 temp2 = true;
13420 }
13421 {
13422 PyThreadState* __tstate = wxPyBeginAllowThreads();
13423 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13424
13425 wxPyEndAllowThreads(__tstate);
13426 if (PyErr_Occurred()) SWIG_fail;
13427 }
13428 {
13429 #if wxUSE_UNICODE
13430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13431 #else
13432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13433 #endif
13434 }
13435 {
13436 if (temp2)
13437 delete arg2;
13438 }
13439 return resultobj;
13440 fail:
13441 {
13442 if (temp2)
13443 delete arg2;
13444 }
13445 return NULL;
13446 }
13447
13448
13449 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13450 PyObject *resultobj;
13451 wxImage *arg1 = (wxImage *) 0 ;
13452 wxString *arg2 = 0 ;
13453 int result;
13454 bool temp2 = false ;
13455 PyObject * obj0 = 0 ;
13456 PyObject * obj1 = 0 ;
13457 char *kwnames[] = {
13458 (char *) "self",(char *) "name", NULL
13459 };
13460
13461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13463 if (SWIG_arg_fail(1)) SWIG_fail;
13464 {
13465 arg2 = wxString_in_helper(obj1);
13466 if (arg2 == NULL) SWIG_fail;
13467 temp2 = true;
13468 }
13469 {
13470 PyThreadState* __tstate = wxPyBeginAllowThreads();
13471 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13472
13473 wxPyEndAllowThreads(__tstate);
13474 if (PyErr_Occurred()) SWIG_fail;
13475 }
13476 {
13477 resultobj = SWIG_From_int((int)(result));
13478 }
13479 {
13480 if (temp2)
13481 delete arg2;
13482 }
13483 return resultobj;
13484 fail:
13485 {
13486 if (temp2)
13487 delete arg2;
13488 }
13489 return NULL;
13490 }
13491
13492
13493 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj;
13495 wxImage *arg1 = (wxImage *) 0 ;
13496 wxString *arg2 = 0 ;
13497 bool result;
13498 bool temp2 = false ;
13499 PyObject * obj0 = 0 ;
13500 PyObject * obj1 = 0 ;
13501 char *kwnames[] = {
13502 (char *) "self",(char *) "name", NULL
13503 };
13504
13505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13507 if (SWIG_arg_fail(1)) SWIG_fail;
13508 {
13509 arg2 = wxString_in_helper(obj1);
13510 if (arg2 == NULL) SWIG_fail;
13511 temp2 = true;
13512 }
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13516
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 {
13521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13522 }
13523 {
13524 if (temp2)
13525 delete arg2;
13526 }
13527 return resultobj;
13528 fail:
13529 {
13530 if (temp2)
13531 delete arg2;
13532 }
13533 return NULL;
13534 }
13535
13536
13537 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj;
13539 wxImage *arg1 = (wxImage *) 0 ;
13540 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13541 unsigned long result;
13542 PyObject * obj0 = 0 ;
13543 PyObject * obj1 = 0 ;
13544 char *kwnames[] = {
13545 (char *) "self",(char *) "stopafter", NULL
13546 };
13547
13548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13550 if (SWIG_arg_fail(1)) SWIG_fail;
13551 if (obj1) {
13552 {
13553 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13554 if (SWIG_arg_fail(2)) SWIG_fail;
13555 }
13556 }
13557 {
13558 PyThreadState* __tstate = wxPyBeginAllowThreads();
13559 result = (unsigned long)(arg1)->CountColours(arg2);
13560
13561 wxPyEndAllowThreads(__tstate);
13562 if (PyErr_Occurred()) SWIG_fail;
13563 }
13564 {
13565 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13566 }
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj;
13575 wxImage *arg1 = (wxImage *) 0 ;
13576 wxImageHistogram *arg2 = 0 ;
13577 unsigned long result;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 char *kwnames[] = {
13581 (char *) "self",(char *) "h", NULL
13582 };
13583
13584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13586 if (SWIG_arg_fail(1)) SWIG_fail;
13587 {
13588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13589 if (SWIG_arg_fail(2)) SWIG_fail;
13590 if (arg2 == NULL) {
13591 SWIG_null_ref("wxImageHistogram");
13592 }
13593 if (SWIG_arg_fail(2)) SWIG_fail;
13594 }
13595 {
13596 PyThreadState* __tstate = wxPyBeginAllowThreads();
13597 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13598
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 {
13603 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13604 }
13605 return resultobj;
13606 fail:
13607 return NULL;
13608 }
13609
13610
13611 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13612 PyObject *resultobj;
13613 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13614 PyObject * obj0 = 0 ;
13615 char *kwnames[] = {
13616 (char *) "handler", NULL
13617 };
13618
13619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13621 if (SWIG_arg_fail(1)) SWIG_fail;
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 wxImage::AddHandler(arg1);
13625
13626 wxPyEndAllowThreads(__tstate);
13627 if (PyErr_Occurred()) SWIG_fail;
13628 }
13629 Py_INCREF(Py_None); resultobj = Py_None;
13630 return resultobj;
13631 fail:
13632 return NULL;
13633 }
13634
13635
13636 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13637 PyObject *resultobj;
13638 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13639 PyObject * obj0 = 0 ;
13640 char *kwnames[] = {
13641 (char *) "handler", NULL
13642 };
13643
13644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13646 if (SWIG_arg_fail(1)) SWIG_fail;
13647 {
13648 PyThreadState* __tstate = wxPyBeginAllowThreads();
13649 wxImage::InsertHandler(arg1);
13650
13651 wxPyEndAllowThreads(__tstate);
13652 if (PyErr_Occurred()) SWIG_fail;
13653 }
13654 Py_INCREF(Py_None); resultobj = Py_None;
13655 return resultobj;
13656 fail:
13657 return NULL;
13658 }
13659
13660
13661 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13662 PyObject *resultobj;
13663 wxString *arg1 = 0 ;
13664 bool result;
13665 bool temp1 = false ;
13666 PyObject * obj0 = 0 ;
13667 char *kwnames[] = {
13668 (char *) "name", NULL
13669 };
13670
13671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13672 {
13673 arg1 = wxString_in_helper(obj0);
13674 if (arg1 == NULL) SWIG_fail;
13675 temp1 = true;
13676 }
13677 {
13678 PyThreadState* __tstate = wxPyBeginAllowThreads();
13679 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13680
13681 wxPyEndAllowThreads(__tstate);
13682 if (PyErr_Occurred()) SWIG_fail;
13683 }
13684 {
13685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13686 }
13687 {
13688 if (temp1)
13689 delete arg1;
13690 }
13691 return resultobj;
13692 fail:
13693 {
13694 if (temp1)
13695 delete arg1;
13696 }
13697 return NULL;
13698 }
13699
13700
13701 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13702 PyObject *resultobj;
13703 wxString result;
13704 char *kwnames[] = {
13705 NULL
13706 };
13707
13708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13709 {
13710 PyThreadState* __tstate = wxPyBeginAllowThreads();
13711 result = wxImage::GetImageExtWildcard();
13712
13713 wxPyEndAllowThreads(__tstate);
13714 if (PyErr_Occurred()) SWIG_fail;
13715 }
13716 {
13717 #if wxUSE_UNICODE
13718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13719 #else
13720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13721 #endif
13722 }
13723 return resultobj;
13724 fail:
13725 return NULL;
13726 }
13727
13728
13729 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13730 PyObject *resultobj;
13731 wxImage *arg1 = (wxImage *) 0 ;
13732 int arg2 = (int) -1 ;
13733 wxBitmap result;
13734 PyObject * obj0 = 0 ;
13735 PyObject * obj1 = 0 ;
13736 char *kwnames[] = {
13737 (char *) "self",(char *) "depth", NULL
13738 };
13739
13740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13742 if (SWIG_arg_fail(1)) SWIG_fail;
13743 if (obj1) {
13744 {
13745 arg2 = (int)(SWIG_As_int(obj1));
13746 if (SWIG_arg_fail(2)) SWIG_fail;
13747 }
13748 }
13749 {
13750 if (!wxPyCheckForApp()) SWIG_fail;
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = wxImage_ConvertToBitmap(arg1,arg2);
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 {
13758 wxBitmap * resultptr;
13759 resultptr = new wxBitmap((wxBitmap &)(result));
13760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13761 }
13762 return resultobj;
13763 fail:
13764 return NULL;
13765 }
13766
13767
13768 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13769 PyObject *resultobj;
13770 wxImage *arg1 = (wxImage *) 0 ;
13771 byte arg2 ;
13772 byte arg3 ;
13773 byte arg4 ;
13774 wxBitmap result;
13775 PyObject * obj0 = 0 ;
13776 PyObject * obj1 = 0 ;
13777 PyObject * obj2 = 0 ;
13778 PyObject * obj3 = 0 ;
13779 char *kwnames[] = {
13780 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13781 };
13782
13783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13785 if (SWIG_arg_fail(1)) SWIG_fail;
13786 {
13787 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13788 if (SWIG_arg_fail(2)) SWIG_fail;
13789 }
13790 {
13791 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13792 if (SWIG_arg_fail(3)) SWIG_fail;
13793 }
13794 {
13795 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13796 if (SWIG_arg_fail(4)) SWIG_fail;
13797 }
13798 {
13799 if (!wxPyCheckForApp()) SWIG_fail;
13800 PyThreadState* __tstate = wxPyBeginAllowThreads();
13801 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13802
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 {
13807 wxBitmap * resultptr;
13808 resultptr = new wxBitmap((wxBitmap &)(result));
13809 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13810 }
13811 return resultobj;
13812 fail:
13813 return NULL;
13814 }
13815
13816
13817 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13818 PyObject *obj;
13819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13820 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13821 Py_INCREF(obj);
13822 return Py_BuildValue((char *)"");
13823 }
13824 static int _wrap_NullImage_set(PyObject *) {
13825 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13826 return 1;
13827 }
13828
13829
13830 static PyObject *_wrap_NullImage_get(void) {
13831 PyObject *pyobj;
13832
13833 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13834 return pyobj;
13835 }
13836
13837
13838 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13839 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13840 return 1;
13841 }
13842
13843
13844 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13845 PyObject *pyobj;
13846
13847 {
13848 #if wxUSE_UNICODE
13849 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13850 #else
13851 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13852 #endif
13853 }
13854 return pyobj;
13855 }
13856
13857
13858 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13859 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13860 return 1;
13861 }
13862
13863
13864 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13865 PyObject *pyobj;
13866
13867 {
13868 #if wxUSE_UNICODE
13869 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13870 #else
13871 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13872 #endif
13873 }
13874 return pyobj;
13875 }
13876
13877
13878 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13879 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13880 return 1;
13881 }
13882
13883
13884 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13885 PyObject *pyobj;
13886
13887 {
13888 #if wxUSE_UNICODE
13889 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13890 #else
13891 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13892 #endif
13893 }
13894 return pyobj;
13895 }
13896
13897
13898 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13899 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13900 return 1;
13901 }
13902
13903
13904 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13905 PyObject *pyobj;
13906
13907 {
13908 #if wxUSE_UNICODE
13909 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13910 #else
13911 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13912 #endif
13913 }
13914 return pyobj;
13915 }
13916
13917
13918 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13919 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13920 return 1;
13921 }
13922
13923
13924 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13925 PyObject *pyobj;
13926
13927 {
13928 #if wxUSE_UNICODE
13929 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13930 #else
13931 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13932 #endif
13933 }
13934 return pyobj;
13935 }
13936
13937
13938 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13939 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13940 return 1;
13941 }
13942
13943
13944 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13945 PyObject *pyobj;
13946
13947 {
13948 #if wxUSE_UNICODE
13949 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13950 #else
13951 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13952 #endif
13953 }
13954 return pyobj;
13955 }
13956
13957
13958 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13959 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13960 return 1;
13961 }
13962
13963
13964 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13965 PyObject *pyobj;
13966
13967 {
13968 #if wxUSE_UNICODE
13969 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13970 #else
13971 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13972 #endif
13973 }
13974 return pyobj;
13975 }
13976
13977
13978 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13979 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13980 return 1;
13981 }
13982
13983
13984 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13985 PyObject *pyobj;
13986
13987 {
13988 #if wxUSE_UNICODE
13989 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13990 #else
13991 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13992 #endif
13993 }
13994 return pyobj;
13995 }
13996
13997
13998 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13999 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14000 return 1;
14001 }
14002
14003
14004 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14005 PyObject *pyobj;
14006
14007 {
14008 #if wxUSE_UNICODE
14009 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14010 #else
14011 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14012 #endif
14013 }
14014 return pyobj;
14015 }
14016
14017
14018 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14019 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14020 return 1;
14021 }
14022
14023
14024 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14025 PyObject *pyobj;
14026
14027 {
14028 #if wxUSE_UNICODE
14029 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14030 #else
14031 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14032 #endif
14033 }
14034 return pyobj;
14035 }
14036
14037
14038 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14039 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14040 return 1;
14041 }
14042
14043
14044 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14045 PyObject *pyobj;
14046
14047 {
14048 #if wxUSE_UNICODE
14049 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14050 #else
14051 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14052 #endif
14053 }
14054 return pyobj;
14055 }
14056
14057
14058 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14059 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14060 return 1;
14061 }
14062
14063
14064 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14065 PyObject *pyobj;
14066
14067 {
14068 #if wxUSE_UNICODE
14069 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14070 #else
14071 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14072 #endif
14073 }
14074 return pyobj;
14075 }
14076
14077
14078 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14079 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14080 return 1;
14081 }
14082
14083
14084 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14085 PyObject *pyobj;
14086
14087 {
14088 #if wxUSE_UNICODE
14089 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14090 #else
14091 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14092 #endif
14093 }
14094 return pyobj;
14095 }
14096
14097
14098 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14099 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14100 return 1;
14101 }
14102
14103
14104 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14105 PyObject *pyobj;
14106
14107 {
14108 #if wxUSE_UNICODE
14109 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14110 #else
14111 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14112 #endif
14113 }
14114 return pyobj;
14115 }
14116
14117
14118 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14119 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14120 return 1;
14121 }
14122
14123
14124 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14125 PyObject *pyobj;
14126
14127 {
14128 #if wxUSE_UNICODE
14129 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14130 #else
14131 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14132 #endif
14133 }
14134 return pyobj;
14135 }
14136
14137
14138 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14139 PyObject *resultobj;
14140 wxBMPHandler *result;
14141 char *kwnames[] = {
14142 NULL
14143 };
14144
14145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 result = (wxBMPHandler *)new wxBMPHandler();
14149
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14154 return resultobj;
14155 fail:
14156 return NULL;
14157 }
14158
14159
14160 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14161 PyObject *obj;
14162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14163 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14164 Py_INCREF(obj);
14165 return Py_BuildValue((char *)"");
14166 }
14167 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14168 PyObject *resultobj;
14169 wxICOHandler *result;
14170 char *kwnames[] = {
14171 NULL
14172 };
14173
14174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14175 {
14176 PyThreadState* __tstate = wxPyBeginAllowThreads();
14177 result = (wxICOHandler *)new wxICOHandler();
14178
14179 wxPyEndAllowThreads(__tstate);
14180 if (PyErr_Occurred()) SWIG_fail;
14181 }
14182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14183 return resultobj;
14184 fail:
14185 return NULL;
14186 }
14187
14188
14189 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14190 PyObject *obj;
14191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14192 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14193 Py_INCREF(obj);
14194 return Py_BuildValue((char *)"");
14195 }
14196 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14197 PyObject *resultobj;
14198 wxCURHandler *result;
14199 char *kwnames[] = {
14200 NULL
14201 };
14202
14203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 result = (wxCURHandler *)new wxCURHandler();
14207
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14219 PyObject *obj;
14220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14221 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14222 Py_INCREF(obj);
14223 return Py_BuildValue((char *)"");
14224 }
14225 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14226 PyObject *resultobj;
14227 wxANIHandler *result;
14228 char *kwnames[] = {
14229 NULL
14230 };
14231
14232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14233 {
14234 PyThreadState* __tstate = wxPyBeginAllowThreads();
14235 result = (wxANIHandler *)new wxANIHandler();
14236
14237 wxPyEndAllowThreads(__tstate);
14238 if (PyErr_Occurred()) SWIG_fail;
14239 }
14240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14248 PyObject *obj;
14249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14250 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14251 Py_INCREF(obj);
14252 return Py_BuildValue((char *)"");
14253 }
14254 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj;
14256 wxPNGHandler *result;
14257 char *kwnames[] = {
14258 NULL
14259 };
14260
14261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14262 {
14263 PyThreadState* __tstate = wxPyBeginAllowThreads();
14264 result = (wxPNGHandler *)new wxPNGHandler();
14265
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14277 PyObject *obj;
14278 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14279 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14280 Py_INCREF(obj);
14281 return Py_BuildValue((char *)"");
14282 }
14283 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14284 PyObject *resultobj;
14285 wxGIFHandler *result;
14286 char *kwnames[] = {
14287 NULL
14288 };
14289
14290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (wxGIFHandler *)new wxGIFHandler();
14294
14295 wxPyEndAllowThreads(__tstate);
14296 if (PyErr_Occurred()) SWIG_fail;
14297 }
14298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14299 return resultobj;
14300 fail:
14301 return NULL;
14302 }
14303
14304
14305 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14306 PyObject *obj;
14307 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14308 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14309 Py_INCREF(obj);
14310 return Py_BuildValue((char *)"");
14311 }
14312 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14313 PyObject *resultobj;
14314 wxPCXHandler *result;
14315 char *kwnames[] = {
14316 NULL
14317 };
14318
14319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14320 {
14321 PyThreadState* __tstate = wxPyBeginAllowThreads();
14322 result = (wxPCXHandler *)new wxPCXHandler();
14323
14324 wxPyEndAllowThreads(__tstate);
14325 if (PyErr_Occurred()) SWIG_fail;
14326 }
14327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14335 PyObject *obj;
14336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14337 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14338 Py_INCREF(obj);
14339 return Py_BuildValue((char *)"");
14340 }
14341 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj;
14343 wxJPEGHandler *result;
14344 char *kwnames[] = {
14345 NULL
14346 };
14347
14348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 result = (wxJPEGHandler *)new wxJPEGHandler();
14352
14353 wxPyEndAllowThreads(__tstate);
14354 if (PyErr_Occurred()) SWIG_fail;
14355 }
14356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14364 PyObject *obj;
14365 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14366 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14367 Py_INCREF(obj);
14368 return Py_BuildValue((char *)"");
14369 }
14370 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14371 PyObject *resultobj;
14372 wxPNMHandler *result;
14373 char *kwnames[] = {
14374 NULL
14375 };
14376
14377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (wxPNMHandler *)new wxPNMHandler();
14381
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14386 return resultobj;
14387 fail:
14388 return NULL;
14389 }
14390
14391
14392 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14393 PyObject *obj;
14394 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14395 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14396 Py_INCREF(obj);
14397 return Py_BuildValue((char *)"");
14398 }
14399 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14400 PyObject *resultobj;
14401 wxXPMHandler *result;
14402 char *kwnames[] = {
14403 NULL
14404 };
14405
14406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14407 {
14408 PyThreadState* __tstate = wxPyBeginAllowThreads();
14409 result = (wxXPMHandler *)new wxXPMHandler();
14410
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14415 return resultobj;
14416 fail:
14417 return NULL;
14418 }
14419
14420
14421 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14422 PyObject *obj;
14423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14424 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14425 Py_INCREF(obj);
14426 return Py_BuildValue((char *)"");
14427 }
14428 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14429 PyObject *resultobj;
14430 wxTIFFHandler *result;
14431 char *kwnames[] = {
14432 NULL
14433 };
14434
14435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14436 {
14437 PyThreadState* __tstate = wxPyBeginAllowThreads();
14438 result = (wxTIFFHandler *)new wxTIFFHandler();
14439
14440 wxPyEndAllowThreads(__tstate);
14441 if (PyErr_Occurred()) SWIG_fail;
14442 }
14443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14444 return resultobj;
14445 fail:
14446 return NULL;
14447 }
14448
14449
14450 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14451 PyObject *obj;
14452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14453 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14454 Py_INCREF(obj);
14455 return Py_BuildValue((char *)"");
14456 }
14457 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj;
14459 wxImage *arg1 = 0 ;
14460 wxImage *arg2 = 0 ;
14461 int arg3 = (int) 236 ;
14462 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14463 bool result;
14464 PyObject * obj0 = 0 ;
14465 PyObject * obj1 = 0 ;
14466 PyObject * obj2 = 0 ;
14467 PyObject * obj3 = 0 ;
14468 char *kwnames[] = {
14469 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14470 };
14471
14472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14473 {
14474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14475 if (SWIG_arg_fail(1)) SWIG_fail;
14476 if (arg1 == NULL) {
14477 SWIG_null_ref("wxImage");
14478 }
14479 if (SWIG_arg_fail(1)) SWIG_fail;
14480 }
14481 {
14482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14483 if (SWIG_arg_fail(2)) SWIG_fail;
14484 if (arg2 == NULL) {
14485 SWIG_null_ref("wxImage");
14486 }
14487 if (SWIG_arg_fail(2)) SWIG_fail;
14488 }
14489 if (obj2) {
14490 {
14491 arg3 = (int)(SWIG_As_int(obj2));
14492 if (SWIG_arg_fail(3)) SWIG_fail;
14493 }
14494 }
14495 if (obj3) {
14496 {
14497 arg4 = (int)(SWIG_As_int(obj3));
14498 if (SWIG_arg_fail(4)) SWIG_fail;
14499 }
14500 }
14501 {
14502 PyThreadState* __tstate = wxPyBeginAllowThreads();
14503 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14504
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14518 PyObject *obj;
14519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14520 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14521 Py_INCREF(obj);
14522 return Py_BuildValue((char *)"");
14523 }
14524 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14525 PyObject *resultobj;
14526 wxEvtHandler *result;
14527 char *kwnames[] = {
14528 NULL
14529 };
14530
14531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14532 {
14533 PyThreadState* __tstate = wxPyBeginAllowThreads();
14534 result = (wxEvtHandler *)new wxEvtHandler();
14535
14536 wxPyEndAllowThreads(__tstate);
14537 if (PyErr_Occurred()) SWIG_fail;
14538 }
14539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14540 return resultobj;
14541 fail:
14542 return NULL;
14543 }
14544
14545
14546 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14547 PyObject *resultobj;
14548 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14549 wxEvtHandler *result;
14550 PyObject * obj0 = 0 ;
14551 char *kwnames[] = {
14552 (char *) "self", NULL
14553 };
14554
14555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14557 if (SWIG_arg_fail(1)) SWIG_fail;
14558 {
14559 PyThreadState* __tstate = wxPyBeginAllowThreads();
14560 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14561
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 {
14566 resultobj = wxPyMake_wxObject(result, 0);
14567 }
14568 return resultobj;
14569 fail:
14570 return NULL;
14571 }
14572
14573
14574 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14575 PyObject *resultobj;
14576 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14577 wxEvtHandler *result;
14578 PyObject * obj0 = 0 ;
14579 char *kwnames[] = {
14580 (char *) "self", NULL
14581 };
14582
14583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14585 if (SWIG_arg_fail(1)) SWIG_fail;
14586 {
14587 PyThreadState* __tstate = wxPyBeginAllowThreads();
14588 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14589
14590 wxPyEndAllowThreads(__tstate);
14591 if (PyErr_Occurred()) SWIG_fail;
14592 }
14593 {
14594 resultobj = wxPyMake_wxObject(result, 0);
14595 }
14596 return resultobj;
14597 fail:
14598 return NULL;
14599 }
14600
14601
14602 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14603 PyObject *resultobj;
14604 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14605 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14606 PyObject * obj0 = 0 ;
14607 PyObject * obj1 = 0 ;
14608 char *kwnames[] = {
14609 (char *) "self",(char *) "handler", NULL
14610 };
14611
14612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14614 if (SWIG_arg_fail(1)) SWIG_fail;
14615 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14616 if (SWIG_arg_fail(2)) SWIG_fail;
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 (arg1)->SetNextHandler(arg2);
14620
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 Py_INCREF(Py_None); resultobj = Py_None;
14625 return resultobj;
14626 fail:
14627 return NULL;
14628 }
14629
14630
14631 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14632 PyObject *resultobj;
14633 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14634 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14635 PyObject * obj0 = 0 ;
14636 PyObject * obj1 = 0 ;
14637 char *kwnames[] = {
14638 (char *) "self",(char *) "handler", NULL
14639 };
14640
14641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14643 if (SWIG_arg_fail(1)) SWIG_fail;
14644 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14645 if (SWIG_arg_fail(2)) SWIG_fail;
14646 {
14647 PyThreadState* __tstate = wxPyBeginAllowThreads();
14648 (arg1)->SetPreviousHandler(arg2);
14649
14650 wxPyEndAllowThreads(__tstate);
14651 if (PyErr_Occurred()) SWIG_fail;
14652 }
14653 Py_INCREF(Py_None); resultobj = Py_None;
14654 return resultobj;
14655 fail:
14656 return NULL;
14657 }
14658
14659
14660 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14661 PyObject *resultobj;
14662 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14663 bool result;
14664 PyObject * obj0 = 0 ;
14665 char *kwnames[] = {
14666 (char *) "self", NULL
14667 };
14668
14669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14671 if (SWIG_arg_fail(1)) SWIG_fail;
14672 {
14673 PyThreadState* __tstate = wxPyBeginAllowThreads();
14674 result = (bool)(arg1)->GetEvtHandlerEnabled();
14675
14676 wxPyEndAllowThreads(__tstate);
14677 if (PyErr_Occurred()) SWIG_fail;
14678 }
14679 {
14680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14681 }
14682 return resultobj;
14683 fail:
14684 return NULL;
14685 }
14686
14687
14688 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14689 PyObject *resultobj;
14690 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14691 bool arg2 ;
14692 PyObject * obj0 = 0 ;
14693 PyObject * obj1 = 0 ;
14694 char *kwnames[] = {
14695 (char *) "self",(char *) "enabled", NULL
14696 };
14697
14698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14700 if (SWIG_arg_fail(1)) SWIG_fail;
14701 {
14702 arg2 = (bool)(SWIG_As_bool(obj1));
14703 if (SWIG_arg_fail(2)) SWIG_fail;
14704 }
14705 {
14706 PyThreadState* __tstate = wxPyBeginAllowThreads();
14707 (arg1)->SetEvtHandlerEnabled(arg2);
14708
14709 wxPyEndAllowThreads(__tstate);
14710 if (PyErr_Occurred()) SWIG_fail;
14711 }
14712 Py_INCREF(Py_None); resultobj = Py_None;
14713 return resultobj;
14714 fail:
14715 return NULL;
14716 }
14717
14718
14719 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14720 PyObject *resultobj;
14721 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14722 wxEvent *arg2 = 0 ;
14723 bool result;
14724 PyObject * obj0 = 0 ;
14725 PyObject * obj1 = 0 ;
14726 char *kwnames[] = {
14727 (char *) "self",(char *) "event", NULL
14728 };
14729
14730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14732 if (SWIG_arg_fail(1)) SWIG_fail;
14733 {
14734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14735 if (SWIG_arg_fail(2)) SWIG_fail;
14736 if (arg2 == NULL) {
14737 SWIG_null_ref("wxEvent");
14738 }
14739 if (SWIG_arg_fail(2)) SWIG_fail;
14740 }
14741 {
14742 PyThreadState* __tstate = wxPyBeginAllowThreads();
14743 result = (bool)(arg1)->ProcessEvent(*arg2);
14744
14745 wxPyEndAllowThreads(__tstate);
14746 if (PyErr_Occurred()) SWIG_fail;
14747 }
14748 {
14749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14750 }
14751 return resultobj;
14752 fail:
14753 return NULL;
14754 }
14755
14756
14757 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14758 PyObject *resultobj;
14759 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14760 wxEvent *arg2 = 0 ;
14761 PyObject * obj0 = 0 ;
14762 PyObject * obj1 = 0 ;
14763 char *kwnames[] = {
14764 (char *) "self",(char *) "event", NULL
14765 };
14766
14767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14769 if (SWIG_arg_fail(1)) SWIG_fail;
14770 {
14771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14772 if (SWIG_arg_fail(2)) SWIG_fail;
14773 if (arg2 == NULL) {
14774 SWIG_null_ref("wxEvent");
14775 }
14776 if (SWIG_arg_fail(2)) SWIG_fail;
14777 }
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 (arg1)->AddPendingEvent(*arg2);
14781
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 Py_INCREF(Py_None); resultobj = Py_None;
14786 return resultobj;
14787 fail:
14788 return NULL;
14789 }
14790
14791
14792 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14793 PyObject *resultobj;
14794 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14795 PyObject * obj0 = 0 ;
14796 char *kwnames[] = {
14797 (char *) "self", NULL
14798 };
14799
14800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14802 if (SWIG_arg_fail(1)) SWIG_fail;
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 (arg1)->ProcessPendingEvents();
14806
14807 wxPyEndAllowThreads(__tstate);
14808 if (PyErr_Occurred()) SWIG_fail;
14809 }
14810 Py_INCREF(Py_None); resultobj = Py_None;
14811 return resultobj;
14812 fail:
14813 return NULL;
14814 }
14815
14816
14817 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14818 PyObject *resultobj;
14819 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14820 int arg2 ;
14821 int arg3 ;
14822 int arg4 ;
14823 PyObject *arg5 = (PyObject *) 0 ;
14824 PyObject * obj0 = 0 ;
14825 PyObject * obj1 = 0 ;
14826 PyObject * obj2 = 0 ;
14827 PyObject * obj3 = 0 ;
14828 PyObject * obj4 = 0 ;
14829 char *kwnames[] = {
14830 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14831 };
14832
14833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14835 if (SWIG_arg_fail(1)) SWIG_fail;
14836 {
14837 arg2 = (int)(SWIG_As_int(obj1));
14838 if (SWIG_arg_fail(2)) SWIG_fail;
14839 }
14840 {
14841 arg3 = (int)(SWIG_As_int(obj2));
14842 if (SWIG_arg_fail(3)) SWIG_fail;
14843 }
14844 {
14845 arg4 = (int)(SWIG_As_int(obj3));
14846 if (SWIG_arg_fail(4)) SWIG_fail;
14847 }
14848 arg5 = obj4;
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14852
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 Py_INCREF(Py_None); resultobj = Py_None;
14857 return resultobj;
14858 fail:
14859 return NULL;
14860 }
14861
14862
14863 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14864 PyObject *resultobj;
14865 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14866 int arg2 ;
14867 int arg3 = (int) -1 ;
14868 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14869 bool result;
14870 PyObject * obj0 = 0 ;
14871 PyObject * obj1 = 0 ;
14872 PyObject * obj2 = 0 ;
14873 PyObject * obj3 = 0 ;
14874 char *kwnames[] = {
14875 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14876 };
14877
14878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14880 if (SWIG_arg_fail(1)) SWIG_fail;
14881 {
14882 arg2 = (int)(SWIG_As_int(obj1));
14883 if (SWIG_arg_fail(2)) SWIG_fail;
14884 }
14885 if (obj2) {
14886 {
14887 arg3 = (int)(SWIG_As_int(obj2));
14888 if (SWIG_arg_fail(3)) SWIG_fail;
14889 }
14890 }
14891 if (obj3) {
14892 {
14893 arg4 = (wxEventType)(SWIG_As_int(obj3));
14894 if (SWIG_arg_fail(4)) SWIG_fail;
14895 }
14896 }
14897 {
14898 PyThreadState* __tstate = wxPyBeginAllowThreads();
14899 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14900
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 {
14905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14906 }
14907 return resultobj;
14908 fail:
14909 return NULL;
14910 }
14911
14912
14913 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14914 PyObject *resultobj;
14915 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14916 PyObject *arg2 = (PyObject *) 0 ;
14917 bool arg3 = (bool) true ;
14918 PyObject * obj0 = 0 ;
14919 PyObject * obj1 = 0 ;
14920 PyObject * obj2 = 0 ;
14921 char *kwnames[] = {
14922 (char *) "self",(char *) "_self",(char *) "incref", NULL
14923 };
14924
14925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14927 if (SWIG_arg_fail(1)) SWIG_fail;
14928 arg2 = obj1;
14929 if (obj2) {
14930 {
14931 arg3 = (bool)(SWIG_As_bool(obj2));
14932 if (SWIG_arg_fail(3)) SWIG_fail;
14933 }
14934 }
14935 {
14936 PyThreadState* __tstate = wxPyBeginAllowThreads();
14937 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14938
14939 wxPyEndAllowThreads(__tstate);
14940 if (PyErr_Occurred()) SWIG_fail;
14941 }
14942 Py_INCREF(Py_None); resultobj = Py_None;
14943 return resultobj;
14944 fail:
14945 return NULL;
14946 }
14947
14948
14949 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14950 PyObject *obj;
14951 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14952 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14953 Py_INCREF(obj);
14954 return Py_BuildValue((char *)"");
14955 }
14956 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj;
14958 wxEventType result;
14959 char *kwnames[] = {
14960 NULL
14961 };
14962
14963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14964 {
14965 PyThreadState* __tstate = wxPyBeginAllowThreads();
14966 result = (wxEventType)wxNewEventType();
14967
14968 wxPyEndAllowThreads(__tstate);
14969 if (PyErr_Occurred()) SWIG_fail;
14970 }
14971 {
14972 resultobj = SWIG_From_int((int)(result));
14973 }
14974 return resultobj;
14975 fail:
14976 return NULL;
14977 }
14978
14979
14980 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14981 PyObject *resultobj;
14982 wxEvent *arg1 = (wxEvent *) 0 ;
14983 PyObject * obj0 = 0 ;
14984 char *kwnames[] = {
14985 (char *) "self", NULL
14986 };
14987
14988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14990 if (SWIG_arg_fail(1)) SWIG_fail;
14991 {
14992 PyThreadState* __tstate = wxPyBeginAllowThreads();
14993 delete arg1;
14994
14995 wxPyEndAllowThreads(__tstate);
14996 if (PyErr_Occurred()) SWIG_fail;
14997 }
14998 Py_INCREF(Py_None); resultobj = Py_None;
14999 return resultobj;
15000 fail:
15001 return NULL;
15002 }
15003
15004
15005 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15006 PyObject *resultobj;
15007 wxEvent *arg1 = (wxEvent *) 0 ;
15008 wxEventType arg2 ;
15009 PyObject * obj0 = 0 ;
15010 PyObject * obj1 = 0 ;
15011 char *kwnames[] = {
15012 (char *) "self",(char *) "typ", NULL
15013 };
15014
15015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15017 if (SWIG_arg_fail(1)) SWIG_fail;
15018 {
15019 arg2 = (wxEventType)(SWIG_As_int(obj1));
15020 if (SWIG_arg_fail(2)) SWIG_fail;
15021 }
15022 {
15023 PyThreadState* __tstate = wxPyBeginAllowThreads();
15024 (arg1)->SetEventType(arg2);
15025
15026 wxPyEndAllowThreads(__tstate);
15027 if (PyErr_Occurred()) SWIG_fail;
15028 }
15029 Py_INCREF(Py_None); resultobj = Py_None;
15030 return resultobj;
15031 fail:
15032 return NULL;
15033 }
15034
15035
15036 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15037 PyObject *resultobj;
15038 wxEvent *arg1 = (wxEvent *) 0 ;
15039 wxEventType result;
15040 PyObject * obj0 = 0 ;
15041 char *kwnames[] = {
15042 (char *) "self", NULL
15043 };
15044
15045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15047 if (SWIG_arg_fail(1)) SWIG_fail;
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15051
15052 wxPyEndAllowThreads(__tstate);
15053 if (PyErr_Occurred()) SWIG_fail;
15054 }
15055 {
15056 resultobj = SWIG_From_int((int)(result));
15057 }
15058 return resultobj;
15059 fail:
15060 return NULL;
15061 }
15062
15063
15064 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj;
15066 wxEvent *arg1 = (wxEvent *) 0 ;
15067 wxObject *result;
15068 PyObject * obj0 = 0 ;
15069 char *kwnames[] = {
15070 (char *) "self", NULL
15071 };
15072
15073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15075 if (SWIG_arg_fail(1)) SWIG_fail;
15076 {
15077 PyThreadState* __tstate = wxPyBeginAllowThreads();
15078 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15079
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 {
15084 resultobj = wxPyMake_wxObject(result, 0);
15085 }
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15093 PyObject *resultobj;
15094 wxEvent *arg1 = (wxEvent *) 0 ;
15095 wxObject *arg2 = (wxObject *) 0 ;
15096 PyObject * obj0 = 0 ;
15097 PyObject * obj1 = 0 ;
15098 char *kwnames[] = {
15099 (char *) "self",(char *) "obj", NULL
15100 };
15101
15102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15104 if (SWIG_arg_fail(1)) SWIG_fail;
15105 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15106 if (SWIG_arg_fail(2)) SWIG_fail;
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 (arg1)->SetEventObject(arg2);
15110
15111 wxPyEndAllowThreads(__tstate);
15112 if (PyErr_Occurred()) SWIG_fail;
15113 }
15114 Py_INCREF(Py_None); resultobj = Py_None;
15115 return resultobj;
15116 fail:
15117 return NULL;
15118 }
15119
15120
15121 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15122 PyObject *resultobj;
15123 wxEvent *arg1 = (wxEvent *) 0 ;
15124 long result;
15125 PyObject * obj0 = 0 ;
15126 char *kwnames[] = {
15127 (char *) "self", NULL
15128 };
15129
15130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15132 if (SWIG_arg_fail(1)) SWIG_fail;
15133 {
15134 PyThreadState* __tstate = wxPyBeginAllowThreads();
15135 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15136
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 {
15141 resultobj = SWIG_From_long((long)(result));
15142 }
15143 return resultobj;
15144 fail:
15145 return NULL;
15146 }
15147
15148
15149 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15150 PyObject *resultobj;
15151 wxEvent *arg1 = (wxEvent *) 0 ;
15152 long arg2 = (long) 0 ;
15153 PyObject * obj0 = 0 ;
15154 PyObject * obj1 = 0 ;
15155 char *kwnames[] = {
15156 (char *) "self",(char *) "ts", NULL
15157 };
15158
15159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15161 if (SWIG_arg_fail(1)) SWIG_fail;
15162 if (obj1) {
15163 {
15164 arg2 = (long)(SWIG_As_long(obj1));
15165 if (SWIG_arg_fail(2)) SWIG_fail;
15166 }
15167 }
15168 {
15169 PyThreadState* __tstate = wxPyBeginAllowThreads();
15170 (arg1)->SetTimestamp(arg2);
15171
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 Py_INCREF(Py_None); resultobj = Py_None;
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15183 PyObject *resultobj;
15184 wxEvent *arg1 = (wxEvent *) 0 ;
15185 int result;
15186 PyObject * obj0 = 0 ;
15187 char *kwnames[] = {
15188 (char *) "self", NULL
15189 };
15190
15191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15193 if (SWIG_arg_fail(1)) SWIG_fail;
15194 {
15195 PyThreadState* __tstate = wxPyBeginAllowThreads();
15196 result = (int)((wxEvent const *)arg1)->GetId();
15197
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 {
15202 resultobj = SWIG_From_int((int)(result));
15203 }
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj;
15212 wxEvent *arg1 = (wxEvent *) 0 ;
15213 int arg2 ;
15214 PyObject * obj0 = 0 ;
15215 PyObject * obj1 = 0 ;
15216 char *kwnames[] = {
15217 (char *) "self",(char *) "Id", NULL
15218 };
15219
15220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15222 if (SWIG_arg_fail(1)) SWIG_fail;
15223 {
15224 arg2 = (int)(SWIG_As_int(obj1));
15225 if (SWIG_arg_fail(2)) SWIG_fail;
15226 }
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 (arg1)->SetId(arg2);
15230
15231 wxPyEndAllowThreads(__tstate);
15232 if (PyErr_Occurred()) SWIG_fail;
15233 }
15234 Py_INCREF(Py_None); resultobj = Py_None;
15235 return resultobj;
15236 fail:
15237 return NULL;
15238 }
15239
15240
15241 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15242 PyObject *resultobj;
15243 wxEvent *arg1 = (wxEvent *) 0 ;
15244 bool result;
15245 PyObject * obj0 = 0 ;
15246 char *kwnames[] = {
15247 (char *) "self", NULL
15248 };
15249
15250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15252 if (SWIG_arg_fail(1)) SWIG_fail;
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15256
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 {
15261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15262 }
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15270 PyObject *resultobj;
15271 wxEvent *arg1 = (wxEvent *) 0 ;
15272 bool arg2 = (bool) true ;
15273 PyObject * obj0 = 0 ;
15274 PyObject * obj1 = 0 ;
15275 char *kwnames[] = {
15276 (char *) "self",(char *) "skip", NULL
15277 };
15278
15279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15281 if (SWIG_arg_fail(1)) SWIG_fail;
15282 if (obj1) {
15283 {
15284 arg2 = (bool)(SWIG_As_bool(obj1));
15285 if (SWIG_arg_fail(2)) SWIG_fail;
15286 }
15287 }
15288 {
15289 PyThreadState* __tstate = wxPyBeginAllowThreads();
15290 (arg1)->Skip(arg2);
15291
15292 wxPyEndAllowThreads(__tstate);
15293 if (PyErr_Occurred()) SWIG_fail;
15294 }
15295 Py_INCREF(Py_None); resultobj = Py_None;
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15303 PyObject *resultobj;
15304 wxEvent *arg1 = (wxEvent *) 0 ;
15305 bool result;
15306 PyObject * obj0 = 0 ;
15307 char *kwnames[] = {
15308 (char *) "self", NULL
15309 };
15310
15311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15313 if (SWIG_arg_fail(1)) SWIG_fail;
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15317
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 {
15322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15323 }
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15331 PyObject *resultobj;
15332 wxEvent *arg1 = (wxEvent *) 0 ;
15333 bool result;
15334 PyObject * obj0 = 0 ;
15335 char *kwnames[] = {
15336 (char *) "self", NULL
15337 };
15338
15339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15341 if (SWIG_arg_fail(1)) SWIG_fail;
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15345
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 {
15350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15351 }
15352 return resultobj;
15353 fail:
15354 return NULL;
15355 }
15356
15357
15358 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15359 PyObject *resultobj;
15360 wxEvent *arg1 = (wxEvent *) 0 ;
15361 int result;
15362 PyObject * obj0 = 0 ;
15363 char *kwnames[] = {
15364 (char *) "self", NULL
15365 };
15366
15367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15369 if (SWIG_arg_fail(1)) SWIG_fail;
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (int)(arg1)->StopPropagation();
15373
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 {
15378 resultobj = SWIG_From_int((int)(result));
15379 }
15380 return resultobj;
15381 fail:
15382 return NULL;
15383 }
15384
15385
15386 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15387 PyObject *resultobj;
15388 wxEvent *arg1 = (wxEvent *) 0 ;
15389 int arg2 ;
15390 PyObject * obj0 = 0 ;
15391 PyObject * obj1 = 0 ;
15392 char *kwnames[] = {
15393 (char *) "self",(char *) "propagationLevel", NULL
15394 };
15395
15396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15398 if (SWIG_arg_fail(1)) SWIG_fail;
15399 {
15400 arg2 = (int)(SWIG_As_int(obj1));
15401 if (SWIG_arg_fail(2)) SWIG_fail;
15402 }
15403 {
15404 PyThreadState* __tstate = wxPyBeginAllowThreads();
15405 (arg1)->ResumePropagation(arg2);
15406
15407 wxPyEndAllowThreads(__tstate);
15408 if (PyErr_Occurred()) SWIG_fail;
15409 }
15410 Py_INCREF(Py_None); resultobj = Py_None;
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15418 PyObject *resultobj;
15419 wxEvent *arg1 = (wxEvent *) 0 ;
15420 wxEvent *result;
15421 PyObject * obj0 = 0 ;
15422 char *kwnames[] = {
15423 (char *) "self", NULL
15424 };
15425
15426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15428 if (SWIG_arg_fail(1)) SWIG_fail;
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (wxEvent *)(arg1)->Clone();
15432
15433 wxPyEndAllowThreads(__tstate);
15434 if (PyErr_Occurred()) SWIG_fail;
15435 }
15436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15437 return resultobj;
15438 fail:
15439 return NULL;
15440 }
15441
15442
15443 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15444 PyObject *obj;
15445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15446 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15447 Py_INCREF(obj);
15448 return Py_BuildValue((char *)"");
15449 }
15450 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15451 PyObject *resultobj;
15452 wxEvent *arg1 = 0 ;
15453 wxPropagationDisabler *result;
15454 PyObject * obj0 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "event", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15460 {
15461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15462 if (SWIG_arg_fail(1)) SWIG_fail;
15463 if (arg1 == NULL) {
15464 SWIG_null_ref("wxEvent");
15465 }
15466 if (SWIG_arg_fail(1)) SWIG_fail;
15467 }
15468 {
15469 PyThreadState* __tstate = wxPyBeginAllowThreads();
15470 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15471
15472 wxPyEndAllowThreads(__tstate);
15473 if (PyErr_Occurred()) SWIG_fail;
15474 }
15475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15476 return resultobj;
15477 fail:
15478 return NULL;
15479 }
15480
15481
15482 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15483 PyObject *resultobj;
15484 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15485 PyObject * obj0 = 0 ;
15486 char *kwnames[] = {
15487 (char *) "self", NULL
15488 };
15489
15490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15492 if (SWIG_arg_fail(1)) SWIG_fail;
15493 {
15494 PyThreadState* __tstate = wxPyBeginAllowThreads();
15495 delete arg1;
15496
15497 wxPyEndAllowThreads(__tstate);
15498 if (PyErr_Occurred()) SWIG_fail;
15499 }
15500 Py_INCREF(Py_None); resultobj = Py_None;
15501 return resultobj;
15502 fail:
15503 return NULL;
15504 }
15505
15506
15507 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15508 PyObject *obj;
15509 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15510 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15511 Py_INCREF(obj);
15512 return Py_BuildValue((char *)"");
15513 }
15514 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15515 PyObject *resultobj;
15516 wxEvent *arg1 = 0 ;
15517 wxPropagateOnce *result;
15518 PyObject * obj0 = 0 ;
15519 char *kwnames[] = {
15520 (char *) "event", NULL
15521 };
15522
15523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15524 {
15525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15526 if (SWIG_arg_fail(1)) SWIG_fail;
15527 if (arg1 == NULL) {
15528 SWIG_null_ref("wxEvent");
15529 }
15530 if (SWIG_arg_fail(1)) SWIG_fail;
15531 }
15532 {
15533 PyThreadState* __tstate = wxPyBeginAllowThreads();
15534 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15535
15536 wxPyEndAllowThreads(__tstate);
15537 if (PyErr_Occurred()) SWIG_fail;
15538 }
15539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15540 return resultobj;
15541 fail:
15542 return NULL;
15543 }
15544
15545
15546 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15547 PyObject *resultobj;
15548 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15549 PyObject * obj0 = 0 ;
15550 char *kwnames[] = {
15551 (char *) "self", NULL
15552 };
15553
15554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15556 if (SWIG_arg_fail(1)) SWIG_fail;
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 delete arg1;
15560
15561 wxPyEndAllowThreads(__tstate);
15562 if (PyErr_Occurred()) SWIG_fail;
15563 }
15564 Py_INCREF(Py_None); resultobj = Py_None;
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15572 PyObject *obj;
15573 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15574 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15575 Py_INCREF(obj);
15576 return Py_BuildValue((char *)"");
15577 }
15578 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15579 PyObject *resultobj;
15580 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15581 int arg2 = (int) 0 ;
15582 wxCommandEvent *result;
15583 PyObject * obj0 = 0 ;
15584 PyObject * obj1 = 0 ;
15585 char *kwnames[] = {
15586 (char *) "commandType",(char *) "winid", NULL
15587 };
15588
15589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15590 if (obj0) {
15591 {
15592 arg1 = (wxEventType)(SWIG_As_int(obj0));
15593 if (SWIG_arg_fail(1)) SWIG_fail;
15594 }
15595 }
15596 if (obj1) {
15597 {
15598 arg2 = (int)(SWIG_As_int(obj1));
15599 if (SWIG_arg_fail(2)) SWIG_fail;
15600 }
15601 }
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15605
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj;
15618 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15619 int result;
15620 PyObject * obj0 = 0 ;
15621 char *kwnames[] = {
15622 (char *) "self", NULL
15623 };
15624
15625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15627 if (SWIG_arg_fail(1)) SWIG_fail;
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15631
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 {
15636 resultobj = SWIG_From_int((int)(result));
15637 }
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj;
15646 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15647 wxString *arg2 = 0 ;
15648 bool temp2 = false ;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 char *kwnames[] = {
15652 (char *) "self",(char *) "s", NULL
15653 };
15654
15655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15657 if (SWIG_arg_fail(1)) SWIG_fail;
15658 {
15659 arg2 = wxString_in_helper(obj1);
15660 if (arg2 == NULL) SWIG_fail;
15661 temp2 = true;
15662 }
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 (arg1)->SetString((wxString const &)*arg2);
15666
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 Py_INCREF(Py_None); resultobj = Py_None;
15671 {
15672 if (temp2)
15673 delete arg2;
15674 }
15675 return resultobj;
15676 fail:
15677 {
15678 if (temp2)
15679 delete arg2;
15680 }
15681 return NULL;
15682 }
15683
15684
15685 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15686 PyObject *resultobj;
15687 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15688 wxString result;
15689 PyObject * obj0 = 0 ;
15690 char *kwnames[] = {
15691 (char *) "self", NULL
15692 };
15693
15694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15696 if (SWIG_arg_fail(1)) SWIG_fail;
15697 {
15698 PyThreadState* __tstate = wxPyBeginAllowThreads();
15699 result = ((wxCommandEvent const *)arg1)->GetString();
15700
15701 wxPyEndAllowThreads(__tstate);
15702 if (PyErr_Occurred()) SWIG_fail;
15703 }
15704 {
15705 #if wxUSE_UNICODE
15706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15707 #else
15708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15709 #endif
15710 }
15711 return resultobj;
15712 fail:
15713 return NULL;
15714 }
15715
15716
15717 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15718 PyObject *resultobj;
15719 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15720 bool result;
15721 PyObject * obj0 = 0 ;
15722 char *kwnames[] = {
15723 (char *) "self", NULL
15724 };
15725
15726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15728 if (SWIG_arg_fail(1)) SWIG_fail;
15729 {
15730 PyThreadState* __tstate = wxPyBeginAllowThreads();
15731 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15732
15733 wxPyEndAllowThreads(__tstate);
15734 if (PyErr_Occurred()) SWIG_fail;
15735 }
15736 {
15737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15738 }
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15746 PyObject *resultobj;
15747 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15748 bool result;
15749 PyObject * obj0 = 0 ;
15750 char *kwnames[] = {
15751 (char *) "self", NULL
15752 };
15753
15754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15756 if (SWIG_arg_fail(1)) SWIG_fail;
15757 {
15758 PyThreadState* __tstate = wxPyBeginAllowThreads();
15759 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15760
15761 wxPyEndAllowThreads(__tstate);
15762 if (PyErr_Occurred()) SWIG_fail;
15763 }
15764 {
15765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15766 }
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15774 PyObject *resultobj;
15775 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15776 long arg2 ;
15777 PyObject * obj0 = 0 ;
15778 PyObject * obj1 = 0 ;
15779 char *kwnames[] = {
15780 (char *) "self",(char *) "extraLong", NULL
15781 };
15782
15783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15785 if (SWIG_arg_fail(1)) SWIG_fail;
15786 {
15787 arg2 = (long)(SWIG_As_long(obj1));
15788 if (SWIG_arg_fail(2)) SWIG_fail;
15789 }
15790 {
15791 PyThreadState* __tstate = wxPyBeginAllowThreads();
15792 (arg1)->SetExtraLong(arg2);
15793
15794 wxPyEndAllowThreads(__tstate);
15795 if (PyErr_Occurred()) SWIG_fail;
15796 }
15797 Py_INCREF(Py_None); resultobj = Py_None;
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15805 PyObject *resultobj;
15806 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15807 long result;
15808 PyObject * obj0 = 0 ;
15809 char *kwnames[] = {
15810 (char *) "self", NULL
15811 };
15812
15813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15815 if (SWIG_arg_fail(1)) SWIG_fail;
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15819
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 {
15824 resultobj = SWIG_From_long((long)(result));
15825 }
15826 return resultobj;
15827 fail:
15828 return NULL;
15829 }
15830
15831
15832 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15833 PyObject *resultobj;
15834 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15835 int arg2 ;
15836 PyObject * obj0 = 0 ;
15837 PyObject * obj1 = 0 ;
15838 char *kwnames[] = {
15839 (char *) "self",(char *) "i", NULL
15840 };
15841
15842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15844 if (SWIG_arg_fail(1)) SWIG_fail;
15845 {
15846 arg2 = (int)(SWIG_As_int(obj1));
15847 if (SWIG_arg_fail(2)) SWIG_fail;
15848 }
15849 {
15850 PyThreadState* __tstate = wxPyBeginAllowThreads();
15851 (arg1)->SetInt(arg2);
15852
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 Py_INCREF(Py_None); resultobj = Py_None;
15857 return resultobj;
15858 fail:
15859 return NULL;
15860 }
15861
15862
15863 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj;
15865 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15866 long result;
15867 PyObject * obj0 = 0 ;
15868 char *kwnames[] = {
15869 (char *) "self", NULL
15870 };
15871
15872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15874 if (SWIG_arg_fail(1)) SWIG_fail;
15875 {
15876 PyThreadState* __tstate = wxPyBeginAllowThreads();
15877 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15878
15879 wxPyEndAllowThreads(__tstate);
15880 if (PyErr_Occurred()) SWIG_fail;
15881 }
15882 {
15883 resultobj = SWIG_From_long((long)(result));
15884 }
15885 return resultobj;
15886 fail:
15887 return NULL;
15888 }
15889
15890
15891 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15892 PyObject *resultobj;
15893 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15894 wxEvent *result;
15895 PyObject * obj0 = 0 ;
15896 char *kwnames[] = {
15897 (char *) "self", NULL
15898 };
15899
15900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15902 if (SWIG_arg_fail(1)) SWIG_fail;
15903 {
15904 PyThreadState* __tstate = wxPyBeginAllowThreads();
15905 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15906
15907 wxPyEndAllowThreads(__tstate);
15908 if (PyErr_Occurred()) SWIG_fail;
15909 }
15910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15911 return resultobj;
15912 fail:
15913 return NULL;
15914 }
15915
15916
15917 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15918 PyObject *obj;
15919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15920 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15921 Py_INCREF(obj);
15922 return Py_BuildValue((char *)"");
15923 }
15924 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15925 PyObject *resultobj;
15926 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15927 int arg2 = (int) 0 ;
15928 wxNotifyEvent *result;
15929 PyObject * obj0 = 0 ;
15930 PyObject * obj1 = 0 ;
15931 char *kwnames[] = {
15932 (char *) "commandType",(char *) "winid", NULL
15933 };
15934
15935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15936 if (obj0) {
15937 {
15938 arg1 = (wxEventType)(SWIG_As_int(obj0));
15939 if (SWIG_arg_fail(1)) SWIG_fail;
15940 }
15941 }
15942 if (obj1) {
15943 {
15944 arg2 = (int)(SWIG_As_int(obj1));
15945 if (SWIG_arg_fail(2)) SWIG_fail;
15946 }
15947 }
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15951
15952 wxPyEndAllowThreads(__tstate);
15953 if (PyErr_Occurred()) SWIG_fail;
15954 }
15955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15956 return resultobj;
15957 fail:
15958 return NULL;
15959 }
15960
15961
15962 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15963 PyObject *resultobj;
15964 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15965 PyObject * obj0 = 0 ;
15966 char *kwnames[] = {
15967 (char *) "self", NULL
15968 };
15969
15970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15972 if (SWIG_arg_fail(1)) SWIG_fail;
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 (arg1)->Veto();
15976
15977 wxPyEndAllowThreads(__tstate);
15978 if (PyErr_Occurred()) SWIG_fail;
15979 }
15980 Py_INCREF(Py_None); resultobj = Py_None;
15981 return resultobj;
15982 fail:
15983 return NULL;
15984 }
15985
15986
15987 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15988 PyObject *resultobj;
15989 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15990 PyObject * obj0 = 0 ;
15991 char *kwnames[] = {
15992 (char *) "self", NULL
15993 };
15994
15995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15997 if (SWIG_arg_fail(1)) SWIG_fail;
15998 {
15999 PyThreadState* __tstate = wxPyBeginAllowThreads();
16000 (arg1)->Allow();
16001
16002 wxPyEndAllowThreads(__tstate);
16003 if (PyErr_Occurred()) SWIG_fail;
16004 }
16005 Py_INCREF(Py_None); resultobj = Py_None;
16006 return resultobj;
16007 fail:
16008 return NULL;
16009 }
16010
16011
16012 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16013 PyObject *resultobj;
16014 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16015 bool result;
16016 PyObject * obj0 = 0 ;
16017 char *kwnames[] = {
16018 (char *) "self", NULL
16019 };
16020
16021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16023 if (SWIG_arg_fail(1)) SWIG_fail;
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 result = (bool)(arg1)->IsAllowed();
16027
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 {
16032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16033 }
16034 return resultobj;
16035 fail:
16036 return NULL;
16037 }
16038
16039
16040 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16041 PyObject *obj;
16042 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16043 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16044 Py_INCREF(obj);
16045 return Py_BuildValue((char *)"");
16046 }
16047 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16048 PyObject *resultobj;
16049 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16050 int arg2 = (int) 0 ;
16051 int arg3 = (int) 0 ;
16052 int arg4 = (int) 0 ;
16053 wxScrollEvent *result;
16054 PyObject * obj0 = 0 ;
16055 PyObject * obj1 = 0 ;
16056 PyObject * obj2 = 0 ;
16057 PyObject * obj3 = 0 ;
16058 char *kwnames[] = {
16059 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16060 };
16061
16062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16063 if (obj0) {
16064 {
16065 arg1 = (wxEventType)(SWIG_As_int(obj0));
16066 if (SWIG_arg_fail(1)) SWIG_fail;
16067 }
16068 }
16069 if (obj1) {
16070 {
16071 arg2 = (int)(SWIG_As_int(obj1));
16072 if (SWIG_arg_fail(2)) SWIG_fail;
16073 }
16074 }
16075 if (obj2) {
16076 {
16077 arg3 = (int)(SWIG_As_int(obj2));
16078 if (SWIG_arg_fail(3)) SWIG_fail;
16079 }
16080 }
16081 if (obj3) {
16082 {
16083 arg4 = (int)(SWIG_As_int(obj3));
16084 if (SWIG_arg_fail(4)) SWIG_fail;
16085 }
16086 }
16087 {
16088 PyThreadState* __tstate = wxPyBeginAllowThreads();
16089 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16090
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16102 PyObject *resultobj;
16103 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16104 int result;
16105 PyObject * obj0 = 0 ;
16106 char *kwnames[] = {
16107 (char *) "self", NULL
16108 };
16109
16110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16112 if (SWIG_arg_fail(1)) SWIG_fail;
16113 {
16114 PyThreadState* __tstate = wxPyBeginAllowThreads();
16115 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16116
16117 wxPyEndAllowThreads(__tstate);
16118 if (PyErr_Occurred()) SWIG_fail;
16119 }
16120 {
16121 resultobj = SWIG_From_int((int)(result));
16122 }
16123 return resultobj;
16124 fail:
16125 return NULL;
16126 }
16127
16128
16129 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16130 PyObject *resultobj;
16131 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16132 int result;
16133 PyObject * obj0 = 0 ;
16134 char *kwnames[] = {
16135 (char *) "self", NULL
16136 };
16137
16138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16140 if (SWIG_arg_fail(1)) SWIG_fail;
16141 {
16142 PyThreadState* __tstate = wxPyBeginAllowThreads();
16143 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16144
16145 wxPyEndAllowThreads(__tstate);
16146 if (PyErr_Occurred()) SWIG_fail;
16147 }
16148 {
16149 resultobj = SWIG_From_int((int)(result));
16150 }
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16158 PyObject *resultobj;
16159 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16160 int arg2 ;
16161 PyObject * obj0 = 0 ;
16162 PyObject * obj1 = 0 ;
16163 char *kwnames[] = {
16164 (char *) "self",(char *) "orient", NULL
16165 };
16166
16167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16169 if (SWIG_arg_fail(1)) SWIG_fail;
16170 {
16171 arg2 = (int)(SWIG_As_int(obj1));
16172 if (SWIG_arg_fail(2)) SWIG_fail;
16173 }
16174 {
16175 PyThreadState* __tstate = wxPyBeginAllowThreads();
16176 (arg1)->SetOrientation(arg2);
16177
16178 wxPyEndAllowThreads(__tstate);
16179 if (PyErr_Occurred()) SWIG_fail;
16180 }
16181 Py_INCREF(Py_None); resultobj = Py_None;
16182 return resultobj;
16183 fail:
16184 return NULL;
16185 }
16186
16187
16188 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16189 PyObject *resultobj;
16190 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16191 int arg2 ;
16192 PyObject * obj0 = 0 ;
16193 PyObject * obj1 = 0 ;
16194 char *kwnames[] = {
16195 (char *) "self",(char *) "pos", NULL
16196 };
16197
16198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16200 if (SWIG_arg_fail(1)) SWIG_fail;
16201 {
16202 arg2 = (int)(SWIG_As_int(obj1));
16203 if (SWIG_arg_fail(2)) SWIG_fail;
16204 }
16205 {
16206 PyThreadState* __tstate = wxPyBeginAllowThreads();
16207 (arg1)->SetPosition(arg2);
16208
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 Py_INCREF(Py_None); resultobj = Py_None;
16213 return resultobj;
16214 fail:
16215 return NULL;
16216 }
16217
16218
16219 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16220 PyObject *obj;
16221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16222 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16223 Py_INCREF(obj);
16224 return Py_BuildValue((char *)"");
16225 }
16226 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16227 PyObject *resultobj;
16228 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16229 int arg2 = (int) 0 ;
16230 int arg3 = (int) 0 ;
16231 wxScrollWinEvent *result;
16232 PyObject * obj0 = 0 ;
16233 PyObject * obj1 = 0 ;
16234 PyObject * obj2 = 0 ;
16235 char *kwnames[] = {
16236 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16237 };
16238
16239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16240 if (obj0) {
16241 {
16242 arg1 = (wxEventType)(SWIG_As_int(obj0));
16243 if (SWIG_arg_fail(1)) SWIG_fail;
16244 }
16245 }
16246 if (obj1) {
16247 {
16248 arg2 = (int)(SWIG_As_int(obj1));
16249 if (SWIG_arg_fail(2)) SWIG_fail;
16250 }
16251 }
16252 if (obj2) {
16253 {
16254 arg3 = (int)(SWIG_As_int(obj2));
16255 if (SWIG_arg_fail(3)) SWIG_fail;
16256 }
16257 }
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16261
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16273 PyObject *resultobj;
16274 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16275 int result;
16276 PyObject * obj0 = 0 ;
16277 char *kwnames[] = {
16278 (char *) "self", NULL
16279 };
16280
16281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16283 if (SWIG_arg_fail(1)) SWIG_fail;
16284 {
16285 PyThreadState* __tstate = wxPyBeginAllowThreads();
16286 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16287
16288 wxPyEndAllowThreads(__tstate);
16289 if (PyErr_Occurred()) SWIG_fail;
16290 }
16291 {
16292 resultobj = SWIG_From_int((int)(result));
16293 }
16294 return resultobj;
16295 fail:
16296 return NULL;
16297 }
16298
16299
16300 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16301 PyObject *resultobj;
16302 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16303 int result;
16304 PyObject * obj0 = 0 ;
16305 char *kwnames[] = {
16306 (char *) "self", NULL
16307 };
16308
16309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16311 if (SWIG_arg_fail(1)) SWIG_fail;
16312 {
16313 PyThreadState* __tstate = wxPyBeginAllowThreads();
16314 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16315
16316 wxPyEndAllowThreads(__tstate);
16317 if (PyErr_Occurred()) SWIG_fail;
16318 }
16319 {
16320 resultobj = SWIG_From_int((int)(result));
16321 }
16322 return resultobj;
16323 fail:
16324 return NULL;
16325 }
16326
16327
16328 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16329 PyObject *resultobj;
16330 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16331 int arg2 ;
16332 PyObject * obj0 = 0 ;
16333 PyObject * obj1 = 0 ;
16334 char *kwnames[] = {
16335 (char *) "self",(char *) "orient", NULL
16336 };
16337
16338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16340 if (SWIG_arg_fail(1)) SWIG_fail;
16341 {
16342 arg2 = (int)(SWIG_As_int(obj1));
16343 if (SWIG_arg_fail(2)) SWIG_fail;
16344 }
16345 {
16346 PyThreadState* __tstate = wxPyBeginAllowThreads();
16347 (arg1)->SetOrientation(arg2);
16348
16349 wxPyEndAllowThreads(__tstate);
16350 if (PyErr_Occurred()) SWIG_fail;
16351 }
16352 Py_INCREF(Py_None); resultobj = Py_None;
16353 return resultobj;
16354 fail:
16355 return NULL;
16356 }
16357
16358
16359 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16360 PyObject *resultobj;
16361 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16362 int arg2 ;
16363 PyObject * obj0 = 0 ;
16364 PyObject * obj1 = 0 ;
16365 char *kwnames[] = {
16366 (char *) "self",(char *) "pos", NULL
16367 };
16368
16369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16371 if (SWIG_arg_fail(1)) SWIG_fail;
16372 {
16373 arg2 = (int)(SWIG_As_int(obj1));
16374 if (SWIG_arg_fail(2)) SWIG_fail;
16375 }
16376 {
16377 PyThreadState* __tstate = wxPyBeginAllowThreads();
16378 (arg1)->SetPosition(arg2);
16379
16380 wxPyEndAllowThreads(__tstate);
16381 if (PyErr_Occurred()) SWIG_fail;
16382 }
16383 Py_INCREF(Py_None); resultobj = Py_None;
16384 return resultobj;
16385 fail:
16386 return NULL;
16387 }
16388
16389
16390 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16391 PyObject *obj;
16392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16393 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16394 Py_INCREF(obj);
16395 return Py_BuildValue((char *)"");
16396 }
16397 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16400 wxMouseEvent *result;
16401 PyObject * obj0 = 0 ;
16402 char *kwnames[] = {
16403 (char *) "mouseType", NULL
16404 };
16405
16406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16407 if (obj0) {
16408 {
16409 arg1 = (wxEventType)(SWIG_As_int(obj0));
16410 if (SWIG_arg_fail(1)) SWIG_fail;
16411 }
16412 }
16413 {
16414 PyThreadState* __tstate = wxPyBeginAllowThreads();
16415 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16416
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 {
16421 resultobj = wxPyMake_wxObject(result, 1);
16422 }
16423 return resultobj;
16424 fail:
16425 return NULL;
16426 }
16427
16428
16429 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16430 PyObject *resultobj;
16431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16432 bool result;
16433 PyObject * obj0 = 0 ;
16434 char *kwnames[] = {
16435 (char *) "self", NULL
16436 };
16437
16438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16440 if (SWIG_arg_fail(1)) SWIG_fail;
16441 {
16442 PyThreadState* __tstate = wxPyBeginAllowThreads();
16443 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16444
16445 wxPyEndAllowThreads(__tstate);
16446 if (PyErr_Occurred()) SWIG_fail;
16447 }
16448 {
16449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16450 }
16451 return resultobj;
16452 fail:
16453 return NULL;
16454 }
16455
16456
16457 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16458 PyObject *resultobj;
16459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16460 int arg2 = (int) wxMOUSE_BTN_ANY ;
16461 bool result;
16462 PyObject * obj0 = 0 ;
16463 PyObject * obj1 = 0 ;
16464 char *kwnames[] = {
16465 (char *) "self",(char *) "but", NULL
16466 };
16467
16468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16470 if (SWIG_arg_fail(1)) SWIG_fail;
16471 if (obj1) {
16472 {
16473 arg2 = (int)(SWIG_As_int(obj1));
16474 if (SWIG_arg_fail(2)) SWIG_fail;
16475 }
16476 }
16477 {
16478 PyThreadState* __tstate = wxPyBeginAllowThreads();
16479 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16480
16481 wxPyEndAllowThreads(__tstate);
16482 if (PyErr_Occurred()) SWIG_fail;
16483 }
16484 {
16485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16486 }
16487 return resultobj;
16488 fail:
16489 return NULL;
16490 }
16491
16492
16493 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16494 PyObject *resultobj;
16495 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16496 int arg2 = (int) wxMOUSE_BTN_ANY ;
16497 bool result;
16498 PyObject * obj0 = 0 ;
16499 PyObject * obj1 = 0 ;
16500 char *kwnames[] = {
16501 (char *) "self",(char *) "but", NULL
16502 };
16503
16504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16506 if (SWIG_arg_fail(1)) SWIG_fail;
16507 if (obj1) {
16508 {
16509 arg2 = (int)(SWIG_As_int(obj1));
16510 if (SWIG_arg_fail(2)) SWIG_fail;
16511 }
16512 }
16513 {
16514 PyThreadState* __tstate = wxPyBeginAllowThreads();
16515 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16516
16517 wxPyEndAllowThreads(__tstate);
16518 if (PyErr_Occurred()) SWIG_fail;
16519 }
16520 {
16521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16522 }
16523 return resultobj;
16524 fail:
16525 return NULL;
16526 }
16527
16528
16529 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16530 PyObject *resultobj;
16531 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16532 int arg2 = (int) wxMOUSE_BTN_ANY ;
16533 bool result;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 char *kwnames[] = {
16537 (char *) "self",(char *) "but", NULL
16538 };
16539
16540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16542 if (SWIG_arg_fail(1)) SWIG_fail;
16543 if (obj1) {
16544 {
16545 arg2 = (int)(SWIG_As_int(obj1));
16546 if (SWIG_arg_fail(2)) SWIG_fail;
16547 }
16548 }
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16552
16553 wxPyEndAllowThreads(__tstate);
16554 if (PyErr_Occurred()) SWIG_fail;
16555 }
16556 {
16557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16558 }
16559 return resultobj;
16560 fail:
16561 return NULL;
16562 }
16563
16564
16565 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16566 PyObject *resultobj;
16567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16568 int arg2 ;
16569 bool result;
16570 PyObject * obj0 = 0 ;
16571 PyObject * obj1 = 0 ;
16572 char *kwnames[] = {
16573 (char *) "self",(char *) "button", NULL
16574 };
16575
16576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16578 if (SWIG_arg_fail(1)) SWIG_fail;
16579 {
16580 arg2 = (int)(SWIG_As_int(obj1));
16581 if (SWIG_arg_fail(2)) SWIG_fail;
16582 }
16583 {
16584 PyThreadState* __tstate = wxPyBeginAllowThreads();
16585 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16586
16587 wxPyEndAllowThreads(__tstate);
16588 if (PyErr_Occurred()) SWIG_fail;
16589 }
16590 {
16591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16592 }
16593 return resultobj;
16594 fail:
16595 return NULL;
16596 }
16597
16598
16599 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16600 PyObject *resultobj;
16601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16602 int arg2 ;
16603 bool result;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 char *kwnames[] = {
16607 (char *) "self",(char *) "but", NULL
16608 };
16609
16610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16612 if (SWIG_arg_fail(1)) SWIG_fail;
16613 {
16614 arg2 = (int)(SWIG_As_int(obj1));
16615 if (SWIG_arg_fail(2)) SWIG_fail;
16616 }
16617 {
16618 PyThreadState* __tstate = wxPyBeginAllowThreads();
16619 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16620
16621 wxPyEndAllowThreads(__tstate);
16622 if (PyErr_Occurred()) SWIG_fail;
16623 }
16624 {
16625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16626 }
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16634 PyObject *resultobj;
16635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16636 int result;
16637 PyObject * obj0 = 0 ;
16638 char *kwnames[] = {
16639 (char *) "self", NULL
16640 };
16641
16642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(1)) SWIG_fail;
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16648
16649 wxPyEndAllowThreads(__tstate);
16650 if (PyErr_Occurred()) SWIG_fail;
16651 }
16652 {
16653 resultobj = SWIG_From_int((int)(result));
16654 }
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj;
16663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16664 bool result;
16665 PyObject * obj0 = 0 ;
16666 char *kwnames[] = {
16667 (char *) "self", NULL
16668 };
16669
16670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16672 if (SWIG_arg_fail(1)) SWIG_fail;
16673 {
16674 PyThreadState* __tstate = wxPyBeginAllowThreads();
16675 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16676
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 {
16681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16682 }
16683 return resultobj;
16684 fail:
16685 return NULL;
16686 }
16687
16688
16689 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16690 PyObject *resultobj;
16691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16692 bool result;
16693 PyObject * obj0 = 0 ;
16694 char *kwnames[] = {
16695 (char *) "self", NULL
16696 };
16697
16698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16700 if (SWIG_arg_fail(1)) SWIG_fail;
16701 {
16702 PyThreadState* __tstate = wxPyBeginAllowThreads();
16703 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16704
16705 wxPyEndAllowThreads(__tstate);
16706 if (PyErr_Occurred()) SWIG_fail;
16707 }
16708 {
16709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16710 }
16711 return resultobj;
16712 fail:
16713 return NULL;
16714 }
16715
16716
16717 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16718 PyObject *resultobj;
16719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16720 bool result;
16721 PyObject * obj0 = 0 ;
16722 char *kwnames[] = {
16723 (char *) "self", NULL
16724 };
16725
16726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16728 if (SWIG_arg_fail(1)) SWIG_fail;
16729 {
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16732
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 {
16737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16738 }
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16746 PyObject *resultobj;
16747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16748 bool result;
16749 PyObject * obj0 = 0 ;
16750 char *kwnames[] = {
16751 (char *) "self", NULL
16752 };
16753
16754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16756 if (SWIG_arg_fail(1)) SWIG_fail;
16757 {
16758 PyThreadState* __tstate = wxPyBeginAllowThreads();
16759 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16760
16761 wxPyEndAllowThreads(__tstate);
16762 if (PyErr_Occurred()) SWIG_fail;
16763 }
16764 {
16765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16766 }
16767 return resultobj;
16768 fail:
16769 return NULL;
16770 }
16771
16772
16773 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16774 PyObject *resultobj;
16775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16776 bool result;
16777 PyObject * obj0 = 0 ;
16778 char *kwnames[] = {
16779 (char *) "self", NULL
16780 };
16781
16782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16784 if (SWIG_arg_fail(1)) SWIG_fail;
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16788
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 {
16793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16794 }
16795 return resultobj;
16796 fail:
16797 return NULL;
16798 }
16799
16800
16801 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16802 PyObject *resultobj;
16803 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16804 bool result;
16805 PyObject * obj0 = 0 ;
16806 char *kwnames[] = {
16807 (char *) "self", NULL
16808 };
16809
16810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16812 if (SWIG_arg_fail(1)) SWIG_fail;
16813 {
16814 PyThreadState* __tstate = wxPyBeginAllowThreads();
16815 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16816
16817 wxPyEndAllowThreads(__tstate);
16818 if (PyErr_Occurred()) SWIG_fail;
16819 }
16820 {
16821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16822 }
16823 return resultobj;
16824 fail:
16825 return NULL;
16826 }
16827
16828
16829 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16830 PyObject *resultobj;
16831 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16832 bool result;
16833 PyObject * obj0 = 0 ;
16834 char *kwnames[] = {
16835 (char *) "self", NULL
16836 };
16837
16838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16840 if (SWIG_arg_fail(1)) SWIG_fail;
16841 {
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16844
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 {
16849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16850 }
16851 return resultobj;
16852 fail:
16853 return NULL;
16854 }
16855
16856
16857 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16858 PyObject *resultobj;
16859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16860 bool result;
16861 PyObject * obj0 = 0 ;
16862 char *kwnames[] = {
16863 (char *) "self", NULL
16864 };
16865
16866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16868 if (SWIG_arg_fail(1)) SWIG_fail;
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16872
16873 wxPyEndAllowThreads(__tstate);
16874 if (PyErr_Occurred()) SWIG_fail;
16875 }
16876 {
16877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16878 }
16879 return resultobj;
16880 fail:
16881 return NULL;
16882 }
16883
16884
16885 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16886 PyObject *resultobj;
16887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16888 bool result;
16889 PyObject * obj0 = 0 ;
16890 char *kwnames[] = {
16891 (char *) "self", NULL
16892 };
16893
16894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16896 if (SWIG_arg_fail(1)) SWIG_fail;
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16900
16901 wxPyEndAllowThreads(__tstate);
16902 if (PyErr_Occurred()) SWIG_fail;
16903 }
16904 {
16905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16906 }
16907 return resultobj;
16908 fail:
16909 return NULL;
16910 }
16911
16912
16913 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16914 PyObject *resultobj;
16915 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16916 bool result;
16917 PyObject * obj0 = 0 ;
16918 char *kwnames[] = {
16919 (char *) "self", NULL
16920 };
16921
16922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16924 if (SWIG_arg_fail(1)) SWIG_fail;
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16928
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 {
16933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16934 }
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16942 PyObject *resultobj;
16943 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16944 bool result;
16945 PyObject * obj0 = 0 ;
16946 char *kwnames[] = {
16947 (char *) "self", NULL
16948 };
16949
16950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16952 if (SWIG_arg_fail(1)) SWIG_fail;
16953 {
16954 PyThreadState* __tstate = wxPyBeginAllowThreads();
16955 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16956
16957 wxPyEndAllowThreads(__tstate);
16958 if (PyErr_Occurred()) SWIG_fail;
16959 }
16960 {
16961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16962 }
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16970 PyObject *resultobj;
16971 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16972 bool result;
16973 PyObject * obj0 = 0 ;
16974 char *kwnames[] = {
16975 (char *) "self", NULL
16976 };
16977
16978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16980 if (SWIG_arg_fail(1)) SWIG_fail;
16981 {
16982 PyThreadState* __tstate = wxPyBeginAllowThreads();
16983 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16984
16985 wxPyEndAllowThreads(__tstate);
16986 if (PyErr_Occurred()) SWIG_fail;
16987 }
16988 {
16989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16990 }
16991 return resultobj;
16992 fail:
16993 return NULL;
16994 }
16995
16996
16997 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16998 PyObject *resultobj;
16999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17000 bool result;
17001 PyObject * obj0 = 0 ;
17002 char *kwnames[] = {
17003 (char *) "self", NULL
17004 };
17005
17006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17008 if (SWIG_arg_fail(1)) SWIG_fail;
17009 {
17010 PyThreadState* __tstate = wxPyBeginAllowThreads();
17011 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17012
17013 wxPyEndAllowThreads(__tstate);
17014 if (PyErr_Occurred()) SWIG_fail;
17015 }
17016 {
17017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17018 }
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17026 PyObject *resultobj;
17027 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17028 bool result;
17029 PyObject * obj0 = 0 ;
17030 char *kwnames[] = {
17031 (char *) "self", NULL
17032 };
17033
17034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17036 if (SWIG_arg_fail(1)) SWIG_fail;
17037 {
17038 PyThreadState* __tstate = wxPyBeginAllowThreads();
17039 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17040
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 {
17045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17046 }
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17054 PyObject *resultobj;
17055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17056 bool result;
17057 PyObject * obj0 = 0 ;
17058 char *kwnames[] = {
17059 (char *) "self", NULL
17060 };
17061
17062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17064 if (SWIG_arg_fail(1)) SWIG_fail;
17065 {
17066 PyThreadState* __tstate = wxPyBeginAllowThreads();
17067 result = (bool)(arg1)->LeftIsDown();
17068
17069 wxPyEndAllowThreads(__tstate);
17070 if (PyErr_Occurred()) SWIG_fail;
17071 }
17072 {
17073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17084 bool result;
17085 PyObject * obj0 = 0 ;
17086 char *kwnames[] = {
17087 (char *) "self", NULL
17088 };
17089
17090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17092 if (SWIG_arg_fail(1)) SWIG_fail;
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (bool)(arg1)->MiddleIsDown();
17096
17097 wxPyEndAllowThreads(__tstate);
17098 if (PyErr_Occurred()) SWIG_fail;
17099 }
17100 {
17101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17102 }
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17110 PyObject *resultobj;
17111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17112 bool result;
17113 PyObject * obj0 = 0 ;
17114 char *kwnames[] = {
17115 (char *) "self", NULL
17116 };
17117
17118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17120 if (SWIG_arg_fail(1)) SWIG_fail;
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (bool)(arg1)->RightIsDown();
17124
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 {
17129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17130 }
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17138 PyObject *resultobj;
17139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17140 bool result;
17141 PyObject * obj0 = 0 ;
17142 char *kwnames[] = {
17143 (char *) "self", NULL
17144 };
17145
17146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17148 if (SWIG_arg_fail(1)) SWIG_fail;
17149 {
17150 PyThreadState* __tstate = wxPyBeginAllowThreads();
17151 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17152
17153 wxPyEndAllowThreads(__tstate);
17154 if (PyErr_Occurred()) SWIG_fail;
17155 }
17156 {
17157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17158 }
17159 return resultobj;
17160 fail:
17161 return NULL;
17162 }
17163
17164
17165 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17166 PyObject *resultobj;
17167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17168 bool result;
17169 PyObject * obj0 = 0 ;
17170 char *kwnames[] = {
17171 (char *) "self", NULL
17172 };
17173
17174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17176 if (SWIG_arg_fail(1)) SWIG_fail;
17177 {
17178 PyThreadState* __tstate = wxPyBeginAllowThreads();
17179 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17180
17181 wxPyEndAllowThreads(__tstate);
17182 if (PyErr_Occurred()) SWIG_fail;
17183 }
17184 {
17185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17186 }
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj;
17195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17196 bool result;
17197 PyObject * obj0 = 0 ;
17198 char *kwnames[] = {
17199 (char *) "self", NULL
17200 };
17201
17202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17204 if (SWIG_arg_fail(1)) SWIG_fail;
17205 {
17206 PyThreadState* __tstate = wxPyBeginAllowThreads();
17207 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17208
17209 wxPyEndAllowThreads(__tstate);
17210 if (PyErr_Occurred()) SWIG_fail;
17211 }
17212 {
17213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17214 }
17215 return resultobj;
17216 fail:
17217 return NULL;
17218 }
17219
17220
17221 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17222 PyObject *resultobj;
17223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17224 bool result;
17225 PyObject * obj0 = 0 ;
17226 char *kwnames[] = {
17227 (char *) "self", NULL
17228 };
17229
17230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17232 if (SWIG_arg_fail(1)) SWIG_fail;
17233 {
17234 PyThreadState* __tstate = wxPyBeginAllowThreads();
17235 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17236
17237 wxPyEndAllowThreads(__tstate);
17238 if (PyErr_Occurred()) SWIG_fail;
17239 }
17240 {
17241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17242 }
17243 return resultobj;
17244 fail:
17245 return NULL;
17246 }
17247
17248
17249 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17250 PyObject *resultobj;
17251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17252 wxPoint result;
17253 PyObject * obj0 = 0 ;
17254 char *kwnames[] = {
17255 (char *) "self", NULL
17256 };
17257
17258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17260 if (SWIG_arg_fail(1)) SWIG_fail;
17261 {
17262 PyThreadState* __tstate = wxPyBeginAllowThreads();
17263 result = (arg1)->GetPosition();
17264
17265 wxPyEndAllowThreads(__tstate);
17266 if (PyErr_Occurred()) SWIG_fail;
17267 }
17268 {
17269 wxPoint * resultptr;
17270 resultptr = new wxPoint((wxPoint &)(result));
17271 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17272 }
17273 return resultobj;
17274 fail:
17275 return NULL;
17276 }
17277
17278
17279 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17280 PyObject *resultobj;
17281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17282 long *arg2 = (long *) 0 ;
17283 long *arg3 = (long *) 0 ;
17284 long temp2 ;
17285 int res2 = 0 ;
17286 long temp3 ;
17287 int res3 = 0 ;
17288 PyObject * obj0 = 0 ;
17289 char *kwnames[] = {
17290 (char *) "self", NULL
17291 };
17292
17293 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17294 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17297 if (SWIG_arg_fail(1)) SWIG_fail;
17298 {
17299 PyThreadState* __tstate = wxPyBeginAllowThreads();
17300 (arg1)->GetPosition(arg2,arg3);
17301
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 Py_INCREF(Py_None); resultobj = Py_None;
17306 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17307 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17308 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17309 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17310 return resultobj;
17311 fail:
17312 return NULL;
17313 }
17314
17315
17316 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17317 PyObject *resultobj;
17318 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17319 wxDC *arg2 = 0 ;
17320 wxPoint result;
17321 PyObject * obj0 = 0 ;
17322 PyObject * obj1 = 0 ;
17323 char *kwnames[] = {
17324 (char *) "self",(char *) "dc", NULL
17325 };
17326
17327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17329 if (SWIG_arg_fail(1)) SWIG_fail;
17330 {
17331 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17332 if (SWIG_arg_fail(2)) SWIG_fail;
17333 if (arg2 == NULL) {
17334 SWIG_null_ref("wxDC");
17335 }
17336 if (SWIG_arg_fail(2)) SWIG_fail;
17337 }
17338 {
17339 PyThreadState* __tstate = wxPyBeginAllowThreads();
17340 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17341
17342 wxPyEndAllowThreads(__tstate);
17343 if (PyErr_Occurred()) SWIG_fail;
17344 }
17345 {
17346 wxPoint * resultptr;
17347 resultptr = new wxPoint((wxPoint &)(result));
17348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17349 }
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj;
17358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17359 int result;
17360 PyObject * obj0 = 0 ;
17361 char *kwnames[] = {
17362 (char *) "self", NULL
17363 };
17364
17365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17367 if (SWIG_arg_fail(1)) SWIG_fail;
17368 {
17369 PyThreadState* __tstate = wxPyBeginAllowThreads();
17370 result = (int)((wxMouseEvent const *)arg1)->GetX();
17371
17372 wxPyEndAllowThreads(__tstate);
17373 if (PyErr_Occurred()) SWIG_fail;
17374 }
17375 {
17376 resultobj = SWIG_From_int((int)(result));
17377 }
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17385 PyObject *resultobj;
17386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17387 int result;
17388 PyObject * obj0 = 0 ;
17389 char *kwnames[] = {
17390 (char *) "self", NULL
17391 };
17392
17393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17395 if (SWIG_arg_fail(1)) SWIG_fail;
17396 {
17397 PyThreadState* __tstate = wxPyBeginAllowThreads();
17398 result = (int)((wxMouseEvent const *)arg1)->GetY();
17399
17400 wxPyEndAllowThreads(__tstate);
17401 if (PyErr_Occurred()) SWIG_fail;
17402 }
17403 {
17404 resultobj = SWIG_From_int((int)(result));
17405 }
17406 return resultobj;
17407 fail:
17408 return NULL;
17409 }
17410
17411
17412 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17413 PyObject *resultobj;
17414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17415 int result;
17416 PyObject * obj0 = 0 ;
17417 char *kwnames[] = {
17418 (char *) "self", NULL
17419 };
17420
17421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17423 if (SWIG_arg_fail(1)) SWIG_fail;
17424 {
17425 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17427
17428 wxPyEndAllowThreads(__tstate);
17429 if (PyErr_Occurred()) SWIG_fail;
17430 }
17431 {
17432 resultobj = SWIG_From_int((int)(result));
17433 }
17434 return resultobj;
17435 fail:
17436 return NULL;
17437 }
17438
17439
17440 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17441 PyObject *resultobj;
17442 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17443 int result;
17444 PyObject * obj0 = 0 ;
17445 char *kwnames[] = {
17446 (char *) "self", NULL
17447 };
17448
17449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17451 if (SWIG_arg_fail(1)) SWIG_fail;
17452 {
17453 PyThreadState* __tstate = wxPyBeginAllowThreads();
17454 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17455
17456 wxPyEndAllowThreads(__tstate);
17457 if (PyErr_Occurred()) SWIG_fail;
17458 }
17459 {
17460 resultobj = SWIG_From_int((int)(result));
17461 }
17462 return resultobj;
17463 fail:
17464 return NULL;
17465 }
17466
17467
17468 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj;
17470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17471 int result;
17472 PyObject * obj0 = 0 ;
17473 char *kwnames[] = {
17474 (char *) "self", NULL
17475 };
17476
17477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17479 if (SWIG_arg_fail(1)) SWIG_fail;
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17483
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 {
17488 resultobj = SWIG_From_int((int)(result));
17489 }
17490 return resultobj;
17491 fail:
17492 return NULL;
17493 }
17494
17495
17496 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17497 PyObject *resultobj;
17498 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17499 bool result;
17500 PyObject * obj0 = 0 ;
17501 char *kwnames[] = {
17502 (char *) "self", NULL
17503 };
17504
17505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17507 if (SWIG_arg_fail(1)) SWIG_fail;
17508 {
17509 PyThreadState* __tstate = wxPyBeginAllowThreads();
17510 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17511
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 {
17516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17517 }
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17525 PyObject *resultobj;
17526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17527 int arg2 ;
17528 PyObject * obj0 = 0 ;
17529 PyObject * obj1 = 0 ;
17530 char *kwnames[] = {
17531 (char *) "self",(char *) "m_x", NULL
17532 };
17533
17534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17536 if (SWIG_arg_fail(1)) SWIG_fail;
17537 {
17538 arg2 = (int)(SWIG_As_int(obj1));
17539 if (SWIG_arg_fail(2)) SWIG_fail;
17540 }
17541 if (arg1) (arg1)->m_x = arg2;
17542
17543 Py_INCREF(Py_None); resultobj = Py_None;
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj;
17552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17553 int result;
17554 PyObject * obj0 = 0 ;
17555 char *kwnames[] = {
17556 (char *) "self", NULL
17557 };
17558
17559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17561 if (SWIG_arg_fail(1)) SWIG_fail;
17562 result = (int) ((arg1)->m_x);
17563
17564 {
17565 resultobj = SWIG_From_int((int)(result));
17566 }
17567 return resultobj;
17568 fail:
17569 return NULL;
17570 }
17571
17572
17573 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17574 PyObject *resultobj;
17575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17576 int arg2 ;
17577 PyObject * obj0 = 0 ;
17578 PyObject * obj1 = 0 ;
17579 char *kwnames[] = {
17580 (char *) "self",(char *) "m_y", NULL
17581 };
17582
17583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17585 if (SWIG_arg_fail(1)) SWIG_fail;
17586 {
17587 arg2 = (int)(SWIG_As_int(obj1));
17588 if (SWIG_arg_fail(2)) SWIG_fail;
17589 }
17590 if (arg1) (arg1)->m_y = arg2;
17591
17592 Py_INCREF(Py_None); resultobj = Py_None;
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj;
17601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17602 int result;
17603 PyObject * obj0 = 0 ;
17604 char *kwnames[] = {
17605 (char *) "self", NULL
17606 };
17607
17608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17610 if (SWIG_arg_fail(1)) SWIG_fail;
17611 result = (int) ((arg1)->m_y);
17612
17613 {
17614 resultobj = SWIG_From_int((int)(result));
17615 }
17616 return resultobj;
17617 fail:
17618 return NULL;
17619 }
17620
17621
17622 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17623 PyObject *resultobj;
17624 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17625 bool arg2 ;
17626 PyObject * obj0 = 0 ;
17627 PyObject * obj1 = 0 ;
17628 char *kwnames[] = {
17629 (char *) "self",(char *) "m_leftDown", NULL
17630 };
17631
17632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17634 if (SWIG_arg_fail(1)) SWIG_fail;
17635 {
17636 arg2 = (bool)(SWIG_As_bool(obj1));
17637 if (SWIG_arg_fail(2)) SWIG_fail;
17638 }
17639 if (arg1) (arg1)->m_leftDown = arg2;
17640
17641 Py_INCREF(Py_None); resultobj = Py_None;
17642 return resultobj;
17643 fail:
17644 return NULL;
17645 }
17646
17647
17648 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17649 PyObject *resultobj;
17650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17651 bool result;
17652 PyObject * obj0 = 0 ;
17653 char *kwnames[] = {
17654 (char *) "self", NULL
17655 };
17656
17657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17659 if (SWIG_arg_fail(1)) SWIG_fail;
17660 result = (bool) ((arg1)->m_leftDown);
17661
17662 {
17663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17664 }
17665 return resultobj;
17666 fail:
17667 return NULL;
17668 }
17669
17670
17671 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17672 PyObject *resultobj;
17673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17674 bool arg2 ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 char *kwnames[] = {
17678 (char *) "self",(char *) "m_middleDown", NULL
17679 };
17680
17681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17683 if (SWIG_arg_fail(1)) SWIG_fail;
17684 {
17685 arg2 = (bool)(SWIG_As_bool(obj1));
17686 if (SWIG_arg_fail(2)) SWIG_fail;
17687 }
17688 if (arg1) (arg1)->m_middleDown = arg2;
17689
17690 Py_INCREF(Py_None); resultobj = Py_None;
17691 return resultobj;
17692 fail:
17693 return NULL;
17694 }
17695
17696
17697 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17698 PyObject *resultobj;
17699 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17700 bool result;
17701 PyObject * obj0 = 0 ;
17702 char *kwnames[] = {
17703 (char *) "self", NULL
17704 };
17705
17706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17708 if (SWIG_arg_fail(1)) SWIG_fail;
17709 result = (bool) ((arg1)->m_middleDown);
17710
17711 {
17712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj;
17722 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17723 bool arg2 ;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 char *kwnames[] = {
17727 (char *) "self",(char *) "m_rightDown", NULL
17728 };
17729
17730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17732 if (SWIG_arg_fail(1)) SWIG_fail;
17733 {
17734 arg2 = (bool)(SWIG_As_bool(obj1));
17735 if (SWIG_arg_fail(2)) SWIG_fail;
17736 }
17737 if (arg1) (arg1)->m_rightDown = arg2;
17738
17739 Py_INCREF(Py_None); resultobj = Py_None;
17740 return resultobj;
17741 fail:
17742 return NULL;
17743 }
17744
17745
17746 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17747 PyObject *resultobj;
17748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17749 bool result;
17750 PyObject * obj0 = 0 ;
17751 char *kwnames[] = {
17752 (char *) "self", NULL
17753 };
17754
17755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17757 if (SWIG_arg_fail(1)) SWIG_fail;
17758 result = (bool) ((arg1)->m_rightDown);
17759
17760 {
17761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17762 }
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17772 bool arg2 ;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 char *kwnames[] = {
17776 (char *) "self",(char *) "m_controlDown", NULL
17777 };
17778
17779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 {
17783 arg2 = (bool)(SWIG_As_bool(obj1));
17784 if (SWIG_arg_fail(2)) SWIG_fail;
17785 }
17786 if (arg1) (arg1)->m_controlDown = arg2;
17787
17788 Py_INCREF(Py_None); resultobj = Py_None;
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17796 PyObject *resultobj;
17797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17798 bool result;
17799 PyObject * obj0 = 0 ;
17800 char *kwnames[] = {
17801 (char *) "self", NULL
17802 };
17803
17804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17806 if (SWIG_arg_fail(1)) SWIG_fail;
17807 result = (bool) ((arg1)->m_controlDown);
17808
17809 {
17810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17811 }
17812 return resultobj;
17813 fail:
17814 return NULL;
17815 }
17816
17817
17818 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17819 PyObject *resultobj;
17820 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17821 bool arg2 ;
17822 PyObject * obj0 = 0 ;
17823 PyObject * obj1 = 0 ;
17824 char *kwnames[] = {
17825 (char *) "self",(char *) "m_shiftDown", NULL
17826 };
17827
17828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17830 if (SWIG_arg_fail(1)) SWIG_fail;
17831 {
17832 arg2 = (bool)(SWIG_As_bool(obj1));
17833 if (SWIG_arg_fail(2)) SWIG_fail;
17834 }
17835 if (arg1) (arg1)->m_shiftDown = arg2;
17836
17837 Py_INCREF(Py_None); resultobj = Py_None;
17838 return resultobj;
17839 fail:
17840 return NULL;
17841 }
17842
17843
17844 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17845 PyObject *resultobj;
17846 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17847 bool result;
17848 PyObject * obj0 = 0 ;
17849 char *kwnames[] = {
17850 (char *) "self", NULL
17851 };
17852
17853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17855 if (SWIG_arg_fail(1)) SWIG_fail;
17856 result = (bool) ((arg1)->m_shiftDown);
17857
17858 {
17859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17860 }
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17868 PyObject *resultobj;
17869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17870 bool arg2 ;
17871 PyObject * obj0 = 0 ;
17872 PyObject * obj1 = 0 ;
17873 char *kwnames[] = {
17874 (char *) "self",(char *) "m_altDown", NULL
17875 };
17876
17877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17879 if (SWIG_arg_fail(1)) SWIG_fail;
17880 {
17881 arg2 = (bool)(SWIG_As_bool(obj1));
17882 if (SWIG_arg_fail(2)) SWIG_fail;
17883 }
17884 if (arg1) (arg1)->m_altDown = arg2;
17885
17886 Py_INCREF(Py_None); resultobj = Py_None;
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj;
17895 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17896 bool result;
17897 PyObject * obj0 = 0 ;
17898 char *kwnames[] = {
17899 (char *) "self", NULL
17900 };
17901
17902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17904 if (SWIG_arg_fail(1)) SWIG_fail;
17905 result = (bool) ((arg1)->m_altDown);
17906
17907 {
17908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17909 }
17910 return resultobj;
17911 fail:
17912 return NULL;
17913 }
17914
17915
17916 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17917 PyObject *resultobj;
17918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17919 bool arg2 ;
17920 PyObject * obj0 = 0 ;
17921 PyObject * obj1 = 0 ;
17922 char *kwnames[] = {
17923 (char *) "self",(char *) "m_metaDown", NULL
17924 };
17925
17926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17928 if (SWIG_arg_fail(1)) SWIG_fail;
17929 {
17930 arg2 = (bool)(SWIG_As_bool(obj1));
17931 if (SWIG_arg_fail(2)) SWIG_fail;
17932 }
17933 if (arg1) (arg1)->m_metaDown = arg2;
17934
17935 Py_INCREF(Py_None); resultobj = Py_None;
17936 return resultobj;
17937 fail:
17938 return NULL;
17939 }
17940
17941
17942 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17943 PyObject *resultobj;
17944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17945 bool result;
17946 PyObject * obj0 = 0 ;
17947 char *kwnames[] = {
17948 (char *) "self", NULL
17949 };
17950
17951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17953 if (SWIG_arg_fail(1)) SWIG_fail;
17954 result = (bool) ((arg1)->m_metaDown);
17955
17956 {
17957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj;
17967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17968 int arg2 ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 char *kwnames[] = {
17972 (char *) "self",(char *) "m_wheelRotation", NULL
17973 };
17974
17975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17977 if (SWIG_arg_fail(1)) SWIG_fail;
17978 {
17979 arg2 = (int)(SWIG_As_int(obj1));
17980 if (SWIG_arg_fail(2)) SWIG_fail;
17981 }
17982 if (arg1) (arg1)->m_wheelRotation = arg2;
17983
17984 Py_INCREF(Py_None); resultobj = Py_None;
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17992 PyObject *resultobj;
17993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17994 int result;
17995 PyObject * obj0 = 0 ;
17996 char *kwnames[] = {
17997 (char *) "self", NULL
17998 };
17999
18000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18002 if (SWIG_arg_fail(1)) SWIG_fail;
18003 result = (int) ((arg1)->m_wheelRotation);
18004
18005 {
18006 resultobj = SWIG_From_int((int)(result));
18007 }
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18015 PyObject *resultobj;
18016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18017 int arg2 ;
18018 PyObject * obj0 = 0 ;
18019 PyObject * obj1 = 0 ;
18020 char *kwnames[] = {
18021 (char *) "self",(char *) "m_wheelDelta", NULL
18022 };
18023
18024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18026 if (SWIG_arg_fail(1)) SWIG_fail;
18027 {
18028 arg2 = (int)(SWIG_As_int(obj1));
18029 if (SWIG_arg_fail(2)) SWIG_fail;
18030 }
18031 if (arg1) (arg1)->m_wheelDelta = arg2;
18032
18033 Py_INCREF(Py_None); resultobj = Py_None;
18034 return resultobj;
18035 fail:
18036 return NULL;
18037 }
18038
18039
18040 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18041 PyObject *resultobj;
18042 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18043 int result;
18044 PyObject * obj0 = 0 ;
18045 char *kwnames[] = {
18046 (char *) "self", NULL
18047 };
18048
18049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18051 if (SWIG_arg_fail(1)) SWIG_fail;
18052 result = (int) ((arg1)->m_wheelDelta);
18053
18054 {
18055 resultobj = SWIG_From_int((int)(result));
18056 }
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18064 PyObject *resultobj;
18065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18066 int arg2 ;
18067 PyObject * obj0 = 0 ;
18068 PyObject * obj1 = 0 ;
18069 char *kwnames[] = {
18070 (char *) "self",(char *) "m_linesPerAction", NULL
18071 };
18072
18073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18075 if (SWIG_arg_fail(1)) SWIG_fail;
18076 {
18077 arg2 = (int)(SWIG_As_int(obj1));
18078 if (SWIG_arg_fail(2)) SWIG_fail;
18079 }
18080 if (arg1) (arg1)->m_linesPerAction = arg2;
18081
18082 Py_INCREF(Py_None); resultobj = Py_None;
18083 return resultobj;
18084 fail:
18085 return NULL;
18086 }
18087
18088
18089 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18090 PyObject *resultobj;
18091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18092 int result;
18093 PyObject * obj0 = 0 ;
18094 char *kwnames[] = {
18095 (char *) "self", NULL
18096 };
18097
18098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18100 if (SWIG_arg_fail(1)) SWIG_fail;
18101 result = (int) ((arg1)->m_linesPerAction);
18102
18103 {
18104 resultobj = SWIG_From_int((int)(result));
18105 }
18106 return resultobj;
18107 fail:
18108 return NULL;
18109 }
18110
18111
18112 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18113 PyObject *obj;
18114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18115 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18116 Py_INCREF(obj);
18117 return Py_BuildValue((char *)"");
18118 }
18119 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18120 PyObject *resultobj;
18121 int arg1 = (int) 0 ;
18122 int arg2 = (int) 0 ;
18123 wxSetCursorEvent *result;
18124 PyObject * obj0 = 0 ;
18125 PyObject * obj1 = 0 ;
18126 char *kwnames[] = {
18127 (char *) "x",(char *) "y", NULL
18128 };
18129
18130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18131 if (obj0) {
18132 {
18133 arg1 = (int)(SWIG_As_int(obj0));
18134 if (SWIG_arg_fail(1)) SWIG_fail;
18135 }
18136 }
18137 if (obj1) {
18138 {
18139 arg2 = (int)(SWIG_As_int(obj1));
18140 if (SWIG_arg_fail(2)) SWIG_fail;
18141 }
18142 }
18143 {
18144 PyThreadState* __tstate = wxPyBeginAllowThreads();
18145 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18146
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18151 return resultobj;
18152 fail:
18153 return NULL;
18154 }
18155
18156
18157 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18158 PyObject *resultobj;
18159 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18160 int result;
18161 PyObject * obj0 = 0 ;
18162 char *kwnames[] = {
18163 (char *) "self", NULL
18164 };
18165
18166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18168 if (SWIG_arg_fail(1)) SWIG_fail;
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18172
18173 wxPyEndAllowThreads(__tstate);
18174 if (PyErr_Occurred()) SWIG_fail;
18175 }
18176 {
18177 resultobj = SWIG_From_int((int)(result));
18178 }
18179 return resultobj;
18180 fail:
18181 return NULL;
18182 }
18183
18184
18185 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18186 PyObject *resultobj;
18187 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18188 int result;
18189 PyObject * obj0 = 0 ;
18190 char *kwnames[] = {
18191 (char *) "self", NULL
18192 };
18193
18194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18196 if (SWIG_arg_fail(1)) SWIG_fail;
18197 {
18198 PyThreadState* __tstate = wxPyBeginAllowThreads();
18199 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18200
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 {
18205 resultobj = SWIG_From_int((int)(result));
18206 }
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18214 PyObject *resultobj;
18215 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18216 wxCursor *arg2 = 0 ;
18217 PyObject * obj0 = 0 ;
18218 PyObject * obj1 = 0 ;
18219 char *kwnames[] = {
18220 (char *) "self",(char *) "cursor", NULL
18221 };
18222
18223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18225 if (SWIG_arg_fail(1)) SWIG_fail;
18226 {
18227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18228 if (SWIG_arg_fail(2)) SWIG_fail;
18229 if (arg2 == NULL) {
18230 SWIG_null_ref("wxCursor");
18231 }
18232 if (SWIG_arg_fail(2)) SWIG_fail;
18233 }
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 (arg1)->SetCursor((wxCursor const &)*arg2);
18237
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 Py_INCREF(Py_None); resultobj = Py_None;
18242 return resultobj;
18243 fail:
18244 return NULL;
18245 }
18246
18247
18248 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18249 PyObject *resultobj;
18250 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18251 wxCursor *result;
18252 PyObject * obj0 = 0 ;
18253 char *kwnames[] = {
18254 (char *) "self", NULL
18255 };
18256
18257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18259 if (SWIG_arg_fail(1)) SWIG_fail;
18260 {
18261 PyThreadState* __tstate = wxPyBeginAllowThreads();
18262 {
18263 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18264 result = (wxCursor *) &_result_ref;
18265 }
18266
18267 wxPyEndAllowThreads(__tstate);
18268 if (PyErr_Occurred()) SWIG_fail;
18269 }
18270 {
18271 wxCursor* resultptr = new wxCursor(*result);
18272 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18273 }
18274 return resultobj;
18275 fail:
18276 return NULL;
18277 }
18278
18279
18280 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj;
18282 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18283 bool result;
18284 PyObject * obj0 = 0 ;
18285 char *kwnames[] = {
18286 (char *) "self", NULL
18287 };
18288
18289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18291 if (SWIG_arg_fail(1)) SWIG_fail;
18292 {
18293 PyThreadState* __tstate = wxPyBeginAllowThreads();
18294 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18295
18296 wxPyEndAllowThreads(__tstate);
18297 if (PyErr_Occurred()) SWIG_fail;
18298 }
18299 {
18300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18301 }
18302 return resultobj;
18303 fail:
18304 return NULL;
18305 }
18306
18307
18308 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18309 PyObject *obj;
18310 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18311 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18312 Py_INCREF(obj);
18313 return Py_BuildValue((char *)"");
18314 }
18315 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18316 PyObject *resultobj;
18317 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18318 wxKeyEvent *result;
18319 PyObject * obj0 = 0 ;
18320 char *kwnames[] = {
18321 (char *) "eventType", NULL
18322 };
18323
18324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18325 if (obj0) {
18326 {
18327 arg1 = (wxEventType)(SWIG_As_int(obj0));
18328 if (SWIG_arg_fail(1)) SWIG_fail;
18329 }
18330 }
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18334
18335 wxPyEndAllowThreads(__tstate);
18336 if (PyErr_Occurred()) SWIG_fail;
18337 }
18338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18339 return resultobj;
18340 fail:
18341 return NULL;
18342 }
18343
18344
18345 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18346 PyObject *resultobj;
18347 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18348 bool result;
18349 PyObject * obj0 = 0 ;
18350 char *kwnames[] = {
18351 (char *) "self", NULL
18352 };
18353
18354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18356 if (SWIG_arg_fail(1)) SWIG_fail;
18357 {
18358 PyThreadState* __tstate = wxPyBeginAllowThreads();
18359 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18360
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 {
18365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18366 }
18367 return resultobj;
18368 fail:
18369 return NULL;
18370 }
18371
18372
18373 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18374 PyObject *resultobj;
18375 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18376 bool result;
18377 PyObject * obj0 = 0 ;
18378 char *kwnames[] = {
18379 (char *) "self", NULL
18380 };
18381
18382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18384 if (SWIG_arg_fail(1)) SWIG_fail;
18385 {
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18388
18389 wxPyEndAllowThreads(__tstate);
18390 if (PyErr_Occurred()) SWIG_fail;
18391 }
18392 {
18393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18394 }
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18402 PyObject *resultobj;
18403 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18404 bool result;
18405 PyObject * obj0 = 0 ;
18406 char *kwnames[] = {
18407 (char *) "self", NULL
18408 };
18409
18410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18412 if (SWIG_arg_fail(1)) SWIG_fail;
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18416
18417 wxPyEndAllowThreads(__tstate);
18418 if (PyErr_Occurred()) SWIG_fail;
18419 }
18420 {
18421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18422 }
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj;
18431 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18432 bool result;
18433 PyObject * obj0 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 {
18442 PyThreadState* __tstate = wxPyBeginAllowThreads();
18443 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18444
18445 wxPyEndAllowThreads(__tstate);
18446 if (PyErr_Occurred()) SWIG_fail;
18447 }
18448 {
18449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18450 }
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj;
18459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18460 bool result;
18461 PyObject * obj0 = 0 ;
18462 char *kwnames[] = {
18463 (char *) "self", NULL
18464 };
18465
18466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18468 if (SWIG_arg_fail(1)) SWIG_fail;
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18472
18473 wxPyEndAllowThreads(__tstate);
18474 if (PyErr_Occurred()) SWIG_fail;
18475 }
18476 {
18477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18478 }
18479 return resultobj;
18480 fail:
18481 return NULL;
18482 }
18483
18484
18485 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18486 PyObject *resultobj;
18487 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18488 bool result;
18489 PyObject * obj0 = 0 ;
18490 char *kwnames[] = {
18491 (char *) "self", NULL
18492 };
18493
18494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18496 if (SWIG_arg_fail(1)) SWIG_fail;
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18500
18501 wxPyEndAllowThreads(__tstate);
18502 if (PyErr_Occurred()) SWIG_fail;
18503 }
18504 {
18505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18506 }
18507 return resultobj;
18508 fail:
18509 return NULL;
18510 }
18511
18512
18513 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18514 PyObject *resultobj;
18515 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18516 int result;
18517 PyObject * obj0 = 0 ;
18518 char *kwnames[] = {
18519 (char *) "self", NULL
18520 };
18521
18522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18524 if (SWIG_arg_fail(1)) SWIG_fail;
18525 {
18526 PyThreadState* __tstate = wxPyBeginAllowThreads();
18527 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18528
18529 wxPyEndAllowThreads(__tstate);
18530 if (PyErr_Occurred()) SWIG_fail;
18531 }
18532 {
18533 resultobj = SWIG_From_int((int)(result));
18534 }
18535 return resultobj;
18536 fail:
18537 return NULL;
18538 }
18539
18540
18541 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18542 PyObject *resultobj;
18543 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18544 int result;
18545 PyObject * obj0 = 0 ;
18546 char *kwnames[] = {
18547 (char *) "self", NULL
18548 };
18549
18550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18552 if (SWIG_arg_fail(1)) SWIG_fail;
18553 {
18554 PyThreadState* __tstate = wxPyBeginAllowThreads();
18555 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18556
18557 wxPyEndAllowThreads(__tstate);
18558 if (PyErr_Occurred()) SWIG_fail;
18559 }
18560 {
18561 resultobj = SWIG_From_int((int)(result));
18562 }
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18570 PyObject *resultobj;
18571 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18572 unsigned int result;
18573 PyObject * obj0 = 0 ;
18574 char *kwnames[] = {
18575 (char *) "self", NULL
18576 };
18577
18578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18580 if (SWIG_arg_fail(1)) SWIG_fail;
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18584
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 {
18589 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18590 }
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj;
18599 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18600 unsigned int result;
18601 PyObject * obj0 = 0 ;
18602 char *kwnames[] = {
18603 (char *) "self", NULL
18604 };
18605
18606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18608 if (SWIG_arg_fail(1)) SWIG_fail;
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18612
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 {
18617 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18618 }
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18626 PyObject *resultobj;
18627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18628 wxPoint result;
18629 PyObject * obj0 = 0 ;
18630 char *kwnames[] = {
18631 (char *) "self", NULL
18632 };
18633
18634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18636 if (SWIG_arg_fail(1)) SWIG_fail;
18637 {
18638 PyThreadState* __tstate = wxPyBeginAllowThreads();
18639 result = (arg1)->GetPosition();
18640
18641 wxPyEndAllowThreads(__tstate);
18642 if (PyErr_Occurred()) SWIG_fail;
18643 }
18644 {
18645 wxPoint * resultptr;
18646 resultptr = new wxPoint((wxPoint &)(result));
18647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18648 }
18649 return resultobj;
18650 fail:
18651 return NULL;
18652 }
18653
18654
18655 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18656 PyObject *resultobj;
18657 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18658 long *arg2 = (long *) 0 ;
18659 long *arg3 = (long *) 0 ;
18660 long temp2 ;
18661 int res2 = 0 ;
18662 long temp3 ;
18663 int res3 = 0 ;
18664 PyObject * obj0 = 0 ;
18665 char *kwnames[] = {
18666 (char *) "self", NULL
18667 };
18668
18669 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18670 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18673 if (SWIG_arg_fail(1)) SWIG_fail;
18674 {
18675 PyThreadState* __tstate = wxPyBeginAllowThreads();
18676 (arg1)->GetPosition(arg2,arg3);
18677
18678 wxPyEndAllowThreads(__tstate);
18679 if (PyErr_Occurred()) SWIG_fail;
18680 }
18681 Py_INCREF(Py_None); resultobj = Py_None;
18682 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18683 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18684 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18685 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj;
18694 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18695 int result;
18696 PyObject * obj0 = 0 ;
18697 char *kwnames[] = {
18698 (char *) "self", NULL
18699 };
18700
18701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18703 if (SWIG_arg_fail(1)) SWIG_fail;
18704 {
18705 PyThreadState* __tstate = wxPyBeginAllowThreads();
18706 result = (int)((wxKeyEvent const *)arg1)->GetX();
18707
18708 wxPyEndAllowThreads(__tstate);
18709 if (PyErr_Occurred()) SWIG_fail;
18710 }
18711 {
18712 resultobj = SWIG_From_int((int)(result));
18713 }
18714 return resultobj;
18715 fail:
18716 return NULL;
18717 }
18718
18719
18720 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18721 PyObject *resultobj;
18722 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18723 int result;
18724 PyObject * obj0 = 0 ;
18725 char *kwnames[] = {
18726 (char *) "self", NULL
18727 };
18728
18729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18731 if (SWIG_arg_fail(1)) SWIG_fail;
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 result = (int)((wxKeyEvent const *)arg1)->GetY();
18735
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 {
18740 resultobj = SWIG_From_int((int)(result));
18741 }
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj;
18750 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18751 int arg2 ;
18752 PyObject * obj0 = 0 ;
18753 PyObject * obj1 = 0 ;
18754 char *kwnames[] = {
18755 (char *) "self",(char *) "m_x", NULL
18756 };
18757
18758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18760 if (SWIG_arg_fail(1)) SWIG_fail;
18761 {
18762 arg2 = (int)(SWIG_As_int(obj1));
18763 if (SWIG_arg_fail(2)) SWIG_fail;
18764 }
18765 if (arg1) (arg1)->m_x = arg2;
18766
18767 Py_INCREF(Py_None); resultobj = Py_None;
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj;
18776 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18777 int result;
18778 PyObject * obj0 = 0 ;
18779 char *kwnames[] = {
18780 (char *) "self", NULL
18781 };
18782
18783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18785 if (SWIG_arg_fail(1)) SWIG_fail;
18786 result = (int) ((arg1)->m_x);
18787
18788 {
18789 resultobj = SWIG_From_int((int)(result));
18790 }
18791 return resultobj;
18792 fail:
18793 return NULL;
18794 }
18795
18796
18797 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18798 PyObject *resultobj;
18799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18800 int arg2 ;
18801 PyObject * obj0 = 0 ;
18802 PyObject * obj1 = 0 ;
18803 char *kwnames[] = {
18804 (char *) "self",(char *) "m_y", NULL
18805 };
18806
18807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18809 if (SWIG_arg_fail(1)) SWIG_fail;
18810 {
18811 arg2 = (int)(SWIG_As_int(obj1));
18812 if (SWIG_arg_fail(2)) SWIG_fail;
18813 }
18814 if (arg1) (arg1)->m_y = arg2;
18815
18816 Py_INCREF(Py_None); resultobj = Py_None;
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18824 PyObject *resultobj;
18825 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18826 int result;
18827 PyObject * obj0 = 0 ;
18828 char *kwnames[] = {
18829 (char *) "self", NULL
18830 };
18831
18832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18834 if (SWIG_arg_fail(1)) SWIG_fail;
18835 result = (int) ((arg1)->m_y);
18836
18837 {
18838 resultobj = SWIG_From_int((int)(result));
18839 }
18840 return resultobj;
18841 fail:
18842 return NULL;
18843 }
18844
18845
18846 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18847 PyObject *resultobj;
18848 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18849 long arg2 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 char *kwnames[] = {
18853 (char *) "self",(char *) "m_keyCode", NULL
18854 };
18855
18856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18858 if (SWIG_arg_fail(1)) SWIG_fail;
18859 {
18860 arg2 = (long)(SWIG_As_long(obj1));
18861 if (SWIG_arg_fail(2)) SWIG_fail;
18862 }
18863 if (arg1) (arg1)->m_keyCode = arg2;
18864
18865 Py_INCREF(Py_None); resultobj = Py_None;
18866 return resultobj;
18867 fail:
18868 return NULL;
18869 }
18870
18871
18872 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj;
18874 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18875 long result;
18876 PyObject * obj0 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "self", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18883 if (SWIG_arg_fail(1)) SWIG_fail;
18884 result = (long) ((arg1)->m_keyCode);
18885
18886 {
18887 resultobj = SWIG_From_long((long)(result));
18888 }
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj;
18897 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18898 bool arg2 ;
18899 PyObject * obj0 = 0 ;
18900 PyObject * obj1 = 0 ;
18901 char *kwnames[] = {
18902 (char *) "self",(char *) "m_controlDown", NULL
18903 };
18904
18905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 {
18909 arg2 = (bool)(SWIG_As_bool(obj1));
18910 if (SWIG_arg_fail(2)) SWIG_fail;
18911 }
18912 if (arg1) (arg1)->m_controlDown = arg2;
18913
18914 Py_INCREF(Py_None); resultobj = Py_None;
18915 return resultobj;
18916 fail:
18917 return NULL;
18918 }
18919
18920
18921 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18922 PyObject *resultobj;
18923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18924 bool result;
18925 PyObject * obj0 = 0 ;
18926 char *kwnames[] = {
18927 (char *) "self", NULL
18928 };
18929
18930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18932 if (SWIG_arg_fail(1)) SWIG_fail;
18933 result = (bool) ((arg1)->m_controlDown);
18934
18935 {
18936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18937 }
18938 return resultobj;
18939 fail:
18940 return NULL;
18941 }
18942
18943
18944 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18945 PyObject *resultobj;
18946 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18947 bool arg2 ;
18948 PyObject * obj0 = 0 ;
18949 PyObject * obj1 = 0 ;
18950 char *kwnames[] = {
18951 (char *) "self",(char *) "m_shiftDown", NULL
18952 };
18953
18954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18956 if (SWIG_arg_fail(1)) SWIG_fail;
18957 {
18958 arg2 = (bool)(SWIG_As_bool(obj1));
18959 if (SWIG_arg_fail(2)) SWIG_fail;
18960 }
18961 if (arg1) (arg1)->m_shiftDown = arg2;
18962
18963 Py_INCREF(Py_None); resultobj = Py_None;
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18971 PyObject *resultobj;
18972 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18973 bool result;
18974 PyObject * obj0 = 0 ;
18975 char *kwnames[] = {
18976 (char *) "self", NULL
18977 };
18978
18979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18981 if (SWIG_arg_fail(1)) SWIG_fail;
18982 result = (bool) ((arg1)->m_shiftDown);
18983
18984 {
18985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18986 }
18987 return resultobj;
18988 fail:
18989 return NULL;
18990 }
18991
18992
18993 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj;
18995 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18996 bool arg2 ;
18997 PyObject * obj0 = 0 ;
18998 PyObject * obj1 = 0 ;
18999 char *kwnames[] = {
19000 (char *) "self",(char *) "m_altDown", NULL
19001 };
19002
19003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19005 if (SWIG_arg_fail(1)) SWIG_fail;
19006 {
19007 arg2 = (bool)(SWIG_As_bool(obj1));
19008 if (SWIG_arg_fail(2)) SWIG_fail;
19009 }
19010 if (arg1) (arg1)->m_altDown = arg2;
19011
19012 Py_INCREF(Py_None); resultobj = Py_None;
19013 return resultobj;
19014 fail:
19015 return NULL;
19016 }
19017
19018
19019 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19020 PyObject *resultobj;
19021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19022 bool result;
19023 PyObject * obj0 = 0 ;
19024 char *kwnames[] = {
19025 (char *) "self", NULL
19026 };
19027
19028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19030 if (SWIG_arg_fail(1)) SWIG_fail;
19031 result = (bool) ((arg1)->m_altDown);
19032
19033 {
19034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19035 }
19036 return resultobj;
19037 fail:
19038 return NULL;
19039 }
19040
19041
19042 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19043 PyObject *resultobj;
19044 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19045 bool arg2 ;
19046 PyObject * obj0 = 0 ;
19047 PyObject * obj1 = 0 ;
19048 char *kwnames[] = {
19049 (char *) "self",(char *) "m_metaDown", NULL
19050 };
19051
19052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19054 if (SWIG_arg_fail(1)) SWIG_fail;
19055 {
19056 arg2 = (bool)(SWIG_As_bool(obj1));
19057 if (SWIG_arg_fail(2)) SWIG_fail;
19058 }
19059 if (arg1) (arg1)->m_metaDown = arg2;
19060
19061 Py_INCREF(Py_None); resultobj = Py_None;
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj;
19070 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19071 bool result;
19072 PyObject * obj0 = 0 ;
19073 char *kwnames[] = {
19074 (char *) "self", NULL
19075 };
19076
19077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19079 if (SWIG_arg_fail(1)) SWIG_fail;
19080 result = (bool) ((arg1)->m_metaDown);
19081
19082 {
19083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19084 }
19085 return resultobj;
19086 fail:
19087 return NULL;
19088 }
19089
19090
19091 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj;
19093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19094 bool arg2 ;
19095 PyObject * obj0 = 0 ;
19096 PyObject * obj1 = 0 ;
19097 char *kwnames[] = {
19098 (char *) "self",(char *) "m_scanCode", NULL
19099 };
19100
19101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19103 if (SWIG_arg_fail(1)) SWIG_fail;
19104 {
19105 arg2 = (bool)(SWIG_As_bool(obj1));
19106 if (SWIG_arg_fail(2)) SWIG_fail;
19107 }
19108 if (arg1) (arg1)->m_scanCode = arg2;
19109
19110 Py_INCREF(Py_None); resultobj = Py_None;
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj;
19119 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19120 bool result;
19121 PyObject * obj0 = 0 ;
19122 char *kwnames[] = {
19123 (char *) "self", NULL
19124 };
19125
19126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19128 if (SWIG_arg_fail(1)) SWIG_fail;
19129 result = (bool) ((arg1)->m_scanCode);
19130
19131 {
19132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19133 }
19134 return resultobj;
19135 fail:
19136 return NULL;
19137 }
19138
19139
19140 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19141 PyObject *resultobj;
19142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19143 unsigned int arg2 ;
19144 PyObject * obj0 = 0 ;
19145 PyObject * obj1 = 0 ;
19146 char *kwnames[] = {
19147 (char *) "self",(char *) "m_rawCode", NULL
19148 };
19149
19150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19152 if (SWIG_arg_fail(1)) SWIG_fail;
19153 {
19154 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19155 if (SWIG_arg_fail(2)) SWIG_fail;
19156 }
19157 if (arg1) (arg1)->m_rawCode = arg2;
19158
19159 Py_INCREF(Py_None); resultobj = Py_None;
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19167 PyObject *resultobj;
19168 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19169 unsigned int result;
19170 PyObject * obj0 = 0 ;
19171 char *kwnames[] = {
19172 (char *) "self", NULL
19173 };
19174
19175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19177 if (SWIG_arg_fail(1)) SWIG_fail;
19178 result = (unsigned int) ((arg1)->m_rawCode);
19179
19180 {
19181 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19182 }
19183 return resultobj;
19184 fail:
19185 return NULL;
19186 }
19187
19188
19189 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19190 PyObject *resultobj;
19191 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19192 unsigned int arg2 ;
19193 PyObject * obj0 = 0 ;
19194 PyObject * obj1 = 0 ;
19195 char *kwnames[] = {
19196 (char *) "self",(char *) "m_rawFlags", NULL
19197 };
19198
19199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19201 if (SWIG_arg_fail(1)) SWIG_fail;
19202 {
19203 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19204 if (SWIG_arg_fail(2)) SWIG_fail;
19205 }
19206 if (arg1) (arg1)->m_rawFlags = arg2;
19207
19208 Py_INCREF(Py_None); resultobj = Py_None;
19209 return resultobj;
19210 fail:
19211 return NULL;
19212 }
19213
19214
19215 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19216 PyObject *resultobj;
19217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19218 unsigned int result;
19219 PyObject * obj0 = 0 ;
19220 char *kwnames[] = {
19221 (char *) "self", NULL
19222 };
19223
19224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19226 if (SWIG_arg_fail(1)) SWIG_fail;
19227 result = (unsigned int) ((arg1)->m_rawFlags);
19228
19229 {
19230 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19231 }
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19239 PyObject *obj;
19240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19241 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19242 Py_INCREF(obj);
19243 return Py_BuildValue((char *)"");
19244 }
19245 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19246 PyObject *resultobj;
19247 wxSize const &arg1_defvalue = wxDefaultSize ;
19248 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19249 int arg2 = (int) 0 ;
19250 wxSizeEvent *result;
19251 wxSize temp1 ;
19252 PyObject * obj0 = 0 ;
19253 PyObject * obj1 = 0 ;
19254 char *kwnames[] = {
19255 (char *) "sz",(char *) "winid", NULL
19256 };
19257
19258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19259 if (obj0) {
19260 {
19261 arg1 = &temp1;
19262 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19263 }
19264 }
19265 if (obj1) {
19266 {
19267 arg2 = (int)(SWIG_As_int(obj1));
19268 if (SWIG_arg_fail(2)) SWIG_fail;
19269 }
19270 }
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19274
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj;
19287 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19288 wxSize result;
19289 PyObject * obj0 = 0 ;
19290 char *kwnames[] = {
19291 (char *) "self", NULL
19292 };
19293
19294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19296 if (SWIG_arg_fail(1)) SWIG_fail;
19297 {
19298 PyThreadState* __tstate = wxPyBeginAllowThreads();
19299 result = ((wxSizeEvent const *)arg1)->GetSize();
19300
19301 wxPyEndAllowThreads(__tstate);
19302 if (PyErr_Occurred()) SWIG_fail;
19303 }
19304 {
19305 wxSize * resultptr;
19306 resultptr = new wxSize((wxSize &)(result));
19307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19308 }
19309 return resultobj;
19310 fail:
19311 return NULL;
19312 }
19313
19314
19315 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19316 PyObject *resultobj;
19317 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19318 wxRect result;
19319 PyObject * obj0 = 0 ;
19320 char *kwnames[] = {
19321 (char *) "self", NULL
19322 };
19323
19324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19326 if (SWIG_arg_fail(1)) SWIG_fail;
19327 {
19328 PyThreadState* __tstate = wxPyBeginAllowThreads();
19329 result = ((wxSizeEvent const *)arg1)->GetRect();
19330
19331 wxPyEndAllowThreads(__tstate);
19332 if (PyErr_Occurred()) SWIG_fail;
19333 }
19334 {
19335 wxRect * resultptr;
19336 resultptr = new wxRect((wxRect &)(result));
19337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19338 }
19339 return resultobj;
19340 fail:
19341 return NULL;
19342 }
19343
19344
19345 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19346 PyObject *resultobj;
19347 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19348 wxRect arg2 ;
19349 PyObject * obj0 = 0 ;
19350 PyObject * obj1 = 0 ;
19351 char *kwnames[] = {
19352 (char *) "self",(char *) "rect", NULL
19353 };
19354
19355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19357 if (SWIG_arg_fail(1)) SWIG_fail;
19358 {
19359 wxRect * argp;
19360 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19361 if (SWIG_arg_fail(2)) SWIG_fail;
19362 if (argp == NULL) {
19363 SWIG_null_ref("wxRect");
19364 }
19365 if (SWIG_arg_fail(2)) SWIG_fail;
19366 arg2 = *argp;
19367 }
19368 {
19369 PyThreadState* __tstate = wxPyBeginAllowThreads();
19370 (arg1)->SetRect(arg2);
19371
19372 wxPyEndAllowThreads(__tstate);
19373 if (PyErr_Occurred()) SWIG_fail;
19374 }
19375 Py_INCREF(Py_None); resultobj = Py_None;
19376 return resultobj;
19377 fail:
19378 return NULL;
19379 }
19380
19381
19382 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19383 PyObject *resultobj;
19384 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19385 wxSize arg2 ;
19386 PyObject * obj0 = 0 ;
19387 PyObject * obj1 = 0 ;
19388 char *kwnames[] = {
19389 (char *) "self",(char *) "size", NULL
19390 };
19391
19392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19394 if (SWIG_arg_fail(1)) SWIG_fail;
19395 {
19396 wxSize * argp;
19397 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19398 if (SWIG_arg_fail(2)) SWIG_fail;
19399 if (argp == NULL) {
19400 SWIG_null_ref("wxSize");
19401 }
19402 if (SWIG_arg_fail(2)) SWIG_fail;
19403 arg2 = *argp;
19404 }
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 wxSizeEvent_SetSize(arg1,arg2);
19408
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 Py_INCREF(Py_None); resultobj = Py_None;
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj;
19421 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19422 wxSize *arg2 = (wxSize *) 0 ;
19423 PyObject * obj0 = 0 ;
19424 PyObject * obj1 = 0 ;
19425 char *kwnames[] = {
19426 (char *) "self",(char *) "m_size", NULL
19427 };
19428
19429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19431 if (SWIG_arg_fail(1)) SWIG_fail;
19432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19433 if (SWIG_arg_fail(2)) SWIG_fail;
19434 if (arg1) (arg1)->m_size = *arg2;
19435
19436 Py_INCREF(Py_None); resultobj = Py_None;
19437 return resultobj;
19438 fail:
19439 return NULL;
19440 }
19441
19442
19443 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19444 PyObject *resultobj;
19445 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19446 wxSize *result;
19447 PyObject * obj0 = 0 ;
19448 char *kwnames[] = {
19449 (char *) "self", NULL
19450 };
19451
19452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19454 if (SWIG_arg_fail(1)) SWIG_fail;
19455 result = (wxSize *)& ((arg1)->m_size);
19456
19457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19458 return resultobj;
19459 fail:
19460 return NULL;
19461 }
19462
19463
19464 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19465 PyObject *resultobj;
19466 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19467 wxRect *arg2 = (wxRect *) 0 ;
19468 PyObject * obj0 = 0 ;
19469 PyObject * obj1 = 0 ;
19470 char *kwnames[] = {
19471 (char *) "self",(char *) "m_rect", NULL
19472 };
19473
19474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19476 if (SWIG_arg_fail(1)) SWIG_fail;
19477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19478 if (SWIG_arg_fail(2)) SWIG_fail;
19479 if (arg1) (arg1)->m_rect = *arg2;
19480
19481 Py_INCREF(Py_None); resultobj = Py_None;
19482 return resultobj;
19483 fail:
19484 return NULL;
19485 }
19486
19487
19488 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19489 PyObject *resultobj;
19490 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19491 wxRect *result;
19492 PyObject * obj0 = 0 ;
19493 char *kwnames[] = {
19494 (char *) "self", NULL
19495 };
19496
19497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19499 if (SWIG_arg_fail(1)) SWIG_fail;
19500 result = (wxRect *)& ((arg1)->m_rect);
19501
19502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19503 return resultobj;
19504 fail:
19505 return NULL;
19506 }
19507
19508
19509 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19510 PyObject *obj;
19511 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19512 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19513 Py_INCREF(obj);
19514 return Py_BuildValue((char *)"");
19515 }
19516 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19517 PyObject *resultobj;
19518 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19519 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19520 int arg2 = (int) 0 ;
19521 wxMoveEvent *result;
19522 wxPoint temp1 ;
19523 PyObject * obj0 = 0 ;
19524 PyObject * obj1 = 0 ;
19525 char *kwnames[] = {
19526 (char *) "pos",(char *) "winid", NULL
19527 };
19528
19529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19530 if (obj0) {
19531 {
19532 arg1 = &temp1;
19533 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19534 }
19535 }
19536 if (obj1) {
19537 {
19538 arg2 = (int)(SWIG_As_int(obj1));
19539 if (SWIG_arg_fail(2)) SWIG_fail;
19540 }
19541 }
19542 {
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19545
19546 wxPyEndAllowThreads(__tstate);
19547 if (PyErr_Occurred()) SWIG_fail;
19548 }
19549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19557 PyObject *resultobj;
19558 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19559 wxPoint result;
19560 PyObject * obj0 = 0 ;
19561 char *kwnames[] = {
19562 (char *) "self", NULL
19563 };
19564
19565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19567 if (SWIG_arg_fail(1)) SWIG_fail;
19568 {
19569 PyThreadState* __tstate = wxPyBeginAllowThreads();
19570 result = ((wxMoveEvent const *)arg1)->GetPosition();
19571
19572 wxPyEndAllowThreads(__tstate);
19573 if (PyErr_Occurred()) SWIG_fail;
19574 }
19575 {
19576 wxPoint * resultptr;
19577 resultptr = new wxPoint((wxPoint &)(result));
19578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19579 }
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj;
19588 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19589 wxRect result;
19590 PyObject * obj0 = 0 ;
19591 char *kwnames[] = {
19592 (char *) "self", NULL
19593 };
19594
19595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19597 if (SWIG_arg_fail(1)) SWIG_fail;
19598 {
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 result = ((wxMoveEvent const *)arg1)->GetRect();
19601
19602 wxPyEndAllowThreads(__tstate);
19603 if (PyErr_Occurred()) SWIG_fail;
19604 }
19605 {
19606 wxRect * resultptr;
19607 resultptr = new wxRect((wxRect &)(result));
19608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19609 }
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19617 PyObject *resultobj;
19618 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19619 wxRect *arg2 = 0 ;
19620 wxRect temp2 ;
19621 PyObject * obj0 = 0 ;
19622 PyObject * obj1 = 0 ;
19623 char *kwnames[] = {
19624 (char *) "self",(char *) "rect", NULL
19625 };
19626
19627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19629 if (SWIG_arg_fail(1)) SWIG_fail;
19630 {
19631 arg2 = &temp2;
19632 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19633 }
19634 {
19635 PyThreadState* __tstate = wxPyBeginAllowThreads();
19636 (arg1)->SetRect((wxRect const &)*arg2);
19637
19638 wxPyEndAllowThreads(__tstate);
19639 if (PyErr_Occurred()) SWIG_fail;
19640 }
19641 Py_INCREF(Py_None); resultobj = Py_None;
19642 return resultobj;
19643 fail:
19644 return NULL;
19645 }
19646
19647
19648 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19649 PyObject *resultobj;
19650 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19651 wxPoint *arg2 = 0 ;
19652 wxPoint temp2 ;
19653 PyObject * obj0 = 0 ;
19654 PyObject * obj1 = 0 ;
19655 char *kwnames[] = {
19656 (char *) "self",(char *) "pos", NULL
19657 };
19658
19659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19661 if (SWIG_arg_fail(1)) SWIG_fail;
19662 {
19663 arg2 = &temp2;
19664 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19665 }
19666 {
19667 PyThreadState* __tstate = wxPyBeginAllowThreads();
19668 (arg1)->SetPosition((wxPoint const &)*arg2);
19669
19670 wxPyEndAllowThreads(__tstate);
19671 if (PyErr_Occurred()) SWIG_fail;
19672 }
19673 Py_INCREF(Py_None); resultobj = Py_None;
19674 return resultobj;
19675 fail:
19676 return NULL;
19677 }
19678
19679
19680 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19681 PyObject *obj;
19682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19683 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19684 Py_INCREF(obj);
19685 return Py_BuildValue((char *)"");
19686 }
19687 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19688 PyObject *resultobj;
19689 int arg1 = (int) 0 ;
19690 wxPaintEvent *result;
19691 PyObject * obj0 = 0 ;
19692 char *kwnames[] = {
19693 (char *) "Id", NULL
19694 };
19695
19696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19697 if (obj0) {
19698 {
19699 arg1 = (int)(SWIG_As_int(obj0));
19700 if (SWIG_arg_fail(1)) SWIG_fail;
19701 }
19702 }
19703 {
19704 PyThreadState* __tstate = wxPyBeginAllowThreads();
19705 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19706
19707 wxPyEndAllowThreads(__tstate);
19708 if (PyErr_Occurred()) SWIG_fail;
19709 }
19710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19711 return resultobj;
19712 fail:
19713 return NULL;
19714 }
19715
19716
19717 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19718 PyObject *obj;
19719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19720 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19721 Py_INCREF(obj);
19722 return Py_BuildValue((char *)"");
19723 }
19724 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19725 PyObject *resultobj;
19726 int arg1 = (int) 0 ;
19727 wxNcPaintEvent *result;
19728 PyObject * obj0 = 0 ;
19729 char *kwnames[] = {
19730 (char *) "winid", NULL
19731 };
19732
19733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19734 if (obj0) {
19735 {
19736 arg1 = (int)(SWIG_As_int(obj0));
19737 if (SWIG_arg_fail(1)) SWIG_fail;
19738 }
19739 }
19740 {
19741 PyThreadState* __tstate = wxPyBeginAllowThreads();
19742 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19743
19744 wxPyEndAllowThreads(__tstate);
19745 if (PyErr_Occurred()) SWIG_fail;
19746 }
19747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19748 return resultobj;
19749 fail:
19750 return NULL;
19751 }
19752
19753
19754 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19755 PyObject *obj;
19756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19757 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19758 Py_INCREF(obj);
19759 return Py_BuildValue((char *)"");
19760 }
19761 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 int arg1 = (int) 0 ;
19764 wxDC *arg2 = (wxDC *) NULL ;
19765 wxEraseEvent *result;
19766 PyObject * obj0 = 0 ;
19767 PyObject * obj1 = 0 ;
19768 char *kwnames[] = {
19769 (char *) "Id",(char *) "dc", NULL
19770 };
19771
19772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19773 if (obj0) {
19774 {
19775 arg1 = (int)(SWIG_As_int(obj0));
19776 if (SWIG_arg_fail(1)) SWIG_fail;
19777 }
19778 }
19779 if (obj1) {
19780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19781 if (SWIG_arg_fail(2)) SWIG_fail;
19782 }
19783 {
19784 PyThreadState* __tstate = wxPyBeginAllowThreads();
19785 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19786
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19791 return resultobj;
19792 fail:
19793 return NULL;
19794 }
19795
19796
19797 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19798 PyObject *resultobj;
19799 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19800 wxDC *result;
19801 PyObject * obj0 = 0 ;
19802 char *kwnames[] = {
19803 (char *) "self", NULL
19804 };
19805
19806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19808 if (SWIG_arg_fail(1)) SWIG_fail;
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19812
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 {
19817 resultobj = wxPyMake_wxObject(result, 0);
19818 }
19819 return resultobj;
19820 fail:
19821 return NULL;
19822 }
19823
19824
19825 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19826 PyObject *obj;
19827 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19828 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19829 Py_INCREF(obj);
19830 return Py_BuildValue((char *)"");
19831 }
19832 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19833 PyObject *resultobj;
19834 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19835 int arg2 = (int) 0 ;
19836 wxFocusEvent *result;
19837 PyObject * obj0 = 0 ;
19838 PyObject * obj1 = 0 ;
19839 char *kwnames[] = {
19840 (char *) "type",(char *) "winid", NULL
19841 };
19842
19843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19844 if (obj0) {
19845 {
19846 arg1 = (wxEventType)(SWIG_As_int(obj0));
19847 if (SWIG_arg_fail(1)) SWIG_fail;
19848 }
19849 }
19850 if (obj1) {
19851 {
19852 arg2 = (int)(SWIG_As_int(obj1));
19853 if (SWIG_arg_fail(2)) SWIG_fail;
19854 }
19855 }
19856 {
19857 PyThreadState* __tstate = wxPyBeginAllowThreads();
19858 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19859
19860 wxPyEndAllowThreads(__tstate);
19861 if (PyErr_Occurred()) SWIG_fail;
19862 }
19863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19864 return resultobj;
19865 fail:
19866 return NULL;
19867 }
19868
19869
19870 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19871 PyObject *resultobj;
19872 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19873 wxWindow *result;
19874 PyObject * obj0 = 0 ;
19875 char *kwnames[] = {
19876 (char *) "self", NULL
19877 };
19878
19879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19881 if (SWIG_arg_fail(1)) SWIG_fail;
19882 {
19883 PyThreadState* __tstate = wxPyBeginAllowThreads();
19884 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19885
19886 wxPyEndAllowThreads(__tstate);
19887 if (PyErr_Occurred()) SWIG_fail;
19888 }
19889 {
19890 resultobj = wxPyMake_wxObject(result, 0);
19891 }
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj;
19900 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19901 wxWindow *arg2 = (wxWindow *) 0 ;
19902 PyObject * obj0 = 0 ;
19903 PyObject * obj1 = 0 ;
19904 char *kwnames[] = {
19905 (char *) "self",(char *) "win", NULL
19906 };
19907
19908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19910 if (SWIG_arg_fail(1)) SWIG_fail;
19911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19912 if (SWIG_arg_fail(2)) SWIG_fail;
19913 {
19914 PyThreadState* __tstate = wxPyBeginAllowThreads();
19915 (arg1)->SetWindow(arg2);
19916
19917 wxPyEndAllowThreads(__tstate);
19918 if (PyErr_Occurred()) SWIG_fail;
19919 }
19920 Py_INCREF(Py_None); resultobj = Py_None;
19921 return resultobj;
19922 fail:
19923 return NULL;
19924 }
19925
19926
19927 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19928 PyObject *obj;
19929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19930 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19931 Py_INCREF(obj);
19932 return Py_BuildValue((char *)"");
19933 }
19934 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj;
19936 wxWindow *arg1 = (wxWindow *) NULL ;
19937 wxChildFocusEvent *result;
19938 PyObject * obj0 = 0 ;
19939 char *kwnames[] = {
19940 (char *) "win", NULL
19941 };
19942
19943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19944 if (obj0) {
19945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19946 if (SWIG_arg_fail(1)) SWIG_fail;
19947 }
19948 {
19949 PyThreadState* __tstate = wxPyBeginAllowThreads();
19950 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19951
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19956 return resultobj;
19957 fail:
19958 return NULL;
19959 }
19960
19961
19962 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19963 PyObject *resultobj;
19964 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19965 wxWindow *result;
19966 PyObject * obj0 = 0 ;
19967 char *kwnames[] = {
19968 (char *) "self", NULL
19969 };
19970
19971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19973 if (SWIG_arg_fail(1)) SWIG_fail;
19974 {
19975 PyThreadState* __tstate = wxPyBeginAllowThreads();
19976 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19977
19978 wxPyEndAllowThreads(__tstate);
19979 if (PyErr_Occurred()) SWIG_fail;
19980 }
19981 {
19982 resultobj = wxPyMake_wxObject(result, 0);
19983 }
19984 return resultobj;
19985 fail:
19986 return NULL;
19987 }
19988
19989
19990 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19991 PyObject *obj;
19992 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19993 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19994 Py_INCREF(obj);
19995 return Py_BuildValue((char *)"");
19996 }
19997 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19998 PyObject *resultobj;
19999 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20000 bool arg2 = (bool) true ;
20001 int arg3 = (int) 0 ;
20002 wxActivateEvent *result;
20003 PyObject * obj0 = 0 ;
20004 PyObject * obj1 = 0 ;
20005 PyObject * obj2 = 0 ;
20006 char *kwnames[] = {
20007 (char *) "type",(char *) "active",(char *) "Id", NULL
20008 };
20009
20010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20011 if (obj0) {
20012 {
20013 arg1 = (wxEventType)(SWIG_As_int(obj0));
20014 if (SWIG_arg_fail(1)) SWIG_fail;
20015 }
20016 }
20017 if (obj1) {
20018 {
20019 arg2 = (bool)(SWIG_As_bool(obj1));
20020 if (SWIG_arg_fail(2)) SWIG_fail;
20021 }
20022 }
20023 if (obj2) {
20024 {
20025 arg3 = (int)(SWIG_As_int(obj2));
20026 if (SWIG_arg_fail(3)) SWIG_fail;
20027 }
20028 }
20029 {
20030 PyThreadState* __tstate = wxPyBeginAllowThreads();
20031 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20032
20033 wxPyEndAllowThreads(__tstate);
20034 if (PyErr_Occurred()) SWIG_fail;
20035 }
20036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20037 return resultobj;
20038 fail:
20039 return NULL;
20040 }
20041
20042
20043 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20044 PyObject *resultobj;
20045 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20046 bool result;
20047 PyObject * obj0 = 0 ;
20048 char *kwnames[] = {
20049 (char *) "self", NULL
20050 };
20051
20052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20054 if (SWIG_arg_fail(1)) SWIG_fail;
20055 {
20056 PyThreadState* __tstate = wxPyBeginAllowThreads();
20057 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20058
20059 wxPyEndAllowThreads(__tstate);
20060 if (PyErr_Occurred()) SWIG_fail;
20061 }
20062 {
20063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20064 }
20065 return resultobj;
20066 fail:
20067 return NULL;
20068 }
20069
20070
20071 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20072 PyObject *obj;
20073 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20074 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20075 Py_INCREF(obj);
20076 return Py_BuildValue((char *)"");
20077 }
20078 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20079 PyObject *resultobj;
20080 int arg1 = (int) 0 ;
20081 wxInitDialogEvent *result;
20082 PyObject * obj0 = 0 ;
20083 char *kwnames[] = {
20084 (char *) "Id", NULL
20085 };
20086
20087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20088 if (obj0) {
20089 {
20090 arg1 = (int)(SWIG_As_int(obj0));
20091 if (SWIG_arg_fail(1)) SWIG_fail;
20092 }
20093 }
20094 {
20095 PyThreadState* __tstate = wxPyBeginAllowThreads();
20096 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20097
20098 wxPyEndAllowThreads(__tstate);
20099 if (PyErr_Occurred()) SWIG_fail;
20100 }
20101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20102 return resultobj;
20103 fail:
20104 return NULL;
20105 }
20106
20107
20108 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20109 PyObject *obj;
20110 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20111 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20112 Py_INCREF(obj);
20113 return Py_BuildValue((char *)"");
20114 }
20115 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20116 PyObject *resultobj;
20117 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20118 int arg2 = (int) 0 ;
20119 wxMenu *arg3 = (wxMenu *) NULL ;
20120 wxMenuEvent *result;
20121 PyObject * obj0 = 0 ;
20122 PyObject * obj1 = 0 ;
20123 PyObject * obj2 = 0 ;
20124 char *kwnames[] = {
20125 (char *) "type",(char *) "winid",(char *) "menu", NULL
20126 };
20127
20128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20129 if (obj0) {
20130 {
20131 arg1 = (wxEventType)(SWIG_As_int(obj0));
20132 if (SWIG_arg_fail(1)) SWIG_fail;
20133 }
20134 }
20135 if (obj1) {
20136 {
20137 arg2 = (int)(SWIG_As_int(obj1));
20138 if (SWIG_arg_fail(2)) SWIG_fail;
20139 }
20140 }
20141 if (obj2) {
20142 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20143 if (SWIG_arg_fail(3)) SWIG_fail;
20144 }
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20148
20149 wxPyEndAllowThreads(__tstate);
20150 if (PyErr_Occurred()) SWIG_fail;
20151 }
20152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20153 return resultobj;
20154 fail:
20155 return NULL;
20156 }
20157
20158
20159 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20160 PyObject *resultobj;
20161 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20162 int result;
20163 PyObject * obj0 = 0 ;
20164 char *kwnames[] = {
20165 (char *) "self", NULL
20166 };
20167
20168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20170 if (SWIG_arg_fail(1)) SWIG_fail;
20171 {
20172 PyThreadState* __tstate = wxPyBeginAllowThreads();
20173 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20174
20175 wxPyEndAllowThreads(__tstate);
20176 if (PyErr_Occurred()) SWIG_fail;
20177 }
20178 {
20179 resultobj = SWIG_From_int((int)(result));
20180 }
20181 return resultobj;
20182 fail:
20183 return NULL;
20184 }
20185
20186
20187 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20188 PyObject *resultobj;
20189 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20190 bool result;
20191 PyObject * obj0 = 0 ;
20192 char *kwnames[] = {
20193 (char *) "self", NULL
20194 };
20195
20196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20198 if (SWIG_arg_fail(1)) SWIG_fail;
20199 {
20200 PyThreadState* __tstate = wxPyBeginAllowThreads();
20201 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20202
20203 wxPyEndAllowThreads(__tstate);
20204 if (PyErr_Occurred()) SWIG_fail;
20205 }
20206 {
20207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20208 }
20209 return resultobj;
20210 fail:
20211 return NULL;
20212 }
20213
20214
20215 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20216 PyObject *resultobj;
20217 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20218 wxMenu *result;
20219 PyObject * obj0 = 0 ;
20220 char *kwnames[] = {
20221 (char *) "self", NULL
20222 };
20223
20224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20226 if (SWIG_arg_fail(1)) SWIG_fail;
20227 {
20228 PyThreadState* __tstate = wxPyBeginAllowThreads();
20229 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20230
20231 wxPyEndAllowThreads(__tstate);
20232 if (PyErr_Occurred()) SWIG_fail;
20233 }
20234 {
20235 resultobj = wxPyMake_wxObject(result, 0);
20236 }
20237 return resultobj;
20238 fail:
20239 return NULL;
20240 }
20241
20242
20243 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20244 PyObject *obj;
20245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20246 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20247 Py_INCREF(obj);
20248 return Py_BuildValue((char *)"");
20249 }
20250 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20251 PyObject *resultobj;
20252 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20253 int arg2 = (int) 0 ;
20254 wxCloseEvent *result;
20255 PyObject * obj0 = 0 ;
20256 PyObject * obj1 = 0 ;
20257 char *kwnames[] = {
20258 (char *) "type",(char *) "winid", NULL
20259 };
20260
20261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20262 if (obj0) {
20263 {
20264 arg1 = (wxEventType)(SWIG_As_int(obj0));
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 }
20267 }
20268 if (obj1) {
20269 {
20270 arg2 = (int)(SWIG_As_int(obj1));
20271 if (SWIG_arg_fail(2)) SWIG_fail;
20272 }
20273 }
20274 {
20275 PyThreadState* __tstate = wxPyBeginAllowThreads();
20276 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20277
20278 wxPyEndAllowThreads(__tstate);
20279 if (PyErr_Occurred()) SWIG_fail;
20280 }
20281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20282 return resultobj;
20283 fail:
20284 return NULL;
20285 }
20286
20287
20288 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20289 PyObject *resultobj;
20290 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20291 bool arg2 ;
20292 PyObject * obj0 = 0 ;
20293 PyObject * obj1 = 0 ;
20294 char *kwnames[] = {
20295 (char *) "self",(char *) "logOff", NULL
20296 };
20297
20298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20300 if (SWIG_arg_fail(1)) SWIG_fail;
20301 {
20302 arg2 = (bool)(SWIG_As_bool(obj1));
20303 if (SWIG_arg_fail(2)) SWIG_fail;
20304 }
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 (arg1)->SetLoggingOff(arg2);
20308
20309 wxPyEndAllowThreads(__tstate);
20310 if (PyErr_Occurred()) SWIG_fail;
20311 }
20312 Py_INCREF(Py_None); resultobj = Py_None;
20313 return resultobj;
20314 fail:
20315 return NULL;
20316 }
20317
20318
20319 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20320 PyObject *resultobj;
20321 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20322 bool result;
20323 PyObject * obj0 = 0 ;
20324 char *kwnames[] = {
20325 (char *) "self", NULL
20326 };
20327
20328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20330 if (SWIG_arg_fail(1)) SWIG_fail;
20331 {
20332 PyThreadState* __tstate = wxPyBeginAllowThreads();
20333 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20334
20335 wxPyEndAllowThreads(__tstate);
20336 if (PyErr_Occurred()) SWIG_fail;
20337 }
20338 {
20339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20340 }
20341 return resultobj;
20342 fail:
20343 return NULL;
20344 }
20345
20346
20347 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20348 PyObject *resultobj;
20349 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20350 bool arg2 = (bool) true ;
20351 PyObject * obj0 = 0 ;
20352 PyObject * obj1 = 0 ;
20353 char *kwnames[] = {
20354 (char *) "self",(char *) "veto", NULL
20355 };
20356
20357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20359 if (SWIG_arg_fail(1)) SWIG_fail;
20360 if (obj1) {
20361 {
20362 arg2 = (bool)(SWIG_As_bool(obj1));
20363 if (SWIG_arg_fail(2)) SWIG_fail;
20364 }
20365 }
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 (arg1)->Veto(arg2);
20369
20370 wxPyEndAllowThreads(__tstate);
20371 if (PyErr_Occurred()) SWIG_fail;
20372 }
20373 Py_INCREF(Py_None); resultobj = Py_None;
20374 return resultobj;
20375 fail:
20376 return NULL;
20377 }
20378
20379
20380 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20381 PyObject *resultobj;
20382 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20383 bool result;
20384 PyObject * obj0 = 0 ;
20385 char *kwnames[] = {
20386 (char *) "self", NULL
20387 };
20388
20389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20395
20396 wxPyEndAllowThreads(__tstate);
20397 if (PyErr_Occurred()) SWIG_fail;
20398 }
20399 {
20400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20401 }
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20409 PyObject *resultobj;
20410 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20411 bool arg2 ;
20412 PyObject * obj0 = 0 ;
20413 PyObject * obj1 = 0 ;
20414 char *kwnames[] = {
20415 (char *) "self",(char *) "canVeto", NULL
20416 };
20417
20418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20420 if (SWIG_arg_fail(1)) SWIG_fail;
20421 {
20422 arg2 = (bool)(SWIG_As_bool(obj1));
20423 if (SWIG_arg_fail(2)) SWIG_fail;
20424 }
20425 {
20426 PyThreadState* __tstate = wxPyBeginAllowThreads();
20427 (arg1)->SetCanVeto(arg2);
20428
20429 wxPyEndAllowThreads(__tstate);
20430 if (PyErr_Occurred()) SWIG_fail;
20431 }
20432 Py_INCREF(Py_None); resultobj = Py_None;
20433 return resultobj;
20434 fail:
20435 return NULL;
20436 }
20437
20438
20439 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20440 PyObject *resultobj;
20441 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20442 bool result;
20443 PyObject * obj0 = 0 ;
20444 char *kwnames[] = {
20445 (char *) "self", NULL
20446 };
20447
20448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20450 if (SWIG_arg_fail(1)) SWIG_fail;
20451 {
20452 PyThreadState* __tstate = wxPyBeginAllowThreads();
20453 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20454
20455 wxPyEndAllowThreads(__tstate);
20456 if (PyErr_Occurred()) SWIG_fail;
20457 }
20458 {
20459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20460 }
20461 return resultobj;
20462 fail:
20463 return NULL;
20464 }
20465
20466
20467 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20468 PyObject *obj;
20469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20470 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20471 Py_INCREF(obj);
20472 return Py_BuildValue((char *)"");
20473 }
20474 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj;
20476 int arg1 = (int) 0 ;
20477 bool arg2 = (bool) false ;
20478 wxShowEvent *result;
20479 PyObject * obj0 = 0 ;
20480 PyObject * obj1 = 0 ;
20481 char *kwnames[] = {
20482 (char *) "winid",(char *) "show", NULL
20483 };
20484
20485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20486 if (obj0) {
20487 {
20488 arg1 = (int)(SWIG_As_int(obj0));
20489 if (SWIG_arg_fail(1)) SWIG_fail;
20490 }
20491 }
20492 if (obj1) {
20493 {
20494 arg2 = (bool)(SWIG_As_bool(obj1));
20495 if (SWIG_arg_fail(2)) SWIG_fail;
20496 }
20497 }
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20501
20502 wxPyEndAllowThreads(__tstate);
20503 if (PyErr_Occurred()) SWIG_fail;
20504 }
20505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20513 PyObject *resultobj;
20514 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20515 bool arg2 ;
20516 PyObject * obj0 = 0 ;
20517 PyObject * obj1 = 0 ;
20518 char *kwnames[] = {
20519 (char *) "self",(char *) "show", NULL
20520 };
20521
20522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20524 if (SWIG_arg_fail(1)) SWIG_fail;
20525 {
20526 arg2 = (bool)(SWIG_As_bool(obj1));
20527 if (SWIG_arg_fail(2)) SWIG_fail;
20528 }
20529 {
20530 PyThreadState* __tstate = wxPyBeginAllowThreads();
20531 (arg1)->SetShow(arg2);
20532
20533 wxPyEndAllowThreads(__tstate);
20534 if (PyErr_Occurred()) SWIG_fail;
20535 }
20536 Py_INCREF(Py_None); resultobj = Py_None;
20537 return resultobj;
20538 fail:
20539 return NULL;
20540 }
20541
20542
20543 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20544 PyObject *resultobj;
20545 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20546 bool result;
20547 PyObject * obj0 = 0 ;
20548 char *kwnames[] = {
20549 (char *) "self", NULL
20550 };
20551
20552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20554 if (SWIG_arg_fail(1)) SWIG_fail;
20555 {
20556 PyThreadState* __tstate = wxPyBeginAllowThreads();
20557 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20558
20559 wxPyEndAllowThreads(__tstate);
20560 if (PyErr_Occurred()) SWIG_fail;
20561 }
20562 {
20563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20564 }
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20572 PyObject *obj;
20573 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20574 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20575 Py_INCREF(obj);
20576 return Py_BuildValue((char *)"");
20577 }
20578 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20579 PyObject *resultobj;
20580 int arg1 = (int) 0 ;
20581 bool arg2 = (bool) true ;
20582 wxIconizeEvent *result;
20583 PyObject * obj0 = 0 ;
20584 PyObject * obj1 = 0 ;
20585 char *kwnames[] = {
20586 (char *) "id",(char *) "iconized", NULL
20587 };
20588
20589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20590 if (obj0) {
20591 {
20592 arg1 = (int)(SWIG_As_int(obj0));
20593 if (SWIG_arg_fail(1)) SWIG_fail;
20594 }
20595 }
20596 if (obj1) {
20597 {
20598 arg2 = (bool)(SWIG_As_bool(obj1));
20599 if (SWIG_arg_fail(2)) SWIG_fail;
20600 }
20601 }
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20605
20606 wxPyEndAllowThreads(__tstate);
20607 if (PyErr_Occurred()) SWIG_fail;
20608 }
20609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20610 return resultobj;
20611 fail:
20612 return NULL;
20613 }
20614
20615
20616 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20617 PyObject *resultobj;
20618 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20619 bool result;
20620 PyObject * obj0 = 0 ;
20621 char *kwnames[] = {
20622 (char *) "self", NULL
20623 };
20624
20625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20627 if (SWIG_arg_fail(1)) SWIG_fail;
20628 {
20629 PyThreadState* __tstate = wxPyBeginAllowThreads();
20630 result = (bool)(arg1)->Iconized();
20631
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20645 PyObject *obj;
20646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20647 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20648 Py_INCREF(obj);
20649 return Py_BuildValue((char *)"");
20650 }
20651 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20652 PyObject *resultobj;
20653 int arg1 = (int) 0 ;
20654 wxMaximizeEvent *result;
20655 PyObject * obj0 = 0 ;
20656 char *kwnames[] = {
20657 (char *) "id", NULL
20658 };
20659
20660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20661 if (obj0) {
20662 {
20663 arg1 = (int)(SWIG_As_int(obj0));
20664 if (SWIG_arg_fail(1)) SWIG_fail;
20665 }
20666 }
20667 {
20668 PyThreadState* __tstate = wxPyBeginAllowThreads();
20669 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20670
20671 wxPyEndAllowThreads(__tstate);
20672 if (PyErr_Occurred()) SWIG_fail;
20673 }
20674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20675 return resultobj;
20676 fail:
20677 return NULL;
20678 }
20679
20680
20681 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20682 PyObject *obj;
20683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20684 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20685 Py_INCREF(obj);
20686 return Py_BuildValue((char *)"");
20687 }
20688 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20689 PyObject *resultobj;
20690 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20691 wxPoint result;
20692 PyObject * obj0 = 0 ;
20693 char *kwnames[] = {
20694 (char *) "self", NULL
20695 };
20696
20697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20699 if (SWIG_arg_fail(1)) SWIG_fail;
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (arg1)->GetPosition();
20703
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 {
20708 wxPoint * resultptr;
20709 resultptr = new wxPoint((wxPoint &)(result));
20710 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20711 }
20712 return resultobj;
20713 fail:
20714 return NULL;
20715 }
20716
20717
20718 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20719 PyObject *resultobj;
20720 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20721 int result;
20722 PyObject * obj0 = 0 ;
20723 char *kwnames[] = {
20724 (char *) "self", NULL
20725 };
20726
20727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20729 if (SWIG_arg_fail(1)) SWIG_fail;
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 result = (int)(arg1)->GetNumberOfFiles();
20733
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 {
20738 resultobj = SWIG_From_int((int)(result));
20739 }
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20747 PyObject *resultobj;
20748 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20749 PyObject *result;
20750 PyObject * obj0 = 0 ;
20751 char *kwnames[] = {
20752 (char *) "self", NULL
20753 };
20754
20755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20757 if (SWIG_arg_fail(1)) SWIG_fail;
20758 {
20759 PyThreadState* __tstate = wxPyBeginAllowThreads();
20760 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20761
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 resultobj = result;
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20773 PyObject *obj;
20774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20775 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20776 Py_INCREF(obj);
20777 return Py_BuildValue((char *)"");
20778 }
20779 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20780 PyObject *resultobj;
20781 int arg1 = (int) 0 ;
20782 wxUpdateUIEvent *result;
20783 PyObject * obj0 = 0 ;
20784 char *kwnames[] = {
20785 (char *) "commandId", NULL
20786 };
20787
20788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20789 if (obj0) {
20790 {
20791 arg1 = (int)(SWIG_As_int(obj0));
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 }
20794 }
20795 {
20796 PyThreadState* __tstate = wxPyBeginAllowThreads();
20797 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20798
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20803 return resultobj;
20804 fail:
20805 return NULL;
20806 }
20807
20808
20809 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20810 PyObject *resultobj;
20811 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20812 bool result;
20813 PyObject * obj0 = 0 ;
20814 char *kwnames[] = {
20815 (char *) "self", NULL
20816 };
20817
20818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20820 if (SWIG_arg_fail(1)) SWIG_fail;
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20824
20825 wxPyEndAllowThreads(__tstate);
20826 if (PyErr_Occurred()) SWIG_fail;
20827 }
20828 {
20829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20830 }
20831 return resultobj;
20832 fail:
20833 return NULL;
20834 }
20835
20836
20837 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20838 PyObject *resultobj;
20839 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20840 bool result;
20841 PyObject * obj0 = 0 ;
20842 char *kwnames[] = {
20843 (char *) "self", NULL
20844 };
20845
20846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20848 if (SWIG_arg_fail(1)) SWIG_fail;
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20852
20853 wxPyEndAllowThreads(__tstate);
20854 if (PyErr_Occurred()) SWIG_fail;
20855 }
20856 {
20857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20858 }
20859 return resultobj;
20860 fail:
20861 return NULL;
20862 }
20863
20864
20865 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20866 PyObject *resultobj;
20867 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20868 wxString result;
20869 PyObject * obj0 = 0 ;
20870 char *kwnames[] = {
20871 (char *) "self", NULL
20872 };
20873
20874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20876 if (SWIG_arg_fail(1)) SWIG_fail;
20877 {
20878 PyThreadState* __tstate = wxPyBeginAllowThreads();
20879 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20880
20881 wxPyEndAllowThreads(__tstate);
20882 if (PyErr_Occurred()) SWIG_fail;
20883 }
20884 {
20885 #if wxUSE_UNICODE
20886 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20887 #else
20888 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20889 #endif
20890 }
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj;
20899 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20900 bool result;
20901 PyObject * obj0 = 0 ;
20902 char *kwnames[] = {
20903 (char *) "self", NULL
20904 };
20905
20906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20908 if (SWIG_arg_fail(1)) SWIG_fail;
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20912
20913 wxPyEndAllowThreads(__tstate);
20914 if (PyErr_Occurred()) SWIG_fail;
20915 }
20916 {
20917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20918 }
20919 return resultobj;
20920 fail:
20921 return NULL;
20922 }
20923
20924
20925 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20926 PyObject *resultobj;
20927 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20928 bool result;
20929 PyObject * obj0 = 0 ;
20930 char *kwnames[] = {
20931 (char *) "self", NULL
20932 };
20933
20934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20936 if (SWIG_arg_fail(1)) SWIG_fail;
20937 {
20938 PyThreadState* __tstate = wxPyBeginAllowThreads();
20939 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20940
20941 wxPyEndAllowThreads(__tstate);
20942 if (PyErr_Occurred()) SWIG_fail;
20943 }
20944 {
20945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20946 }
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20954 PyObject *resultobj;
20955 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20956 bool result;
20957 PyObject * obj0 = 0 ;
20958 char *kwnames[] = {
20959 (char *) "self", NULL
20960 };
20961
20962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20964 if (SWIG_arg_fail(1)) SWIG_fail;
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20968
20969 wxPyEndAllowThreads(__tstate);
20970 if (PyErr_Occurred()) SWIG_fail;
20971 }
20972 {
20973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20974 }
20975 return resultobj;
20976 fail:
20977 return NULL;
20978 }
20979
20980
20981 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20982 PyObject *resultobj;
20983 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20984 bool arg2 ;
20985 PyObject * obj0 = 0 ;
20986 PyObject * obj1 = 0 ;
20987 char *kwnames[] = {
20988 (char *) "self",(char *) "check", NULL
20989 };
20990
20991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20993 if (SWIG_arg_fail(1)) SWIG_fail;
20994 {
20995 arg2 = (bool)(SWIG_As_bool(obj1));
20996 if (SWIG_arg_fail(2)) SWIG_fail;
20997 }
20998 {
20999 PyThreadState* __tstate = wxPyBeginAllowThreads();
21000 (arg1)->Check(arg2);
21001
21002 wxPyEndAllowThreads(__tstate);
21003 if (PyErr_Occurred()) SWIG_fail;
21004 }
21005 Py_INCREF(Py_None); resultobj = Py_None;
21006 return resultobj;
21007 fail:
21008 return NULL;
21009 }
21010
21011
21012 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21013 PyObject *resultobj;
21014 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21015 bool arg2 ;
21016 PyObject * obj0 = 0 ;
21017 PyObject * obj1 = 0 ;
21018 char *kwnames[] = {
21019 (char *) "self",(char *) "enable", NULL
21020 };
21021
21022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21024 if (SWIG_arg_fail(1)) SWIG_fail;
21025 {
21026 arg2 = (bool)(SWIG_As_bool(obj1));
21027 if (SWIG_arg_fail(2)) SWIG_fail;
21028 }
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 (arg1)->Enable(arg2);
21032
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 Py_INCREF(Py_None); resultobj = Py_None;
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21044 PyObject *resultobj;
21045 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21046 wxString *arg2 = 0 ;
21047 bool temp2 = false ;
21048 PyObject * obj0 = 0 ;
21049 PyObject * obj1 = 0 ;
21050 char *kwnames[] = {
21051 (char *) "self",(char *) "text", NULL
21052 };
21053
21054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21056 if (SWIG_arg_fail(1)) SWIG_fail;
21057 {
21058 arg2 = wxString_in_helper(obj1);
21059 if (arg2 == NULL) SWIG_fail;
21060 temp2 = true;
21061 }
21062 {
21063 PyThreadState* __tstate = wxPyBeginAllowThreads();
21064 (arg1)->SetText((wxString const &)*arg2);
21065
21066 wxPyEndAllowThreads(__tstate);
21067 if (PyErr_Occurred()) SWIG_fail;
21068 }
21069 Py_INCREF(Py_None); resultobj = Py_None;
21070 {
21071 if (temp2)
21072 delete arg2;
21073 }
21074 return resultobj;
21075 fail:
21076 {
21077 if (temp2)
21078 delete arg2;
21079 }
21080 return NULL;
21081 }
21082
21083
21084 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21085 PyObject *resultobj;
21086 long arg1 ;
21087 PyObject * obj0 = 0 ;
21088 char *kwnames[] = {
21089 (char *) "updateInterval", NULL
21090 };
21091
21092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21093 {
21094 arg1 = (long)(SWIG_As_long(obj0));
21095 if (SWIG_arg_fail(1)) SWIG_fail;
21096 }
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 wxUpdateUIEvent::SetUpdateInterval(arg1);
21100
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 Py_INCREF(Py_None); resultobj = Py_None;
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21112 PyObject *resultobj;
21113 long result;
21114 char *kwnames[] = {
21115 NULL
21116 };
21117
21118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21119 {
21120 PyThreadState* __tstate = wxPyBeginAllowThreads();
21121 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21122
21123 wxPyEndAllowThreads(__tstate);
21124 if (PyErr_Occurred()) SWIG_fail;
21125 }
21126 {
21127 resultobj = SWIG_From_long((long)(result));
21128 }
21129 return resultobj;
21130 fail:
21131 return NULL;
21132 }
21133
21134
21135 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21136 PyObject *resultobj;
21137 wxWindow *arg1 = (wxWindow *) 0 ;
21138 bool result;
21139 PyObject * obj0 = 0 ;
21140 char *kwnames[] = {
21141 (char *) "win", NULL
21142 };
21143
21144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21146 if (SWIG_arg_fail(1)) SWIG_fail;
21147 {
21148 PyThreadState* __tstate = wxPyBeginAllowThreads();
21149 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21150
21151 wxPyEndAllowThreads(__tstate);
21152 if (PyErr_Occurred()) SWIG_fail;
21153 }
21154 {
21155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21156 }
21157 return resultobj;
21158 fail:
21159 return NULL;
21160 }
21161
21162
21163 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21164 PyObject *resultobj;
21165 char *kwnames[] = {
21166 NULL
21167 };
21168
21169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 wxUpdateUIEvent::ResetUpdateTime();
21173
21174 wxPyEndAllowThreads(__tstate);
21175 if (PyErr_Occurred()) SWIG_fail;
21176 }
21177 Py_INCREF(Py_None); resultobj = Py_None;
21178 return resultobj;
21179 fail:
21180 return NULL;
21181 }
21182
21183
21184 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21185 PyObject *resultobj;
21186 wxUpdateUIMode arg1 ;
21187 PyObject * obj0 = 0 ;
21188 char *kwnames[] = {
21189 (char *) "mode", NULL
21190 };
21191
21192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21193 {
21194 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21195 if (SWIG_arg_fail(1)) SWIG_fail;
21196 }
21197 {
21198 PyThreadState* __tstate = wxPyBeginAllowThreads();
21199 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21200
21201 wxPyEndAllowThreads(__tstate);
21202 if (PyErr_Occurred()) SWIG_fail;
21203 }
21204 Py_INCREF(Py_None); resultobj = Py_None;
21205 return resultobj;
21206 fail:
21207 return NULL;
21208 }
21209
21210
21211 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21212 PyObject *resultobj;
21213 wxUpdateUIMode result;
21214 char *kwnames[] = {
21215 NULL
21216 };
21217
21218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21219 {
21220 PyThreadState* __tstate = wxPyBeginAllowThreads();
21221 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21222
21223 wxPyEndAllowThreads(__tstate);
21224 if (PyErr_Occurred()) SWIG_fail;
21225 }
21226 resultobj = SWIG_From_int((result));
21227 return resultobj;
21228 fail:
21229 return NULL;
21230 }
21231
21232
21233 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21234 PyObject *obj;
21235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21236 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21237 Py_INCREF(obj);
21238 return Py_BuildValue((char *)"");
21239 }
21240 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21241 PyObject *resultobj;
21242 wxSysColourChangedEvent *result;
21243 char *kwnames[] = {
21244 NULL
21245 };
21246
21247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21248 {
21249 PyThreadState* __tstate = wxPyBeginAllowThreads();
21250 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21251
21252 wxPyEndAllowThreads(__tstate);
21253 if (PyErr_Occurred()) SWIG_fail;
21254 }
21255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21263 PyObject *obj;
21264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21265 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21266 Py_INCREF(obj);
21267 return Py_BuildValue((char *)"");
21268 }
21269 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21270 PyObject *resultobj;
21271 int arg1 = (int) 0 ;
21272 wxWindow *arg2 = (wxWindow *) NULL ;
21273 wxMouseCaptureChangedEvent *result;
21274 PyObject * obj0 = 0 ;
21275 PyObject * obj1 = 0 ;
21276 char *kwnames[] = {
21277 (char *) "winid",(char *) "gainedCapture", NULL
21278 };
21279
21280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21281 if (obj0) {
21282 {
21283 arg1 = (int)(SWIG_As_int(obj0));
21284 if (SWIG_arg_fail(1)) SWIG_fail;
21285 }
21286 }
21287 if (obj1) {
21288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21289 if (SWIG_arg_fail(2)) SWIG_fail;
21290 }
21291 {
21292 PyThreadState* __tstate = wxPyBeginAllowThreads();
21293 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21294
21295 wxPyEndAllowThreads(__tstate);
21296 if (PyErr_Occurred()) SWIG_fail;
21297 }
21298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21306 PyObject *resultobj;
21307 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21308 wxWindow *result;
21309 PyObject * obj0 = 0 ;
21310 char *kwnames[] = {
21311 (char *) "self", NULL
21312 };
21313
21314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21316 if (SWIG_arg_fail(1)) SWIG_fail;
21317 {
21318 PyThreadState* __tstate = wxPyBeginAllowThreads();
21319 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21320
21321 wxPyEndAllowThreads(__tstate);
21322 if (PyErr_Occurred()) SWIG_fail;
21323 }
21324 {
21325 resultobj = wxPyMake_wxObject(result, 0);
21326 }
21327 return resultobj;
21328 fail:
21329 return NULL;
21330 }
21331
21332
21333 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21334 PyObject *obj;
21335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21336 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21337 Py_INCREF(obj);
21338 return Py_BuildValue((char *)"");
21339 }
21340 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21341 PyObject *resultobj;
21342 wxDisplayChangedEvent *result;
21343 char *kwnames[] = {
21344 NULL
21345 };
21346
21347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21348 {
21349 PyThreadState* __tstate = wxPyBeginAllowThreads();
21350 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21351
21352 wxPyEndAllowThreads(__tstate);
21353 if (PyErr_Occurred()) SWIG_fail;
21354 }
21355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21356 return resultobj;
21357 fail:
21358 return NULL;
21359 }
21360
21361
21362 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21363 PyObject *obj;
21364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21365 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21366 Py_INCREF(obj);
21367 return Py_BuildValue((char *)"");
21368 }
21369 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21370 PyObject *resultobj;
21371 int arg1 = (int) 0 ;
21372 wxPaletteChangedEvent *result;
21373 PyObject * obj0 = 0 ;
21374 char *kwnames[] = {
21375 (char *) "id", NULL
21376 };
21377
21378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21379 if (obj0) {
21380 {
21381 arg1 = (int)(SWIG_As_int(obj0));
21382 if (SWIG_arg_fail(1)) SWIG_fail;
21383 }
21384 }
21385 {
21386 PyThreadState* __tstate = wxPyBeginAllowThreads();
21387 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21388
21389 wxPyEndAllowThreads(__tstate);
21390 if (PyErr_Occurred()) SWIG_fail;
21391 }
21392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21393 return resultobj;
21394 fail:
21395 return NULL;
21396 }
21397
21398
21399 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21400 PyObject *resultobj;
21401 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21402 wxWindow *arg2 = (wxWindow *) 0 ;
21403 PyObject * obj0 = 0 ;
21404 PyObject * obj1 = 0 ;
21405 char *kwnames[] = {
21406 (char *) "self",(char *) "win", NULL
21407 };
21408
21409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21411 if (SWIG_arg_fail(1)) SWIG_fail;
21412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21413 if (SWIG_arg_fail(2)) SWIG_fail;
21414 {
21415 PyThreadState* __tstate = wxPyBeginAllowThreads();
21416 (arg1)->SetChangedWindow(arg2);
21417
21418 wxPyEndAllowThreads(__tstate);
21419 if (PyErr_Occurred()) SWIG_fail;
21420 }
21421 Py_INCREF(Py_None); resultobj = Py_None;
21422 return resultobj;
21423 fail:
21424 return NULL;
21425 }
21426
21427
21428 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21429 PyObject *resultobj;
21430 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21431 wxWindow *result;
21432 PyObject * obj0 = 0 ;
21433 char *kwnames[] = {
21434 (char *) "self", NULL
21435 };
21436
21437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21439 if (SWIG_arg_fail(1)) SWIG_fail;
21440 {
21441 PyThreadState* __tstate = wxPyBeginAllowThreads();
21442 result = (wxWindow *)(arg1)->GetChangedWindow();
21443
21444 wxPyEndAllowThreads(__tstate);
21445 if (PyErr_Occurred()) SWIG_fail;
21446 }
21447 {
21448 resultobj = wxPyMake_wxObject(result, 0);
21449 }
21450 return resultobj;
21451 fail:
21452 return NULL;
21453 }
21454
21455
21456 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21457 PyObject *obj;
21458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21459 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21460 Py_INCREF(obj);
21461 return Py_BuildValue((char *)"");
21462 }
21463 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21464 PyObject *resultobj;
21465 int arg1 = (int) 0 ;
21466 wxQueryNewPaletteEvent *result;
21467 PyObject * obj0 = 0 ;
21468 char *kwnames[] = {
21469 (char *) "winid", NULL
21470 };
21471
21472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21473 if (obj0) {
21474 {
21475 arg1 = (int)(SWIG_As_int(obj0));
21476 if (SWIG_arg_fail(1)) SWIG_fail;
21477 }
21478 }
21479 {
21480 PyThreadState* __tstate = wxPyBeginAllowThreads();
21481 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21482
21483 wxPyEndAllowThreads(__tstate);
21484 if (PyErr_Occurred()) SWIG_fail;
21485 }
21486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21487 return resultobj;
21488 fail:
21489 return NULL;
21490 }
21491
21492
21493 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21494 PyObject *resultobj;
21495 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21496 bool arg2 ;
21497 PyObject * obj0 = 0 ;
21498 PyObject * obj1 = 0 ;
21499 char *kwnames[] = {
21500 (char *) "self",(char *) "realized", NULL
21501 };
21502
21503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21505 if (SWIG_arg_fail(1)) SWIG_fail;
21506 {
21507 arg2 = (bool)(SWIG_As_bool(obj1));
21508 if (SWIG_arg_fail(2)) SWIG_fail;
21509 }
21510 {
21511 PyThreadState* __tstate = wxPyBeginAllowThreads();
21512 (arg1)->SetPaletteRealized(arg2);
21513
21514 wxPyEndAllowThreads(__tstate);
21515 if (PyErr_Occurred()) SWIG_fail;
21516 }
21517 Py_INCREF(Py_None); resultobj = Py_None;
21518 return resultobj;
21519 fail:
21520 return NULL;
21521 }
21522
21523
21524 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21525 PyObject *resultobj;
21526 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21527 bool result;
21528 PyObject * obj0 = 0 ;
21529 char *kwnames[] = {
21530 (char *) "self", NULL
21531 };
21532
21533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21535 if (SWIG_arg_fail(1)) SWIG_fail;
21536 {
21537 PyThreadState* __tstate = wxPyBeginAllowThreads();
21538 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21539
21540 wxPyEndAllowThreads(__tstate);
21541 if (PyErr_Occurred()) SWIG_fail;
21542 }
21543 {
21544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21545 }
21546 return resultobj;
21547 fail:
21548 return NULL;
21549 }
21550
21551
21552 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21553 PyObject *obj;
21554 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21555 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21556 Py_INCREF(obj);
21557 return Py_BuildValue((char *)"");
21558 }
21559 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21560 PyObject *resultobj;
21561 wxNavigationKeyEvent *result;
21562 char *kwnames[] = {
21563 NULL
21564 };
21565
21566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21567 {
21568 PyThreadState* __tstate = wxPyBeginAllowThreads();
21569 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21570
21571 wxPyEndAllowThreads(__tstate);
21572 if (PyErr_Occurred()) SWIG_fail;
21573 }
21574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21575 return resultobj;
21576 fail:
21577 return NULL;
21578 }
21579
21580
21581 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21582 PyObject *resultobj;
21583 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21584 bool result;
21585 PyObject * obj0 = 0 ;
21586 char *kwnames[] = {
21587 (char *) "self", NULL
21588 };
21589
21590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21592 if (SWIG_arg_fail(1)) SWIG_fail;
21593 {
21594 PyThreadState* __tstate = wxPyBeginAllowThreads();
21595 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21596
21597 wxPyEndAllowThreads(__tstate);
21598 if (PyErr_Occurred()) SWIG_fail;
21599 }
21600 {
21601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21602 }
21603 return resultobj;
21604 fail:
21605 return NULL;
21606 }
21607
21608
21609 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21610 PyObject *resultobj;
21611 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21612 bool arg2 ;
21613 PyObject * obj0 = 0 ;
21614 PyObject * obj1 = 0 ;
21615 char *kwnames[] = {
21616 (char *) "self",(char *) "forward", NULL
21617 };
21618
21619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21621 if (SWIG_arg_fail(1)) SWIG_fail;
21622 {
21623 arg2 = (bool)(SWIG_As_bool(obj1));
21624 if (SWIG_arg_fail(2)) SWIG_fail;
21625 }
21626 {
21627 PyThreadState* __tstate = wxPyBeginAllowThreads();
21628 (arg1)->SetDirection(arg2);
21629
21630 wxPyEndAllowThreads(__tstate);
21631 if (PyErr_Occurred()) SWIG_fail;
21632 }
21633 Py_INCREF(Py_None); resultobj = Py_None;
21634 return resultobj;
21635 fail:
21636 return NULL;
21637 }
21638
21639
21640 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21641 PyObject *resultobj;
21642 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21643 bool result;
21644 PyObject * obj0 = 0 ;
21645 char *kwnames[] = {
21646 (char *) "self", NULL
21647 };
21648
21649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21651 if (SWIG_arg_fail(1)) SWIG_fail;
21652 {
21653 PyThreadState* __tstate = wxPyBeginAllowThreads();
21654 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21655
21656 wxPyEndAllowThreads(__tstate);
21657 if (PyErr_Occurred()) SWIG_fail;
21658 }
21659 {
21660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21661 }
21662 return resultobj;
21663 fail:
21664 return NULL;
21665 }
21666
21667
21668 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21669 PyObject *resultobj;
21670 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21671 bool arg2 ;
21672 PyObject * obj0 = 0 ;
21673 PyObject * obj1 = 0 ;
21674 char *kwnames[] = {
21675 (char *) "self",(char *) "ischange", NULL
21676 };
21677
21678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21680 if (SWIG_arg_fail(1)) SWIG_fail;
21681 {
21682 arg2 = (bool)(SWIG_As_bool(obj1));
21683 if (SWIG_arg_fail(2)) SWIG_fail;
21684 }
21685 {
21686 PyThreadState* __tstate = wxPyBeginAllowThreads();
21687 (arg1)->SetWindowChange(arg2);
21688
21689 wxPyEndAllowThreads(__tstate);
21690 if (PyErr_Occurred()) SWIG_fail;
21691 }
21692 Py_INCREF(Py_None); resultobj = Py_None;
21693 return resultobj;
21694 fail:
21695 return NULL;
21696 }
21697
21698
21699 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21700 PyObject *resultobj;
21701 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21702 bool result;
21703 PyObject * obj0 = 0 ;
21704 char *kwnames[] = {
21705 (char *) "self", NULL
21706 };
21707
21708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21710 if (SWIG_arg_fail(1)) SWIG_fail;
21711 {
21712 PyThreadState* __tstate = wxPyBeginAllowThreads();
21713 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21714
21715 wxPyEndAllowThreads(__tstate);
21716 if (PyErr_Occurred()) SWIG_fail;
21717 }
21718 {
21719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21720 }
21721 return resultobj;
21722 fail:
21723 return NULL;
21724 }
21725
21726
21727 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21728 PyObject *resultobj;
21729 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21730 bool arg2 ;
21731 PyObject * obj0 = 0 ;
21732 PyObject * obj1 = 0 ;
21733 char *kwnames[] = {
21734 (char *) "self",(char *) "bIs", NULL
21735 };
21736
21737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21739 if (SWIG_arg_fail(1)) SWIG_fail;
21740 {
21741 arg2 = (bool)(SWIG_As_bool(obj1));
21742 if (SWIG_arg_fail(2)) SWIG_fail;
21743 }
21744 {
21745 PyThreadState* __tstate = wxPyBeginAllowThreads();
21746 (arg1)->SetFromTab(arg2);
21747
21748 wxPyEndAllowThreads(__tstate);
21749 if (PyErr_Occurred()) SWIG_fail;
21750 }
21751 Py_INCREF(Py_None); resultobj = Py_None;
21752 return resultobj;
21753 fail:
21754 return NULL;
21755 }
21756
21757
21758 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21759 PyObject *resultobj;
21760 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21761 long arg2 ;
21762 PyObject * obj0 = 0 ;
21763 PyObject * obj1 = 0 ;
21764 char *kwnames[] = {
21765 (char *) "self",(char *) "flags", NULL
21766 };
21767
21768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21770 if (SWIG_arg_fail(1)) SWIG_fail;
21771 {
21772 arg2 = (long)(SWIG_As_long(obj1));
21773 if (SWIG_arg_fail(2)) SWIG_fail;
21774 }
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 (arg1)->SetFlags(arg2);
21778
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 Py_INCREF(Py_None); resultobj = Py_None;
21783 return resultobj;
21784 fail:
21785 return NULL;
21786 }
21787
21788
21789 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21790 PyObject *resultobj;
21791 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21792 wxWindow *result;
21793 PyObject * obj0 = 0 ;
21794 char *kwnames[] = {
21795 (char *) "self", NULL
21796 };
21797
21798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21800 if (SWIG_arg_fail(1)) SWIG_fail;
21801 {
21802 PyThreadState* __tstate = wxPyBeginAllowThreads();
21803 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21804
21805 wxPyEndAllowThreads(__tstate);
21806 if (PyErr_Occurred()) SWIG_fail;
21807 }
21808 {
21809 resultobj = wxPyMake_wxObject(result, 0);
21810 }
21811 return resultobj;
21812 fail:
21813 return NULL;
21814 }
21815
21816
21817 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21818 PyObject *resultobj;
21819 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21820 wxWindow *arg2 = (wxWindow *) 0 ;
21821 PyObject * obj0 = 0 ;
21822 PyObject * obj1 = 0 ;
21823 char *kwnames[] = {
21824 (char *) "self",(char *) "win", NULL
21825 };
21826
21827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21829 if (SWIG_arg_fail(1)) SWIG_fail;
21830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21831 if (SWIG_arg_fail(2)) SWIG_fail;
21832 {
21833 PyThreadState* __tstate = wxPyBeginAllowThreads();
21834 (arg1)->SetCurrentFocus(arg2);
21835
21836 wxPyEndAllowThreads(__tstate);
21837 if (PyErr_Occurred()) SWIG_fail;
21838 }
21839 Py_INCREF(Py_None); resultobj = Py_None;
21840 return resultobj;
21841 fail:
21842 return NULL;
21843 }
21844
21845
21846 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21847 PyObject *obj;
21848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21849 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21850 Py_INCREF(obj);
21851 return Py_BuildValue((char *)"");
21852 }
21853 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21854 PyObject *resultobj;
21855 wxWindow *arg1 = (wxWindow *) NULL ;
21856 wxWindowCreateEvent *result;
21857 PyObject * obj0 = 0 ;
21858 char *kwnames[] = {
21859 (char *) "win", NULL
21860 };
21861
21862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21863 if (obj0) {
21864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21865 if (SWIG_arg_fail(1)) SWIG_fail;
21866 }
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21870
21871 wxPyEndAllowThreads(__tstate);
21872 if (PyErr_Occurred()) SWIG_fail;
21873 }
21874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21875 return resultobj;
21876 fail:
21877 return NULL;
21878 }
21879
21880
21881 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21882 PyObject *resultobj;
21883 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21884 wxWindow *result;
21885 PyObject * obj0 = 0 ;
21886 char *kwnames[] = {
21887 (char *) "self", NULL
21888 };
21889
21890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21892 if (SWIG_arg_fail(1)) SWIG_fail;
21893 {
21894 PyThreadState* __tstate = wxPyBeginAllowThreads();
21895 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21896
21897 wxPyEndAllowThreads(__tstate);
21898 if (PyErr_Occurred()) SWIG_fail;
21899 }
21900 {
21901 resultobj = wxPyMake_wxObject(result, 0);
21902 }
21903 return resultobj;
21904 fail:
21905 return NULL;
21906 }
21907
21908
21909 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21910 PyObject *obj;
21911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21912 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21913 Py_INCREF(obj);
21914 return Py_BuildValue((char *)"");
21915 }
21916 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj;
21918 wxWindow *arg1 = (wxWindow *) NULL ;
21919 wxWindowDestroyEvent *result;
21920 PyObject * obj0 = 0 ;
21921 char *kwnames[] = {
21922 (char *) "win", NULL
21923 };
21924
21925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21926 if (obj0) {
21927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21928 if (SWIG_arg_fail(1)) SWIG_fail;
21929 }
21930 {
21931 PyThreadState* __tstate = wxPyBeginAllowThreads();
21932 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21933
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21945 PyObject *resultobj;
21946 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21947 wxWindow *result;
21948 PyObject * obj0 = 0 ;
21949 char *kwnames[] = {
21950 (char *) "self", NULL
21951 };
21952
21953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21955 if (SWIG_arg_fail(1)) SWIG_fail;
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21959
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 {
21964 resultobj = wxPyMake_wxObject(result, 0);
21965 }
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21973 PyObject *obj;
21974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21975 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21976 Py_INCREF(obj);
21977 return Py_BuildValue((char *)"");
21978 }
21979 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21980 PyObject *resultobj;
21981 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21982 int arg2 = (int) 0 ;
21983 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21984 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21985 wxContextMenuEvent *result;
21986 wxPoint temp3 ;
21987 PyObject * obj0 = 0 ;
21988 PyObject * obj1 = 0 ;
21989 PyObject * obj2 = 0 ;
21990 char *kwnames[] = {
21991 (char *) "type",(char *) "winid",(char *) "pt", NULL
21992 };
21993
21994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21995 if (obj0) {
21996 {
21997 arg1 = (wxEventType)(SWIG_As_int(obj0));
21998 if (SWIG_arg_fail(1)) SWIG_fail;
21999 }
22000 }
22001 if (obj1) {
22002 {
22003 arg2 = (int)(SWIG_As_int(obj1));
22004 if (SWIG_arg_fail(2)) SWIG_fail;
22005 }
22006 }
22007 if (obj2) {
22008 {
22009 arg3 = &temp3;
22010 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22011 }
22012 }
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22016
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22028 PyObject *resultobj;
22029 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22030 wxPoint *result;
22031 PyObject * obj0 = 0 ;
22032 char *kwnames[] = {
22033 (char *) "self", NULL
22034 };
22035
22036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22038 if (SWIG_arg_fail(1)) SWIG_fail;
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 {
22042 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22043 result = (wxPoint *) &_result_ref;
22044 }
22045
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22050 return resultobj;
22051 fail:
22052 return NULL;
22053 }
22054
22055
22056 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22057 PyObject *resultobj;
22058 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22059 wxPoint *arg2 = 0 ;
22060 wxPoint temp2 ;
22061 PyObject * obj0 = 0 ;
22062 PyObject * obj1 = 0 ;
22063 char *kwnames[] = {
22064 (char *) "self",(char *) "pos", NULL
22065 };
22066
22067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22069 if (SWIG_arg_fail(1)) SWIG_fail;
22070 {
22071 arg2 = &temp2;
22072 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22073 }
22074 {
22075 PyThreadState* __tstate = wxPyBeginAllowThreads();
22076 (arg1)->SetPosition((wxPoint const &)*arg2);
22077
22078 wxPyEndAllowThreads(__tstate);
22079 if (PyErr_Occurred()) SWIG_fail;
22080 }
22081 Py_INCREF(Py_None); resultobj = Py_None;
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22089 PyObject *obj;
22090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22091 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22092 Py_INCREF(obj);
22093 return Py_BuildValue((char *)"");
22094 }
22095 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22096 PyObject *resultobj;
22097 wxIdleEvent *result;
22098 char *kwnames[] = {
22099 NULL
22100 };
22101
22102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22103 {
22104 PyThreadState* __tstate = wxPyBeginAllowThreads();
22105 result = (wxIdleEvent *)new wxIdleEvent();
22106
22107 wxPyEndAllowThreads(__tstate);
22108 if (PyErr_Occurred()) SWIG_fail;
22109 }
22110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22118 PyObject *resultobj;
22119 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22120 bool arg2 = (bool) true ;
22121 PyObject * obj0 = 0 ;
22122 PyObject * obj1 = 0 ;
22123 char *kwnames[] = {
22124 (char *) "self",(char *) "needMore", NULL
22125 };
22126
22127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22129 if (SWIG_arg_fail(1)) SWIG_fail;
22130 if (obj1) {
22131 {
22132 arg2 = (bool)(SWIG_As_bool(obj1));
22133 if (SWIG_arg_fail(2)) SWIG_fail;
22134 }
22135 }
22136 {
22137 PyThreadState* __tstate = wxPyBeginAllowThreads();
22138 (arg1)->RequestMore(arg2);
22139
22140 wxPyEndAllowThreads(__tstate);
22141 if (PyErr_Occurred()) SWIG_fail;
22142 }
22143 Py_INCREF(Py_None); resultobj = Py_None;
22144 return resultobj;
22145 fail:
22146 return NULL;
22147 }
22148
22149
22150 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22151 PyObject *resultobj;
22152 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22153 bool result;
22154 PyObject * obj0 = 0 ;
22155 char *kwnames[] = {
22156 (char *) "self", NULL
22157 };
22158
22159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22161 if (SWIG_arg_fail(1)) SWIG_fail;
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22165
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 {
22170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22171 }
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj;
22180 wxIdleMode arg1 ;
22181 PyObject * obj0 = 0 ;
22182 char *kwnames[] = {
22183 (char *) "mode", NULL
22184 };
22185
22186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22187 {
22188 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22189 if (SWIG_arg_fail(1)) SWIG_fail;
22190 }
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 wxIdleEvent::SetMode((wxIdleMode )arg1);
22194
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 Py_INCREF(Py_None); resultobj = Py_None;
22199 return resultobj;
22200 fail:
22201 return NULL;
22202 }
22203
22204
22205 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22206 PyObject *resultobj;
22207 wxIdleMode result;
22208 char *kwnames[] = {
22209 NULL
22210 };
22211
22212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22213 {
22214 PyThreadState* __tstate = wxPyBeginAllowThreads();
22215 result = (wxIdleMode)wxIdleEvent::GetMode();
22216
22217 wxPyEndAllowThreads(__tstate);
22218 if (PyErr_Occurred()) SWIG_fail;
22219 }
22220 resultobj = SWIG_From_int((result));
22221 return resultobj;
22222 fail:
22223 return NULL;
22224 }
22225
22226
22227 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22228 PyObject *resultobj;
22229 wxWindow *arg1 = (wxWindow *) 0 ;
22230 bool result;
22231 PyObject * obj0 = 0 ;
22232 char *kwnames[] = {
22233 (char *) "win", NULL
22234 };
22235
22236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22238 if (SWIG_arg_fail(1)) SWIG_fail;
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 result = (bool)wxIdleEvent::CanSend(arg1);
22242
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 {
22247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22248 }
22249 return resultobj;
22250 fail:
22251 return NULL;
22252 }
22253
22254
22255 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22256 PyObject *obj;
22257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22258 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22259 Py_INCREF(obj);
22260 return Py_BuildValue((char *)"");
22261 }
22262 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22263 PyObject *resultobj;
22264 int arg1 = (int) 0 ;
22265 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22266 wxPyEvent *result;
22267 PyObject * obj0 = 0 ;
22268 PyObject * obj1 = 0 ;
22269 char *kwnames[] = {
22270 (char *) "winid",(char *) "eventType", NULL
22271 };
22272
22273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22274 if (obj0) {
22275 {
22276 arg1 = (int)(SWIG_As_int(obj0));
22277 if (SWIG_arg_fail(1)) SWIG_fail;
22278 }
22279 }
22280 if (obj1) {
22281 {
22282 arg2 = (wxEventType)(SWIG_As_int(obj1));
22283 if (SWIG_arg_fail(2)) SWIG_fail;
22284 }
22285 }
22286 {
22287 PyThreadState* __tstate = wxPyBeginAllowThreads();
22288 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22289
22290 wxPyEndAllowThreads(__tstate);
22291 if (PyErr_Occurred()) SWIG_fail;
22292 }
22293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22294 return resultobj;
22295 fail:
22296 return NULL;
22297 }
22298
22299
22300 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22301 PyObject *resultobj;
22302 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22303 PyObject * obj0 = 0 ;
22304 char *kwnames[] = {
22305 (char *) "self", NULL
22306 };
22307
22308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22310 if (SWIG_arg_fail(1)) SWIG_fail;
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 delete arg1;
22314
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 Py_INCREF(Py_None); resultobj = Py_None;
22319 return resultobj;
22320 fail:
22321 return NULL;
22322 }
22323
22324
22325 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22326 PyObject *resultobj;
22327 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22328 PyObject *arg2 = (PyObject *) 0 ;
22329 PyObject * obj0 = 0 ;
22330 PyObject * obj1 = 0 ;
22331 char *kwnames[] = {
22332 (char *) "self",(char *) "self", NULL
22333 };
22334
22335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22337 if (SWIG_arg_fail(1)) SWIG_fail;
22338 arg2 = obj1;
22339 {
22340 PyThreadState* __tstate = wxPyBeginAllowThreads();
22341 (arg1)->SetSelf(arg2);
22342
22343 wxPyEndAllowThreads(__tstate);
22344 if (PyErr_Occurred()) SWIG_fail;
22345 }
22346 Py_INCREF(Py_None); resultobj = Py_None;
22347 return resultobj;
22348 fail:
22349 return NULL;
22350 }
22351
22352
22353 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22354 PyObject *resultobj;
22355 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22356 PyObject *result;
22357 PyObject * obj0 = 0 ;
22358 char *kwnames[] = {
22359 (char *) "self", NULL
22360 };
22361
22362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22364 if (SWIG_arg_fail(1)) SWIG_fail;
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 result = (PyObject *)(arg1)->GetSelf();
22368
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 resultobj = result;
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22380 PyObject *obj;
22381 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22382 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22383 Py_INCREF(obj);
22384 return Py_BuildValue((char *)"");
22385 }
22386 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22387 PyObject *resultobj;
22388 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22389 int arg2 = (int) 0 ;
22390 wxPyCommandEvent *result;
22391 PyObject * obj0 = 0 ;
22392 PyObject * obj1 = 0 ;
22393 char *kwnames[] = {
22394 (char *) "eventType",(char *) "id", NULL
22395 };
22396
22397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22398 if (obj0) {
22399 {
22400 arg1 = (wxEventType)(SWIG_As_int(obj0));
22401 if (SWIG_arg_fail(1)) SWIG_fail;
22402 }
22403 }
22404 if (obj1) {
22405 {
22406 arg2 = (int)(SWIG_As_int(obj1));
22407 if (SWIG_arg_fail(2)) SWIG_fail;
22408 }
22409 }
22410 {
22411 PyThreadState* __tstate = wxPyBeginAllowThreads();
22412 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22413
22414 wxPyEndAllowThreads(__tstate);
22415 if (PyErr_Occurred()) SWIG_fail;
22416 }
22417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22418 return resultobj;
22419 fail:
22420 return NULL;
22421 }
22422
22423
22424 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22425 PyObject *resultobj;
22426 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22427 PyObject * obj0 = 0 ;
22428 char *kwnames[] = {
22429 (char *) "self", NULL
22430 };
22431
22432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22434 if (SWIG_arg_fail(1)) SWIG_fail;
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 delete arg1;
22438
22439 wxPyEndAllowThreads(__tstate);
22440 if (PyErr_Occurred()) SWIG_fail;
22441 }
22442 Py_INCREF(Py_None); resultobj = Py_None;
22443 return resultobj;
22444 fail:
22445 return NULL;
22446 }
22447
22448
22449 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22450 PyObject *resultobj;
22451 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22452 PyObject *arg2 = (PyObject *) 0 ;
22453 PyObject * obj0 = 0 ;
22454 PyObject * obj1 = 0 ;
22455 char *kwnames[] = {
22456 (char *) "self",(char *) "self", NULL
22457 };
22458
22459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22461 if (SWIG_arg_fail(1)) SWIG_fail;
22462 arg2 = obj1;
22463 {
22464 PyThreadState* __tstate = wxPyBeginAllowThreads();
22465 (arg1)->SetSelf(arg2);
22466
22467 wxPyEndAllowThreads(__tstate);
22468 if (PyErr_Occurred()) SWIG_fail;
22469 }
22470 Py_INCREF(Py_None); resultobj = Py_None;
22471 return resultobj;
22472 fail:
22473 return NULL;
22474 }
22475
22476
22477 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22478 PyObject *resultobj;
22479 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22480 PyObject *result;
22481 PyObject * obj0 = 0 ;
22482 char *kwnames[] = {
22483 (char *) "self", NULL
22484 };
22485
22486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
22487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22488 if (SWIG_arg_fail(1)) SWIG_fail;
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 result = (PyObject *)(arg1)->GetSelf();
22492
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 resultobj = result;
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22504 PyObject *obj;
22505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22506 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22507 Py_INCREF(obj);
22508 return Py_BuildValue((char *)"");
22509 }
22510 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22511 PyObject *resultobj;
22512 wxWindow *arg1 = (wxWindow *) 0 ;
22513 wxDateTime *arg2 = 0 ;
22514 wxEventType arg3 ;
22515 wxDateEvent *result;
22516 PyObject * obj0 = 0 ;
22517 PyObject * obj1 = 0 ;
22518 PyObject * obj2 = 0 ;
22519 char *kwnames[] = {
22520 (char *) "win",(char *) "dt",(char *) "type", NULL
22521 };
22522
22523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22525 if (SWIG_arg_fail(1)) SWIG_fail;
22526 {
22527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22528 if (SWIG_arg_fail(2)) SWIG_fail;
22529 if (arg2 == NULL) {
22530 SWIG_null_ref("wxDateTime");
22531 }
22532 if (SWIG_arg_fail(2)) SWIG_fail;
22533 }
22534 {
22535 arg3 = (wxEventType)(SWIG_As_int(obj2));
22536 if (SWIG_arg_fail(3)) SWIG_fail;
22537 }
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22541
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22553 PyObject *resultobj;
22554 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22555 wxDateTime *result;
22556 PyObject * obj0 = 0 ;
22557 char *kwnames[] = {
22558 (char *) "self", NULL
22559 };
22560
22561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22563 if (SWIG_arg_fail(1)) SWIG_fail;
22564 {
22565 PyThreadState* __tstate = wxPyBeginAllowThreads();
22566 {
22567 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22568 result = (wxDateTime *) &_result_ref;
22569 }
22570
22571 wxPyEndAllowThreads(__tstate);
22572 if (PyErr_Occurred()) SWIG_fail;
22573 }
22574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22582 PyObject *resultobj;
22583 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22584 wxDateTime *arg2 = 0 ;
22585 PyObject * obj0 = 0 ;
22586 PyObject * obj1 = 0 ;
22587 char *kwnames[] = {
22588 (char *) "self",(char *) "date", NULL
22589 };
22590
22591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22593 if (SWIG_arg_fail(1)) SWIG_fail;
22594 {
22595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22596 if (SWIG_arg_fail(2)) SWIG_fail;
22597 if (arg2 == NULL) {
22598 SWIG_null_ref("wxDateTime");
22599 }
22600 if (SWIG_arg_fail(2)) SWIG_fail;
22601 }
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 (arg1)->SetDate((wxDateTime const &)*arg2);
22605
22606 wxPyEndAllowThreads(__tstate);
22607 if (PyErr_Occurred()) SWIG_fail;
22608 }
22609 Py_INCREF(Py_None); resultobj = Py_None;
22610 return resultobj;
22611 fail:
22612 return NULL;
22613 }
22614
22615
22616 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22617 PyObject *obj;
22618 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22619 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22620 Py_INCREF(obj);
22621 return Py_BuildValue((char *)"");
22622 }
22623 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22624 PyObject *resultobj;
22625 wxPyApp *result;
22626 char *kwnames[] = {
22627 NULL
22628 };
22629
22630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = (wxPyApp *)new_wxPyApp();
22634
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22639 return resultobj;
22640 fail:
22641 return NULL;
22642 }
22643
22644
22645 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22646 PyObject *resultobj;
22647 wxPyApp *arg1 = (wxPyApp *) 0 ;
22648 PyObject * obj0 = 0 ;
22649 char *kwnames[] = {
22650 (char *) "self", NULL
22651 };
22652
22653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22655 if (SWIG_arg_fail(1)) SWIG_fail;
22656 {
22657 PyThreadState* __tstate = wxPyBeginAllowThreads();
22658 delete arg1;
22659
22660 wxPyEndAllowThreads(__tstate);
22661 if (PyErr_Occurred()) SWIG_fail;
22662 }
22663 Py_INCREF(Py_None); resultobj = Py_None;
22664 return resultobj;
22665 fail:
22666 return NULL;
22667 }
22668
22669
22670 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22671 PyObject *resultobj;
22672 wxPyApp *arg1 = (wxPyApp *) 0 ;
22673 PyObject *arg2 = (PyObject *) 0 ;
22674 PyObject *arg3 = (PyObject *) 0 ;
22675 bool arg4 ;
22676 PyObject * obj0 = 0 ;
22677 PyObject * obj1 = 0 ;
22678 PyObject * obj2 = 0 ;
22679 PyObject * obj3 = 0 ;
22680 char *kwnames[] = {
22681 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22682 };
22683
22684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22686 if (SWIG_arg_fail(1)) SWIG_fail;
22687 arg2 = obj1;
22688 arg3 = obj2;
22689 {
22690 arg4 = (bool)(SWIG_As_bool(obj3));
22691 if (SWIG_arg_fail(4)) SWIG_fail;
22692 }
22693 {
22694 PyThreadState* __tstate = wxPyBeginAllowThreads();
22695 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22696
22697 wxPyEndAllowThreads(__tstate);
22698 if (PyErr_Occurred()) SWIG_fail;
22699 }
22700 Py_INCREF(Py_None); resultobj = Py_None;
22701 return resultobj;
22702 fail:
22703 return NULL;
22704 }
22705
22706
22707 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22708 PyObject *resultobj;
22709 wxPyApp *arg1 = (wxPyApp *) 0 ;
22710 wxString result;
22711 PyObject * obj0 = 0 ;
22712 char *kwnames[] = {
22713 (char *) "self", NULL
22714 };
22715
22716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22718 if (SWIG_arg_fail(1)) SWIG_fail;
22719 {
22720 PyThreadState* __tstate = wxPyBeginAllowThreads();
22721 result = ((wxPyApp const *)arg1)->GetAppName();
22722
22723 wxPyEndAllowThreads(__tstate);
22724 if (PyErr_Occurred()) SWIG_fail;
22725 }
22726 {
22727 #if wxUSE_UNICODE
22728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22729 #else
22730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22731 #endif
22732 }
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22740 PyObject *resultobj;
22741 wxPyApp *arg1 = (wxPyApp *) 0 ;
22742 wxString *arg2 = 0 ;
22743 bool temp2 = false ;
22744 PyObject * obj0 = 0 ;
22745 PyObject * obj1 = 0 ;
22746 char *kwnames[] = {
22747 (char *) "self",(char *) "name", NULL
22748 };
22749
22750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22752 if (SWIG_arg_fail(1)) SWIG_fail;
22753 {
22754 arg2 = wxString_in_helper(obj1);
22755 if (arg2 == NULL) SWIG_fail;
22756 temp2 = true;
22757 }
22758 {
22759 PyThreadState* __tstate = wxPyBeginAllowThreads();
22760 (arg1)->SetAppName((wxString const &)*arg2);
22761
22762 wxPyEndAllowThreads(__tstate);
22763 if (PyErr_Occurred()) SWIG_fail;
22764 }
22765 Py_INCREF(Py_None); resultobj = Py_None;
22766 {
22767 if (temp2)
22768 delete arg2;
22769 }
22770 return resultobj;
22771 fail:
22772 {
22773 if (temp2)
22774 delete arg2;
22775 }
22776 return NULL;
22777 }
22778
22779
22780 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22781 PyObject *resultobj;
22782 wxPyApp *arg1 = (wxPyApp *) 0 ;
22783 wxString result;
22784 PyObject * obj0 = 0 ;
22785 char *kwnames[] = {
22786 (char *) "self", NULL
22787 };
22788
22789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22791 if (SWIG_arg_fail(1)) SWIG_fail;
22792 {
22793 PyThreadState* __tstate = wxPyBeginAllowThreads();
22794 result = ((wxPyApp const *)arg1)->GetClassName();
22795
22796 wxPyEndAllowThreads(__tstate);
22797 if (PyErr_Occurred()) SWIG_fail;
22798 }
22799 {
22800 #if wxUSE_UNICODE
22801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22802 #else
22803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22804 #endif
22805 }
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22813 PyObject *resultobj;
22814 wxPyApp *arg1 = (wxPyApp *) 0 ;
22815 wxString *arg2 = 0 ;
22816 bool temp2 = false ;
22817 PyObject * obj0 = 0 ;
22818 PyObject * obj1 = 0 ;
22819 char *kwnames[] = {
22820 (char *) "self",(char *) "name", NULL
22821 };
22822
22823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22825 if (SWIG_arg_fail(1)) SWIG_fail;
22826 {
22827 arg2 = wxString_in_helper(obj1);
22828 if (arg2 == NULL) SWIG_fail;
22829 temp2 = true;
22830 }
22831 {
22832 PyThreadState* __tstate = wxPyBeginAllowThreads();
22833 (arg1)->SetClassName((wxString const &)*arg2);
22834
22835 wxPyEndAllowThreads(__tstate);
22836 if (PyErr_Occurred()) SWIG_fail;
22837 }
22838 Py_INCREF(Py_None); resultobj = Py_None;
22839 {
22840 if (temp2)
22841 delete arg2;
22842 }
22843 return resultobj;
22844 fail:
22845 {
22846 if (temp2)
22847 delete arg2;
22848 }
22849 return NULL;
22850 }
22851
22852
22853 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22854 PyObject *resultobj;
22855 wxPyApp *arg1 = (wxPyApp *) 0 ;
22856 wxString *result;
22857 PyObject * obj0 = 0 ;
22858 char *kwnames[] = {
22859 (char *) "self", NULL
22860 };
22861
22862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22864 if (SWIG_arg_fail(1)) SWIG_fail;
22865 {
22866 PyThreadState* __tstate = wxPyBeginAllowThreads();
22867 {
22868 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22869 result = (wxString *) &_result_ref;
22870 }
22871
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 {
22876 #if wxUSE_UNICODE
22877 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22878 #else
22879 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22880 #endif
22881 }
22882 return resultobj;
22883 fail:
22884 return NULL;
22885 }
22886
22887
22888 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22889 PyObject *resultobj;
22890 wxPyApp *arg1 = (wxPyApp *) 0 ;
22891 wxString *arg2 = 0 ;
22892 bool temp2 = false ;
22893 PyObject * obj0 = 0 ;
22894 PyObject * obj1 = 0 ;
22895 char *kwnames[] = {
22896 (char *) "self",(char *) "name", NULL
22897 };
22898
22899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22901 if (SWIG_arg_fail(1)) SWIG_fail;
22902 {
22903 arg2 = wxString_in_helper(obj1);
22904 if (arg2 == NULL) SWIG_fail;
22905 temp2 = true;
22906 }
22907 {
22908 PyThreadState* __tstate = wxPyBeginAllowThreads();
22909 (arg1)->SetVendorName((wxString const &)*arg2);
22910
22911 wxPyEndAllowThreads(__tstate);
22912 if (PyErr_Occurred()) SWIG_fail;
22913 }
22914 Py_INCREF(Py_None); resultobj = Py_None;
22915 {
22916 if (temp2)
22917 delete arg2;
22918 }
22919 return resultobj;
22920 fail:
22921 {
22922 if (temp2)
22923 delete arg2;
22924 }
22925 return NULL;
22926 }
22927
22928
22929 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22930 PyObject *resultobj;
22931 wxPyApp *arg1 = (wxPyApp *) 0 ;
22932 wxAppTraits *result;
22933 PyObject * obj0 = 0 ;
22934 char *kwnames[] = {
22935 (char *) "self", NULL
22936 };
22937
22938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22940 if (SWIG_arg_fail(1)) SWIG_fail;
22941 {
22942 PyThreadState* __tstate = wxPyBeginAllowThreads();
22943 result = (wxAppTraits *)(arg1)->GetTraits();
22944
22945 wxPyEndAllowThreads(__tstate);
22946 if (PyErr_Occurred()) SWIG_fail;
22947 }
22948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22949 return resultobj;
22950 fail:
22951 return NULL;
22952 }
22953
22954
22955 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22956 PyObject *resultobj;
22957 wxPyApp *arg1 = (wxPyApp *) 0 ;
22958 PyObject * obj0 = 0 ;
22959 char *kwnames[] = {
22960 (char *) "self", NULL
22961 };
22962
22963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22965 if (SWIG_arg_fail(1)) SWIG_fail;
22966 {
22967 PyThreadState* __tstate = wxPyBeginAllowThreads();
22968 (arg1)->ProcessPendingEvents();
22969
22970 wxPyEndAllowThreads(__tstate);
22971 if (PyErr_Occurred()) SWIG_fail;
22972 }
22973 Py_INCREF(Py_None); resultobj = Py_None;
22974 return resultobj;
22975 fail:
22976 return NULL;
22977 }
22978
22979
22980 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22981 PyObject *resultobj;
22982 wxPyApp *arg1 = (wxPyApp *) 0 ;
22983 bool arg2 = (bool) false ;
22984 bool result;
22985 PyObject * obj0 = 0 ;
22986 PyObject * obj1 = 0 ;
22987 char *kwnames[] = {
22988 (char *) "self",(char *) "onlyIfNeeded", NULL
22989 };
22990
22991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22993 if (SWIG_arg_fail(1)) SWIG_fail;
22994 if (obj1) {
22995 {
22996 arg2 = (bool)(SWIG_As_bool(obj1));
22997 if (SWIG_arg_fail(2)) SWIG_fail;
22998 }
22999 }
23000 {
23001 PyThreadState* __tstate = wxPyBeginAllowThreads();
23002 result = (bool)(arg1)->Yield(arg2);
23003
23004 wxPyEndAllowThreads(__tstate);
23005 if (PyErr_Occurred()) SWIG_fail;
23006 }
23007 {
23008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23009 }
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23017 PyObject *resultobj;
23018 wxPyApp *arg1 = (wxPyApp *) 0 ;
23019 PyObject * obj0 = 0 ;
23020 char *kwnames[] = {
23021 (char *) "self", NULL
23022 };
23023
23024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23026 if (SWIG_arg_fail(1)) SWIG_fail;
23027 {
23028 PyThreadState* __tstate = wxPyBeginAllowThreads();
23029 (arg1)->WakeUpIdle();
23030
23031 wxPyEndAllowThreads(__tstate);
23032 if (PyErr_Occurred()) SWIG_fail;
23033 }
23034 Py_INCREF(Py_None); resultobj = Py_None;
23035 return resultobj;
23036 fail:
23037 return NULL;
23038 }
23039
23040
23041 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23042 PyObject *resultobj;
23043 bool result;
23044 char *kwnames[] = {
23045 NULL
23046 };
23047
23048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 result = (bool)wxPyApp::IsMainLoopRunning();
23052
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 {
23057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23058 }
23059 return resultobj;
23060 fail:
23061 return NULL;
23062 }
23063
23064
23065 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23066 PyObject *resultobj;
23067 wxPyApp *arg1 = (wxPyApp *) 0 ;
23068 int result;
23069 PyObject * obj0 = 0 ;
23070 char *kwnames[] = {
23071 (char *) "self", NULL
23072 };
23073
23074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23076 if (SWIG_arg_fail(1)) SWIG_fail;
23077 {
23078 PyThreadState* __tstate = wxPyBeginAllowThreads();
23079 result = (int)(arg1)->MainLoop();
23080
23081 wxPyEndAllowThreads(__tstate);
23082 if (PyErr_Occurred()) SWIG_fail;
23083 }
23084 {
23085 resultobj = SWIG_From_int((int)(result));
23086 }
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj;
23095 wxPyApp *arg1 = (wxPyApp *) 0 ;
23096 PyObject * obj0 = 0 ;
23097 char *kwnames[] = {
23098 (char *) "self", NULL
23099 };
23100
23101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23103 if (SWIG_arg_fail(1)) SWIG_fail;
23104 {
23105 PyThreadState* __tstate = wxPyBeginAllowThreads();
23106 (arg1)->Exit();
23107
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 Py_INCREF(Py_None); resultobj = Py_None;
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23119 PyObject *resultobj;
23120 wxPyApp *arg1 = (wxPyApp *) 0 ;
23121 PyObject * obj0 = 0 ;
23122 char *kwnames[] = {
23123 (char *) "self", NULL
23124 };
23125
23126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23128 if (SWIG_arg_fail(1)) SWIG_fail;
23129 {
23130 PyThreadState* __tstate = wxPyBeginAllowThreads();
23131 (arg1)->ExitMainLoop();
23132
23133 wxPyEndAllowThreads(__tstate);
23134 if (PyErr_Occurred()) SWIG_fail;
23135 }
23136 Py_INCREF(Py_None); resultobj = Py_None;
23137 return resultobj;
23138 fail:
23139 return NULL;
23140 }
23141
23142
23143 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23144 PyObject *resultobj;
23145 wxPyApp *arg1 = (wxPyApp *) 0 ;
23146 bool result;
23147 PyObject * obj0 = 0 ;
23148 char *kwnames[] = {
23149 (char *) "self", NULL
23150 };
23151
23152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23154 if (SWIG_arg_fail(1)) SWIG_fail;
23155 {
23156 PyThreadState* __tstate = wxPyBeginAllowThreads();
23157 result = (bool)(arg1)->Pending();
23158
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 {
23163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23164 }
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23172 PyObject *resultobj;
23173 wxPyApp *arg1 = (wxPyApp *) 0 ;
23174 bool result;
23175 PyObject * obj0 = 0 ;
23176 char *kwnames[] = {
23177 (char *) "self", NULL
23178 };
23179
23180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23182 if (SWIG_arg_fail(1)) SWIG_fail;
23183 {
23184 PyThreadState* __tstate = wxPyBeginAllowThreads();
23185 result = (bool)(arg1)->Dispatch();
23186
23187 wxPyEndAllowThreads(__tstate);
23188 if (PyErr_Occurred()) SWIG_fail;
23189 }
23190 {
23191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23192 }
23193 return resultobj;
23194 fail:
23195 return NULL;
23196 }
23197
23198
23199 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23200 PyObject *resultobj;
23201 wxPyApp *arg1 = (wxPyApp *) 0 ;
23202 bool result;
23203 PyObject * obj0 = 0 ;
23204 char *kwnames[] = {
23205 (char *) "self", NULL
23206 };
23207
23208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23210 if (SWIG_arg_fail(1)) SWIG_fail;
23211 {
23212 PyThreadState* __tstate = wxPyBeginAllowThreads();
23213 result = (bool)(arg1)->ProcessIdle();
23214
23215 wxPyEndAllowThreads(__tstate);
23216 if (PyErr_Occurred()) SWIG_fail;
23217 }
23218 {
23219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23220 }
23221 return resultobj;
23222 fail:
23223 return NULL;
23224 }
23225
23226
23227 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23228 PyObject *resultobj;
23229 wxPyApp *arg1 = (wxPyApp *) 0 ;
23230 wxWindow *arg2 = (wxWindow *) 0 ;
23231 wxIdleEvent *arg3 = 0 ;
23232 bool result;
23233 PyObject * obj0 = 0 ;
23234 PyObject * obj1 = 0 ;
23235 PyObject * obj2 = 0 ;
23236 char *kwnames[] = {
23237 (char *) "self",(char *) "win",(char *) "event", NULL
23238 };
23239
23240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23242 if (SWIG_arg_fail(1)) SWIG_fail;
23243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23244 if (SWIG_arg_fail(2)) SWIG_fail;
23245 {
23246 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23247 if (SWIG_arg_fail(3)) SWIG_fail;
23248 if (arg3 == NULL) {
23249 SWIG_null_ref("wxIdleEvent");
23250 }
23251 if (SWIG_arg_fail(3)) SWIG_fail;
23252 }
23253 {
23254 PyThreadState* __tstate = wxPyBeginAllowThreads();
23255 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23256
23257 wxPyEndAllowThreads(__tstate);
23258 if (PyErr_Occurred()) SWIG_fail;
23259 }
23260 {
23261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23262 }
23263 return resultobj;
23264 fail:
23265 return NULL;
23266 }
23267
23268
23269 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23270 PyObject *resultobj;
23271 wxPyApp *arg1 = (wxPyApp *) 0 ;
23272 bool result;
23273 PyObject * obj0 = 0 ;
23274 char *kwnames[] = {
23275 (char *) "self", NULL
23276 };
23277
23278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23280 if (SWIG_arg_fail(1)) SWIG_fail;
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 result = (bool)((wxPyApp const *)arg1)->IsActive();
23284
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 {
23289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23290 }
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj;
23299 wxPyApp *arg1 = (wxPyApp *) 0 ;
23300 wxWindow *arg2 = (wxWindow *) 0 ;
23301 PyObject * obj0 = 0 ;
23302 PyObject * obj1 = 0 ;
23303 char *kwnames[] = {
23304 (char *) "self",(char *) "win", NULL
23305 };
23306
23307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23309 if (SWIG_arg_fail(1)) SWIG_fail;
23310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23311 if (SWIG_arg_fail(2)) SWIG_fail;
23312 {
23313 PyThreadState* __tstate = wxPyBeginAllowThreads();
23314 (arg1)->SetTopWindow(arg2);
23315
23316 wxPyEndAllowThreads(__tstate);
23317 if (PyErr_Occurred()) SWIG_fail;
23318 }
23319 Py_INCREF(Py_None); resultobj = Py_None;
23320 return resultobj;
23321 fail:
23322 return NULL;
23323 }
23324
23325
23326 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23327 PyObject *resultobj;
23328 wxPyApp *arg1 = (wxPyApp *) 0 ;
23329 wxWindow *result;
23330 PyObject * obj0 = 0 ;
23331 char *kwnames[] = {
23332 (char *) "self", NULL
23333 };
23334
23335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23337 if (SWIG_arg_fail(1)) SWIG_fail;
23338 {
23339 PyThreadState* __tstate = wxPyBeginAllowThreads();
23340 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23341
23342 wxPyEndAllowThreads(__tstate);
23343 if (PyErr_Occurred()) SWIG_fail;
23344 }
23345 {
23346 resultobj = wxPyMake_wxObject(result, 0);
23347 }
23348 return resultobj;
23349 fail:
23350 return NULL;
23351 }
23352
23353
23354 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23355 PyObject *resultobj;
23356 wxPyApp *arg1 = (wxPyApp *) 0 ;
23357 bool arg2 ;
23358 PyObject * obj0 = 0 ;
23359 PyObject * obj1 = 0 ;
23360 char *kwnames[] = {
23361 (char *) "self",(char *) "flag", NULL
23362 };
23363
23364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23366 if (SWIG_arg_fail(1)) SWIG_fail;
23367 {
23368 arg2 = (bool)(SWIG_As_bool(obj1));
23369 if (SWIG_arg_fail(2)) SWIG_fail;
23370 }
23371 {
23372 PyThreadState* __tstate = wxPyBeginAllowThreads();
23373 (arg1)->SetExitOnFrameDelete(arg2);
23374
23375 wxPyEndAllowThreads(__tstate);
23376 if (PyErr_Occurred()) SWIG_fail;
23377 }
23378 Py_INCREF(Py_None); resultobj = Py_None;
23379 return resultobj;
23380 fail:
23381 return NULL;
23382 }
23383
23384
23385 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23386 PyObject *resultobj;
23387 wxPyApp *arg1 = (wxPyApp *) 0 ;
23388 bool result;
23389 PyObject * obj0 = 0 ;
23390 char *kwnames[] = {
23391 (char *) "self", NULL
23392 };
23393
23394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23396 if (SWIG_arg_fail(1)) SWIG_fail;
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23400
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 {
23405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23406 }
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23414 PyObject *resultobj;
23415 wxPyApp *arg1 = (wxPyApp *) 0 ;
23416 bool arg2 ;
23417 PyObject * obj0 = 0 ;
23418 PyObject * obj1 = 0 ;
23419 char *kwnames[] = {
23420 (char *) "self",(char *) "flag", NULL
23421 };
23422
23423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23425 if (SWIG_arg_fail(1)) SWIG_fail;
23426 {
23427 arg2 = (bool)(SWIG_As_bool(obj1));
23428 if (SWIG_arg_fail(2)) SWIG_fail;
23429 }
23430 {
23431 PyThreadState* __tstate = wxPyBeginAllowThreads();
23432 (arg1)->SetUseBestVisual(arg2);
23433
23434 wxPyEndAllowThreads(__tstate);
23435 if (PyErr_Occurred()) SWIG_fail;
23436 }
23437 Py_INCREF(Py_None); resultobj = Py_None;
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj;
23446 wxPyApp *arg1 = (wxPyApp *) 0 ;
23447 bool result;
23448 PyObject * obj0 = 0 ;
23449 char *kwnames[] = {
23450 (char *) "self", NULL
23451 };
23452
23453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23455 if (SWIG_arg_fail(1)) SWIG_fail;
23456 {
23457 PyThreadState* __tstate = wxPyBeginAllowThreads();
23458 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23459
23460 wxPyEndAllowThreads(__tstate);
23461 if (PyErr_Occurred()) SWIG_fail;
23462 }
23463 {
23464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23465 }
23466 return resultobj;
23467 fail:
23468 return NULL;
23469 }
23470
23471
23472 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23473 PyObject *resultobj;
23474 wxPyApp *arg1 = (wxPyApp *) 0 ;
23475 int arg2 ;
23476 PyObject * obj0 = 0 ;
23477 PyObject * obj1 = 0 ;
23478 char *kwnames[] = {
23479 (char *) "self",(char *) "mode", NULL
23480 };
23481
23482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23484 if (SWIG_arg_fail(1)) SWIG_fail;
23485 {
23486 arg2 = (int)(SWIG_As_int(obj1));
23487 if (SWIG_arg_fail(2)) SWIG_fail;
23488 }
23489 {
23490 PyThreadState* __tstate = wxPyBeginAllowThreads();
23491 (arg1)->SetPrintMode(arg2);
23492
23493 wxPyEndAllowThreads(__tstate);
23494 if (PyErr_Occurred()) SWIG_fail;
23495 }
23496 Py_INCREF(Py_None); resultobj = Py_None;
23497 return resultobj;
23498 fail:
23499 return NULL;
23500 }
23501
23502
23503 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23504 PyObject *resultobj;
23505 wxPyApp *arg1 = (wxPyApp *) 0 ;
23506 int result;
23507 PyObject * obj0 = 0 ;
23508 char *kwnames[] = {
23509 (char *) "self", NULL
23510 };
23511
23512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23514 if (SWIG_arg_fail(1)) SWIG_fail;
23515 {
23516 PyThreadState* __tstate = wxPyBeginAllowThreads();
23517 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23518
23519 wxPyEndAllowThreads(__tstate);
23520 if (PyErr_Occurred()) SWIG_fail;
23521 }
23522 {
23523 resultobj = SWIG_From_int((int)(result));
23524 }
23525 return resultobj;
23526 fail:
23527 return NULL;
23528 }
23529
23530
23531 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23532 PyObject *resultobj;
23533 wxPyApp *arg1 = (wxPyApp *) 0 ;
23534 int arg2 ;
23535 PyObject * obj0 = 0 ;
23536 PyObject * obj1 = 0 ;
23537 char *kwnames[] = {
23538 (char *) "self",(char *) "mode", NULL
23539 };
23540
23541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23543 if (SWIG_arg_fail(1)) SWIG_fail;
23544 {
23545 arg2 = (int)(SWIG_As_int(obj1));
23546 if (SWIG_arg_fail(2)) SWIG_fail;
23547 }
23548 {
23549 PyThreadState* __tstate = wxPyBeginAllowThreads();
23550 (arg1)->SetAssertMode(arg2);
23551
23552 wxPyEndAllowThreads(__tstate);
23553 if (PyErr_Occurred()) SWIG_fail;
23554 }
23555 Py_INCREF(Py_None); resultobj = Py_None;
23556 return resultobj;
23557 fail:
23558 return NULL;
23559 }
23560
23561
23562 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23563 PyObject *resultobj;
23564 wxPyApp *arg1 = (wxPyApp *) 0 ;
23565 int result;
23566 PyObject * obj0 = 0 ;
23567 char *kwnames[] = {
23568 (char *) "self", NULL
23569 };
23570
23571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23573 if (SWIG_arg_fail(1)) SWIG_fail;
23574 {
23575 PyThreadState* __tstate = wxPyBeginAllowThreads();
23576 result = (int)(arg1)->GetAssertMode();
23577
23578 wxPyEndAllowThreads(__tstate);
23579 if (PyErr_Occurred()) SWIG_fail;
23580 }
23581 {
23582 resultobj = SWIG_From_int((int)(result));
23583 }
23584 return resultobj;
23585 fail:
23586 return NULL;
23587 }
23588
23589
23590 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23591 PyObject *resultobj;
23592 bool result;
23593 char *kwnames[] = {
23594 NULL
23595 };
23596
23597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23598 {
23599 PyThreadState* __tstate = wxPyBeginAllowThreads();
23600 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23601
23602 wxPyEndAllowThreads(__tstate);
23603 if (PyErr_Occurred()) SWIG_fail;
23604 }
23605 {
23606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23607 }
23608 return resultobj;
23609 fail:
23610 return NULL;
23611 }
23612
23613
23614 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23615 PyObject *resultobj;
23616 long result;
23617 char *kwnames[] = {
23618 NULL
23619 };
23620
23621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23622 {
23623 PyThreadState* __tstate = wxPyBeginAllowThreads();
23624 result = (long)wxPyApp::GetMacAboutMenuItemId();
23625
23626 wxPyEndAllowThreads(__tstate);
23627 if (PyErr_Occurred()) SWIG_fail;
23628 }
23629 {
23630 resultobj = SWIG_From_long((long)(result));
23631 }
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj;
23640 long result;
23641 char *kwnames[] = {
23642 NULL
23643 };
23644
23645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23649
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 resultobj = SWIG_From_long((long)(result));
23655 }
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23663 PyObject *resultobj;
23664 long result;
23665 char *kwnames[] = {
23666 NULL
23667 };
23668
23669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 result = (long)wxPyApp::GetMacExitMenuItemId();
23673
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 {
23678 resultobj = SWIG_From_long((long)(result));
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj;
23688 wxString result;
23689 char *kwnames[] = {
23690 NULL
23691 };
23692
23693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23694 {
23695 PyThreadState* __tstate = wxPyBeginAllowThreads();
23696 result = wxPyApp::GetMacHelpMenuTitleName();
23697
23698 wxPyEndAllowThreads(__tstate);
23699 if (PyErr_Occurred()) SWIG_fail;
23700 }
23701 {
23702 #if wxUSE_UNICODE
23703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23704 #else
23705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23706 #endif
23707 }
23708 return resultobj;
23709 fail:
23710 return NULL;
23711 }
23712
23713
23714 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23715 PyObject *resultobj;
23716 bool arg1 ;
23717 PyObject * obj0 = 0 ;
23718 char *kwnames[] = {
23719 (char *) "val", NULL
23720 };
23721
23722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23723 {
23724 arg1 = (bool)(SWIG_As_bool(obj0));
23725 if (SWIG_arg_fail(1)) SWIG_fail;
23726 }
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23730
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 Py_INCREF(Py_None); resultobj = Py_None;
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23742 PyObject *resultobj;
23743 long arg1 ;
23744 PyObject * obj0 = 0 ;
23745 char *kwnames[] = {
23746 (char *) "val", NULL
23747 };
23748
23749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23750 {
23751 arg1 = (long)(SWIG_As_long(obj0));
23752 if (SWIG_arg_fail(1)) SWIG_fail;
23753 }
23754 {
23755 PyThreadState* __tstate = wxPyBeginAllowThreads();
23756 wxPyApp::SetMacAboutMenuItemId(arg1);
23757
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 Py_INCREF(Py_None); resultobj = Py_None;
23762 return resultobj;
23763 fail:
23764 return NULL;
23765 }
23766
23767
23768 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23769 PyObject *resultobj;
23770 long arg1 ;
23771 PyObject * obj0 = 0 ;
23772 char *kwnames[] = {
23773 (char *) "val", NULL
23774 };
23775
23776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23777 {
23778 arg1 = (long)(SWIG_As_long(obj0));
23779 if (SWIG_arg_fail(1)) SWIG_fail;
23780 }
23781 {
23782 PyThreadState* __tstate = wxPyBeginAllowThreads();
23783 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23784
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 Py_INCREF(Py_None); resultobj = Py_None;
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23796 PyObject *resultobj;
23797 long arg1 ;
23798 PyObject * obj0 = 0 ;
23799 char *kwnames[] = {
23800 (char *) "val", NULL
23801 };
23802
23803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23804 {
23805 arg1 = (long)(SWIG_As_long(obj0));
23806 if (SWIG_arg_fail(1)) SWIG_fail;
23807 }
23808 {
23809 PyThreadState* __tstate = wxPyBeginAllowThreads();
23810 wxPyApp::SetMacExitMenuItemId(arg1);
23811
23812 wxPyEndAllowThreads(__tstate);
23813 if (PyErr_Occurred()) SWIG_fail;
23814 }
23815 Py_INCREF(Py_None); resultobj = Py_None;
23816 return resultobj;
23817 fail:
23818 return NULL;
23819 }
23820
23821
23822 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23823 PyObject *resultobj;
23824 wxString *arg1 = 0 ;
23825 bool temp1 = false ;
23826 PyObject * obj0 = 0 ;
23827 char *kwnames[] = {
23828 (char *) "val", NULL
23829 };
23830
23831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23832 {
23833 arg1 = wxString_in_helper(obj0);
23834 if (arg1 == NULL) SWIG_fail;
23835 temp1 = true;
23836 }
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23840
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 Py_INCREF(Py_None); resultobj = Py_None;
23845 {
23846 if (temp1)
23847 delete arg1;
23848 }
23849 return resultobj;
23850 fail:
23851 {
23852 if (temp1)
23853 delete arg1;
23854 }
23855 return NULL;
23856 }
23857
23858
23859 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23860 PyObject *resultobj;
23861 wxPyApp *arg1 = (wxPyApp *) 0 ;
23862 PyObject * obj0 = 0 ;
23863 char *kwnames[] = {
23864 (char *) "self", NULL
23865 };
23866
23867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23869 if (SWIG_arg_fail(1)) SWIG_fail;
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 (arg1)->_BootstrapApp();
23873
23874 wxPyEndAllowThreads(__tstate);
23875 if (PyErr_Occurred()) SWIG_fail;
23876 }
23877 Py_INCREF(Py_None); resultobj = Py_None;
23878 return resultobj;
23879 fail:
23880 return NULL;
23881 }
23882
23883
23884 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23885 PyObject *resultobj;
23886 int result;
23887 char *kwnames[] = {
23888 NULL
23889 };
23890
23891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23892 {
23893 PyThreadState* __tstate = wxPyBeginAllowThreads();
23894 result = (int)wxPyApp::GetComCtl32Version();
23895
23896 wxPyEndAllowThreads(__tstate);
23897 if (PyErr_Occurred()) SWIG_fail;
23898 }
23899 {
23900 resultobj = SWIG_From_int((int)(result));
23901 }
23902 return resultobj;
23903 fail:
23904 return NULL;
23905 }
23906
23907
23908 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23909 PyObject *obj;
23910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23911 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23912 Py_INCREF(obj);
23913 return Py_BuildValue((char *)"");
23914 }
23915 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23916 PyObject *resultobj;
23917 char *kwnames[] = {
23918 NULL
23919 };
23920
23921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 wxExit();
23925
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 Py_INCREF(Py_None); resultobj = Py_None;
23930 return resultobj;
23931 fail:
23932 return NULL;
23933 }
23934
23935
23936 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23937 PyObject *resultobj;
23938 bool result;
23939 char *kwnames[] = {
23940 NULL
23941 };
23942
23943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23944 {
23945 PyThreadState* __tstate = wxPyBeginAllowThreads();
23946 result = (bool)wxYield();
23947
23948 wxPyEndAllowThreads(__tstate);
23949 if (PyErr_Occurred()) SWIG_fail;
23950 }
23951 {
23952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23953 }
23954 return resultobj;
23955 fail:
23956 return NULL;
23957 }
23958
23959
23960 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23961 PyObject *resultobj;
23962 bool result;
23963 char *kwnames[] = {
23964 NULL
23965 };
23966
23967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23968 {
23969 PyThreadState* __tstate = wxPyBeginAllowThreads();
23970 result = (bool)wxYieldIfNeeded();
23971
23972 wxPyEndAllowThreads(__tstate);
23973 if (PyErr_Occurred()) SWIG_fail;
23974 }
23975 {
23976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23977 }
23978 return resultobj;
23979 fail:
23980 return NULL;
23981 }
23982
23983
23984 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23985 PyObject *resultobj;
23986 wxWindow *arg1 = (wxWindow *) NULL ;
23987 bool arg2 = (bool) false ;
23988 bool result;
23989 PyObject * obj0 = 0 ;
23990 PyObject * obj1 = 0 ;
23991 char *kwnames[] = {
23992 (char *) "win",(char *) "onlyIfNeeded", NULL
23993 };
23994
23995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23996 if (obj0) {
23997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23998 if (SWIG_arg_fail(1)) SWIG_fail;
23999 }
24000 if (obj1) {
24001 {
24002 arg2 = (bool)(SWIG_As_bool(obj1));
24003 if (SWIG_arg_fail(2)) SWIG_fail;
24004 }
24005 }
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (bool)wxSafeYield(arg1,arg2);
24009
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 {
24014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24015 }
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24023 PyObject *resultobj;
24024 char *kwnames[] = {
24025 NULL
24026 };
24027
24028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24029 {
24030 PyThreadState* __tstate = wxPyBeginAllowThreads();
24031 wxWakeUpIdle();
24032
24033 wxPyEndAllowThreads(__tstate);
24034 if (PyErr_Occurred()) SWIG_fail;
24035 }
24036 Py_INCREF(Py_None); resultobj = Py_None;
24037 return resultobj;
24038 fail:
24039 return NULL;
24040 }
24041
24042
24043 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24044 PyObject *resultobj;
24045 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24046 wxEvent *arg2 = 0 ;
24047 PyObject * obj0 = 0 ;
24048 PyObject * obj1 = 0 ;
24049 char *kwnames[] = {
24050 (char *) "dest",(char *) "event", NULL
24051 };
24052
24053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24055 if (SWIG_arg_fail(1)) SWIG_fail;
24056 {
24057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24058 if (SWIG_arg_fail(2)) SWIG_fail;
24059 if (arg2 == NULL) {
24060 SWIG_null_ref("wxEvent");
24061 }
24062 if (SWIG_arg_fail(2)) SWIG_fail;
24063 }
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 wxPostEvent(arg1,*arg2);
24067
24068 wxPyEndAllowThreads(__tstate);
24069 if (PyErr_Occurred()) SWIG_fail;
24070 }
24071 Py_INCREF(Py_None); resultobj = Py_None;
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24079 PyObject *resultobj;
24080 char *kwnames[] = {
24081 NULL
24082 };
24083
24084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24085 {
24086 PyThreadState* __tstate = wxPyBeginAllowThreads();
24087 wxApp_CleanUp();
24088
24089 wxPyEndAllowThreads(__tstate);
24090 if (PyErr_Occurred()) SWIG_fail;
24091 }
24092 Py_INCREF(Py_None); resultobj = Py_None;
24093 return resultobj;
24094 fail:
24095 return NULL;
24096 }
24097
24098
24099 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24100 PyObject *resultobj;
24101 wxPyApp *result;
24102 char *kwnames[] = {
24103 NULL
24104 };
24105
24106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24107 {
24108 PyThreadState* __tstate = wxPyBeginAllowThreads();
24109 result = (wxPyApp *)wxPyGetApp();
24110
24111 wxPyEndAllowThreads(__tstate);
24112 if (PyErr_Occurred()) SWIG_fail;
24113 }
24114 {
24115 resultobj = wxPyMake_wxObject(result, 0);
24116 }
24117 return resultobj;
24118 fail:
24119 return NULL;
24120 }
24121
24122
24123 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24124 PyObject *resultobj;
24125 char *arg1 = (char *) 0 ;
24126 PyObject * obj0 = 0 ;
24127 char *kwnames[] = {
24128 (char *) "encoding", NULL
24129 };
24130
24131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24132 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24133 SWIG_arg_fail(1);SWIG_fail;
24134 }
24135 {
24136 PyThreadState* __tstate = wxPyBeginAllowThreads();
24137 wxSetDefaultPyEncoding((char const *)arg1);
24138
24139 wxPyEndAllowThreads(__tstate);
24140 if (PyErr_Occurred()) SWIG_fail;
24141 }
24142 Py_INCREF(Py_None); resultobj = Py_None;
24143 return resultobj;
24144 fail:
24145 return NULL;
24146 }
24147
24148
24149 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24150 PyObject *resultobj;
24151 char *result;
24152 char *kwnames[] = {
24153 NULL
24154 };
24155
24156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (char *)wxGetDefaultPyEncoding();
24160
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 resultobj = SWIG_FromCharPtr(result);
24165 return resultobj;
24166 fail:
24167 return NULL;
24168 }
24169
24170
24171 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24172 PyObject *resultobj;
24173 wxEventLoop *result;
24174 char *kwnames[] = {
24175 NULL
24176 };
24177
24178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24179 {
24180 PyThreadState* __tstate = wxPyBeginAllowThreads();
24181 result = (wxEventLoop *)new wxEventLoop();
24182
24183 wxPyEndAllowThreads(__tstate);
24184 if (PyErr_Occurred()) SWIG_fail;
24185 }
24186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24187 return resultobj;
24188 fail:
24189 return NULL;
24190 }
24191
24192
24193 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24194 PyObject *resultobj;
24195 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24196 PyObject * obj0 = 0 ;
24197 char *kwnames[] = {
24198 (char *) "self", NULL
24199 };
24200
24201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24203 if (SWIG_arg_fail(1)) SWIG_fail;
24204 {
24205 PyThreadState* __tstate = wxPyBeginAllowThreads();
24206 delete arg1;
24207
24208 wxPyEndAllowThreads(__tstate);
24209 if (PyErr_Occurred()) SWIG_fail;
24210 }
24211 Py_INCREF(Py_None); resultobj = Py_None;
24212 return resultobj;
24213 fail:
24214 return NULL;
24215 }
24216
24217
24218 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24219 PyObject *resultobj;
24220 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24221 int result;
24222 PyObject * obj0 = 0 ;
24223 char *kwnames[] = {
24224 (char *) "self", NULL
24225 };
24226
24227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24229 if (SWIG_arg_fail(1)) SWIG_fail;
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (int)(arg1)->Run();
24233
24234 wxPyEndAllowThreads(__tstate);
24235 if (PyErr_Occurred()) SWIG_fail;
24236 }
24237 {
24238 resultobj = SWIG_From_int((int)(result));
24239 }
24240 return resultobj;
24241 fail:
24242 return NULL;
24243 }
24244
24245
24246 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24247 PyObject *resultobj;
24248 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24249 int arg2 = (int) 0 ;
24250 PyObject * obj0 = 0 ;
24251 PyObject * obj1 = 0 ;
24252 char *kwnames[] = {
24253 (char *) "self",(char *) "rc", NULL
24254 };
24255
24256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24258 if (SWIG_arg_fail(1)) SWIG_fail;
24259 if (obj1) {
24260 {
24261 arg2 = (int)(SWIG_As_int(obj1));
24262 if (SWIG_arg_fail(2)) SWIG_fail;
24263 }
24264 }
24265 {
24266 PyThreadState* __tstate = wxPyBeginAllowThreads();
24267 (arg1)->Exit(arg2);
24268
24269 wxPyEndAllowThreads(__tstate);
24270 if (PyErr_Occurred()) SWIG_fail;
24271 }
24272 Py_INCREF(Py_None); resultobj = Py_None;
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24280 PyObject *resultobj;
24281 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24282 bool result;
24283 PyObject * obj0 = 0 ;
24284 char *kwnames[] = {
24285 (char *) "self", NULL
24286 };
24287
24288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24290 if (SWIG_arg_fail(1)) SWIG_fail;
24291 {
24292 PyThreadState* __tstate = wxPyBeginAllowThreads();
24293 result = (bool)((wxEventLoop const *)arg1)->Pending();
24294
24295 wxPyEndAllowThreads(__tstate);
24296 if (PyErr_Occurred()) SWIG_fail;
24297 }
24298 {
24299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24300 }
24301 return resultobj;
24302 fail:
24303 return NULL;
24304 }
24305
24306
24307 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24308 PyObject *resultobj;
24309 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24310 bool result;
24311 PyObject * obj0 = 0 ;
24312 char *kwnames[] = {
24313 (char *) "self", NULL
24314 };
24315
24316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24318 if (SWIG_arg_fail(1)) SWIG_fail;
24319 {
24320 PyThreadState* __tstate = wxPyBeginAllowThreads();
24321 result = (bool)(arg1)->Dispatch();
24322
24323 wxPyEndAllowThreads(__tstate);
24324 if (PyErr_Occurred()) SWIG_fail;
24325 }
24326 {
24327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24328 }
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj;
24337 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24338 bool result;
24339 PyObject * obj0 = 0 ;
24340 char *kwnames[] = {
24341 (char *) "self", NULL
24342 };
24343
24344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24346 if (SWIG_arg_fail(1)) SWIG_fail;
24347 {
24348 PyThreadState* __tstate = wxPyBeginAllowThreads();
24349 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24350
24351 wxPyEndAllowThreads(__tstate);
24352 if (PyErr_Occurred()) SWIG_fail;
24353 }
24354 {
24355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24356 }
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24364 PyObject *resultobj;
24365 wxEventLoop *result;
24366 char *kwnames[] = {
24367 NULL
24368 };
24369
24370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24371 {
24372 PyThreadState* __tstate = wxPyBeginAllowThreads();
24373 result = (wxEventLoop *)wxEventLoop::GetActive();
24374
24375 wxPyEndAllowThreads(__tstate);
24376 if (PyErr_Occurred()) SWIG_fail;
24377 }
24378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24379 return resultobj;
24380 fail:
24381 return NULL;
24382 }
24383
24384
24385 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24386 PyObject *resultobj;
24387 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24388 PyObject * obj0 = 0 ;
24389 char *kwnames[] = {
24390 (char *) "loop", NULL
24391 };
24392
24393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24395 if (SWIG_arg_fail(1)) SWIG_fail;
24396 {
24397 PyThreadState* __tstate = wxPyBeginAllowThreads();
24398 wxEventLoop::SetActive(arg1);
24399
24400 wxPyEndAllowThreads(__tstate);
24401 if (PyErr_Occurred()) SWIG_fail;
24402 }
24403 Py_INCREF(Py_None); resultobj = Py_None;
24404 return resultobj;
24405 fail:
24406 return NULL;
24407 }
24408
24409
24410 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24411 PyObject *obj;
24412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24413 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24414 Py_INCREF(obj);
24415 return Py_BuildValue((char *)"");
24416 }
24417 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24418 PyObject *resultobj;
24419 int arg1 = (int) 0 ;
24420 int arg2 = (int) 0 ;
24421 int arg3 = (int) 0 ;
24422 wxAcceleratorEntry *result;
24423 PyObject * obj0 = 0 ;
24424 PyObject * obj1 = 0 ;
24425 PyObject * obj2 = 0 ;
24426 char *kwnames[] = {
24427 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24428 };
24429
24430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24431 if (obj0) {
24432 {
24433 arg1 = (int)(SWIG_As_int(obj0));
24434 if (SWIG_arg_fail(1)) SWIG_fail;
24435 }
24436 }
24437 if (obj1) {
24438 {
24439 arg2 = (int)(SWIG_As_int(obj1));
24440 if (SWIG_arg_fail(2)) SWIG_fail;
24441 }
24442 }
24443 if (obj2) {
24444 {
24445 arg3 = (int)(SWIG_As_int(obj2));
24446 if (SWIG_arg_fail(3)) SWIG_fail;
24447 }
24448 }
24449 {
24450 PyThreadState* __tstate = wxPyBeginAllowThreads();
24451 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24452
24453 wxPyEndAllowThreads(__tstate);
24454 if (PyErr_Occurred()) SWIG_fail;
24455 }
24456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24457 return resultobj;
24458 fail:
24459 return NULL;
24460 }
24461
24462
24463 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24464 PyObject *resultobj;
24465 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24466 PyObject * obj0 = 0 ;
24467 char *kwnames[] = {
24468 (char *) "self", NULL
24469 };
24470
24471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24473 if (SWIG_arg_fail(1)) SWIG_fail;
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 delete arg1;
24477
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 Py_INCREF(Py_None); resultobj = Py_None;
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24489 PyObject *resultobj;
24490 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24491 int arg2 ;
24492 int arg3 ;
24493 int arg4 ;
24494 PyObject * obj0 = 0 ;
24495 PyObject * obj1 = 0 ;
24496 PyObject * obj2 = 0 ;
24497 PyObject * obj3 = 0 ;
24498 char *kwnames[] = {
24499 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24500 };
24501
24502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24504 if (SWIG_arg_fail(1)) SWIG_fail;
24505 {
24506 arg2 = (int)(SWIG_As_int(obj1));
24507 if (SWIG_arg_fail(2)) SWIG_fail;
24508 }
24509 {
24510 arg3 = (int)(SWIG_As_int(obj2));
24511 if (SWIG_arg_fail(3)) SWIG_fail;
24512 }
24513 {
24514 arg4 = (int)(SWIG_As_int(obj3));
24515 if (SWIG_arg_fail(4)) SWIG_fail;
24516 }
24517 {
24518 PyThreadState* __tstate = wxPyBeginAllowThreads();
24519 (arg1)->Set(arg2,arg3,arg4);
24520
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 Py_INCREF(Py_None); resultobj = Py_None;
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24532 PyObject *resultobj;
24533 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24534 int result;
24535 PyObject * obj0 = 0 ;
24536 char *kwnames[] = {
24537 (char *) "self", NULL
24538 };
24539
24540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24542 if (SWIG_arg_fail(1)) SWIG_fail;
24543 {
24544 PyThreadState* __tstate = wxPyBeginAllowThreads();
24545 result = (int)(arg1)->GetFlags();
24546
24547 wxPyEndAllowThreads(__tstate);
24548 if (PyErr_Occurred()) SWIG_fail;
24549 }
24550 {
24551 resultobj = SWIG_From_int((int)(result));
24552 }
24553 return resultobj;
24554 fail:
24555 return NULL;
24556 }
24557
24558
24559 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24560 PyObject *resultobj;
24561 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24562 int result;
24563 PyObject * obj0 = 0 ;
24564 char *kwnames[] = {
24565 (char *) "self", NULL
24566 };
24567
24568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24570 if (SWIG_arg_fail(1)) SWIG_fail;
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 result = (int)(arg1)->GetKeyCode();
24574
24575 wxPyEndAllowThreads(__tstate);
24576 if (PyErr_Occurred()) SWIG_fail;
24577 }
24578 {
24579 resultobj = SWIG_From_int((int)(result));
24580 }
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj;
24589 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24590 int result;
24591 PyObject * obj0 = 0 ;
24592 char *kwnames[] = {
24593 (char *) "self", NULL
24594 };
24595
24596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24598 if (SWIG_arg_fail(1)) SWIG_fail;
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (int)(arg1)->GetCommand();
24602
24603 wxPyEndAllowThreads(__tstate);
24604 if (PyErr_Occurred()) SWIG_fail;
24605 }
24606 {
24607 resultobj = SWIG_From_int((int)(result));
24608 }
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24616 PyObject *obj;
24617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24618 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24619 Py_INCREF(obj);
24620 return Py_BuildValue((char *)"");
24621 }
24622 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24623 PyObject *resultobj;
24624 int arg1 ;
24625 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24626 wxAcceleratorTable *result;
24627 PyObject * obj0 = 0 ;
24628 char *kwnames[] = {
24629 (char *) "n", NULL
24630 };
24631
24632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24633 {
24634 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24635 if (arg2) arg1 = PyList_Size(obj0);
24636 else arg1 = 0;
24637 }
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24641
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24646 {
24647 delete [] arg2;
24648 }
24649 return resultobj;
24650 fail:
24651 {
24652 delete [] arg2;
24653 }
24654 return NULL;
24655 }
24656
24657
24658 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24659 PyObject *resultobj;
24660 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24661 PyObject * obj0 = 0 ;
24662 char *kwnames[] = {
24663 (char *) "self", NULL
24664 };
24665
24666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24668 if (SWIG_arg_fail(1)) SWIG_fail;
24669 {
24670 PyThreadState* __tstate = wxPyBeginAllowThreads();
24671 delete arg1;
24672
24673 wxPyEndAllowThreads(__tstate);
24674 if (PyErr_Occurred()) SWIG_fail;
24675 }
24676 Py_INCREF(Py_None); resultobj = Py_None;
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj;
24685 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24686 bool result;
24687 PyObject * obj0 = 0 ;
24688 char *kwnames[] = {
24689 (char *) "self", NULL
24690 };
24691
24692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24694 if (SWIG_arg_fail(1)) SWIG_fail;
24695 {
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24698
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 {
24703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24704 }
24705 return resultobj;
24706 fail:
24707 return NULL;
24708 }
24709
24710
24711 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24712 PyObject *obj;
24713 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24714 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24715 Py_INCREF(obj);
24716 return Py_BuildValue((char *)"");
24717 }
24718 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24719 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24720 return 1;
24721 }
24722
24723
24724 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24725 PyObject *pyobj;
24726
24727 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24728 return pyobj;
24729 }
24730
24731
24732 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24733 PyObject *resultobj;
24734 wxString *arg1 = 0 ;
24735 wxAcceleratorEntry *result;
24736 bool temp1 = false ;
24737 PyObject * obj0 = 0 ;
24738 char *kwnames[] = {
24739 (char *) "label", NULL
24740 };
24741
24742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24743 {
24744 arg1 = wxString_in_helper(obj0);
24745 if (arg1 == NULL) SWIG_fail;
24746 temp1 = true;
24747 }
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24751
24752 wxPyEndAllowThreads(__tstate);
24753 if (PyErr_Occurred()) SWIG_fail;
24754 }
24755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24756 {
24757 if (temp1)
24758 delete arg1;
24759 }
24760 return resultobj;
24761 fail:
24762 {
24763 if (temp1)
24764 delete arg1;
24765 }
24766 return NULL;
24767 }
24768
24769
24770 static int _wrap_PanelNameStr_set(PyObject *) {
24771 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24772 return 1;
24773 }
24774
24775
24776 static PyObject *_wrap_PanelNameStr_get(void) {
24777 PyObject *pyobj;
24778
24779 {
24780 #if wxUSE_UNICODE
24781 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24782 #else
24783 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24784 #endif
24785 }
24786 return pyobj;
24787 }
24788
24789
24790 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24791 PyObject *resultobj;
24792 wxVisualAttributes *result;
24793 char *kwnames[] = {
24794 NULL
24795 };
24796
24797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24798 {
24799 PyThreadState* __tstate = wxPyBeginAllowThreads();
24800 result = (wxVisualAttributes *)new_wxVisualAttributes();
24801
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24813 PyObject *resultobj;
24814 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24815 PyObject * obj0 = 0 ;
24816 char *kwnames[] = {
24817 (char *) "self", NULL
24818 };
24819
24820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24822 if (SWIG_arg_fail(1)) SWIG_fail;
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 delete_wxVisualAttributes(arg1);
24826
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 Py_INCREF(Py_None); resultobj = Py_None;
24831 return resultobj;
24832 fail:
24833 return NULL;
24834 }
24835
24836
24837 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24838 PyObject *resultobj;
24839 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24840 wxFont *arg2 = (wxFont *) 0 ;
24841 PyObject * obj0 = 0 ;
24842 PyObject * obj1 = 0 ;
24843 char *kwnames[] = {
24844 (char *) "self",(char *) "font", NULL
24845 };
24846
24847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24849 if (SWIG_arg_fail(1)) SWIG_fail;
24850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24851 if (SWIG_arg_fail(2)) SWIG_fail;
24852 if (arg1) (arg1)->font = *arg2;
24853
24854 Py_INCREF(Py_None); resultobj = Py_None;
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24862 PyObject *resultobj;
24863 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24864 wxFont *result;
24865 PyObject * obj0 = 0 ;
24866 char *kwnames[] = {
24867 (char *) "self", NULL
24868 };
24869
24870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24872 if (SWIG_arg_fail(1)) SWIG_fail;
24873 result = (wxFont *)& ((arg1)->font);
24874
24875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24876 return resultobj;
24877 fail:
24878 return NULL;
24879 }
24880
24881
24882 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24883 PyObject *resultobj;
24884 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24885 wxColour *arg2 = (wxColour *) 0 ;
24886 PyObject * obj0 = 0 ;
24887 PyObject * obj1 = 0 ;
24888 char *kwnames[] = {
24889 (char *) "self",(char *) "colFg", NULL
24890 };
24891
24892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24894 if (SWIG_arg_fail(1)) SWIG_fail;
24895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24896 if (SWIG_arg_fail(2)) SWIG_fail;
24897 if (arg1) (arg1)->colFg = *arg2;
24898
24899 Py_INCREF(Py_None); resultobj = Py_None;
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24907 PyObject *resultobj;
24908 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24909 wxColour *result;
24910 PyObject * obj0 = 0 ;
24911 char *kwnames[] = {
24912 (char *) "self", NULL
24913 };
24914
24915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24917 if (SWIG_arg_fail(1)) SWIG_fail;
24918 result = (wxColour *)& ((arg1)->colFg);
24919
24920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24921 return resultobj;
24922 fail:
24923 return NULL;
24924 }
24925
24926
24927 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24928 PyObject *resultobj;
24929 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24930 wxColour *arg2 = (wxColour *) 0 ;
24931 PyObject * obj0 = 0 ;
24932 PyObject * obj1 = 0 ;
24933 char *kwnames[] = {
24934 (char *) "self",(char *) "colBg", NULL
24935 };
24936
24937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24939 if (SWIG_arg_fail(1)) SWIG_fail;
24940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24941 if (SWIG_arg_fail(2)) SWIG_fail;
24942 if (arg1) (arg1)->colBg = *arg2;
24943
24944 Py_INCREF(Py_None); resultobj = Py_None;
24945 return resultobj;
24946 fail:
24947 return NULL;
24948 }
24949
24950
24951 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24952 PyObject *resultobj;
24953 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24954 wxColour *result;
24955 PyObject * obj0 = 0 ;
24956 char *kwnames[] = {
24957 (char *) "self", NULL
24958 };
24959
24960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24962 if (SWIG_arg_fail(1)) SWIG_fail;
24963 result = (wxColour *)& ((arg1)->colBg);
24964
24965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24966 return resultobj;
24967 fail:
24968 return NULL;
24969 }
24970
24971
24972 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24973 PyObject *obj;
24974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24975 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24976 Py_INCREF(obj);
24977 return Py_BuildValue((char *)"");
24978 }
24979 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24980 PyObject *resultobj;
24981 wxWindow *arg1 = (wxWindow *) 0 ;
24982 int arg2 = (int) (int)-1 ;
24983 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24984 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24985 wxSize const &arg4_defvalue = wxDefaultSize ;
24986 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24987 long arg5 = (long) 0 ;
24988 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24989 wxString *arg6 = (wxString *) &arg6_defvalue ;
24990 wxWindow *result;
24991 wxPoint temp3 ;
24992 wxSize temp4 ;
24993 bool temp6 = false ;
24994 PyObject * obj0 = 0 ;
24995 PyObject * obj1 = 0 ;
24996 PyObject * obj2 = 0 ;
24997 PyObject * obj3 = 0 ;
24998 PyObject * obj4 = 0 ;
24999 PyObject * obj5 = 0 ;
25000 char *kwnames[] = {
25001 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25002 };
25003
25004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25006 if (SWIG_arg_fail(1)) SWIG_fail;
25007 if (obj1) {
25008 {
25009 arg2 = (int const)(SWIG_As_int(obj1));
25010 if (SWIG_arg_fail(2)) SWIG_fail;
25011 }
25012 }
25013 if (obj2) {
25014 {
25015 arg3 = &temp3;
25016 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25017 }
25018 }
25019 if (obj3) {
25020 {
25021 arg4 = &temp4;
25022 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25023 }
25024 }
25025 if (obj4) {
25026 {
25027 arg5 = (long)(SWIG_As_long(obj4));
25028 if (SWIG_arg_fail(5)) SWIG_fail;
25029 }
25030 }
25031 if (obj5) {
25032 {
25033 arg6 = wxString_in_helper(obj5);
25034 if (arg6 == NULL) SWIG_fail;
25035 temp6 = true;
25036 }
25037 }
25038 {
25039 if (!wxPyCheckForApp()) SWIG_fail;
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25042
25043 wxPyEndAllowThreads(__tstate);
25044 if (PyErr_Occurred()) SWIG_fail;
25045 }
25046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25047 {
25048 if (temp6)
25049 delete arg6;
25050 }
25051 return resultobj;
25052 fail:
25053 {
25054 if (temp6)
25055 delete arg6;
25056 }
25057 return NULL;
25058 }
25059
25060
25061 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25062 PyObject *resultobj;
25063 wxWindow *result;
25064 char *kwnames[] = {
25065 NULL
25066 };
25067
25068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25069 {
25070 if (!wxPyCheckForApp()) SWIG_fail;
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 result = (wxWindow *)new wxWindow();
25073
25074 wxPyEndAllowThreads(__tstate);
25075 if (PyErr_Occurred()) SWIG_fail;
25076 }
25077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25078 return resultobj;
25079 fail:
25080 return NULL;
25081 }
25082
25083
25084 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25085 PyObject *resultobj;
25086 wxWindow *arg1 = (wxWindow *) 0 ;
25087 wxWindow *arg2 = (wxWindow *) 0 ;
25088 int arg3 = (int) (int)-1 ;
25089 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25090 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25091 wxSize const &arg5_defvalue = wxDefaultSize ;
25092 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25093 long arg6 = (long) 0 ;
25094 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25095 wxString *arg7 = (wxString *) &arg7_defvalue ;
25096 bool result;
25097 wxPoint temp4 ;
25098 wxSize temp5 ;
25099 bool temp7 = false ;
25100 PyObject * obj0 = 0 ;
25101 PyObject * obj1 = 0 ;
25102 PyObject * obj2 = 0 ;
25103 PyObject * obj3 = 0 ;
25104 PyObject * obj4 = 0 ;
25105 PyObject * obj5 = 0 ;
25106 PyObject * obj6 = 0 ;
25107 char *kwnames[] = {
25108 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25109 };
25110
25111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25113 if (SWIG_arg_fail(1)) SWIG_fail;
25114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25115 if (SWIG_arg_fail(2)) SWIG_fail;
25116 if (obj2) {
25117 {
25118 arg3 = (int const)(SWIG_As_int(obj2));
25119 if (SWIG_arg_fail(3)) SWIG_fail;
25120 }
25121 }
25122 if (obj3) {
25123 {
25124 arg4 = &temp4;
25125 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25126 }
25127 }
25128 if (obj4) {
25129 {
25130 arg5 = &temp5;
25131 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25132 }
25133 }
25134 if (obj5) {
25135 {
25136 arg6 = (long)(SWIG_As_long(obj5));
25137 if (SWIG_arg_fail(6)) SWIG_fail;
25138 }
25139 }
25140 if (obj6) {
25141 {
25142 arg7 = wxString_in_helper(obj6);
25143 if (arg7 == NULL) SWIG_fail;
25144 temp7 = true;
25145 }
25146 }
25147 {
25148 PyThreadState* __tstate = wxPyBeginAllowThreads();
25149 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25150
25151 wxPyEndAllowThreads(__tstate);
25152 if (PyErr_Occurred()) SWIG_fail;
25153 }
25154 {
25155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25156 }
25157 {
25158 if (temp7)
25159 delete arg7;
25160 }
25161 return resultobj;
25162 fail:
25163 {
25164 if (temp7)
25165 delete arg7;
25166 }
25167 return NULL;
25168 }
25169
25170
25171 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25172 PyObject *resultobj;
25173 wxWindow *arg1 = (wxWindow *) 0 ;
25174 bool arg2 = (bool) false ;
25175 bool result;
25176 PyObject * obj0 = 0 ;
25177 PyObject * obj1 = 0 ;
25178 char *kwnames[] = {
25179 (char *) "self",(char *) "force", NULL
25180 };
25181
25182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25184 if (SWIG_arg_fail(1)) SWIG_fail;
25185 if (obj1) {
25186 {
25187 arg2 = (bool)(SWIG_As_bool(obj1));
25188 if (SWIG_arg_fail(2)) SWIG_fail;
25189 }
25190 }
25191 {
25192 PyThreadState* __tstate = wxPyBeginAllowThreads();
25193 result = (bool)(arg1)->Close(arg2);
25194
25195 wxPyEndAllowThreads(__tstate);
25196 if (PyErr_Occurred()) SWIG_fail;
25197 }
25198 {
25199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25200 }
25201 return resultobj;
25202 fail:
25203 return NULL;
25204 }
25205
25206
25207 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25208 PyObject *resultobj;
25209 wxWindow *arg1 = (wxWindow *) 0 ;
25210 bool result;
25211 PyObject * obj0 = 0 ;
25212 char *kwnames[] = {
25213 (char *) "self", NULL
25214 };
25215
25216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25218 if (SWIG_arg_fail(1)) SWIG_fail;
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 result = (bool)(arg1)->Destroy();
25222
25223 wxPyEndAllowThreads(__tstate);
25224 if (PyErr_Occurred()) SWIG_fail;
25225 }
25226 {
25227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25228 }
25229 return resultobj;
25230 fail:
25231 return NULL;
25232 }
25233
25234
25235 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25236 PyObject *resultobj;
25237 wxWindow *arg1 = (wxWindow *) 0 ;
25238 bool result;
25239 PyObject * obj0 = 0 ;
25240 char *kwnames[] = {
25241 (char *) "self", NULL
25242 };
25243
25244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25246 if (SWIG_arg_fail(1)) SWIG_fail;
25247 {
25248 PyThreadState* __tstate = wxPyBeginAllowThreads();
25249 result = (bool)(arg1)->DestroyChildren();
25250
25251 wxPyEndAllowThreads(__tstate);
25252 if (PyErr_Occurred()) SWIG_fail;
25253 }
25254 {
25255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25256 }
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25264 PyObject *resultobj;
25265 wxWindow *arg1 = (wxWindow *) 0 ;
25266 bool result;
25267 PyObject * obj0 = 0 ;
25268 char *kwnames[] = {
25269 (char *) "self", NULL
25270 };
25271
25272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25274 if (SWIG_arg_fail(1)) SWIG_fail;
25275 {
25276 PyThreadState* __tstate = wxPyBeginAllowThreads();
25277 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25278
25279 wxPyEndAllowThreads(__tstate);
25280 if (PyErr_Occurred()) SWIG_fail;
25281 }
25282 {
25283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25284 }
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25292 PyObject *resultobj;
25293 wxWindow *arg1 = (wxWindow *) 0 ;
25294 wxString *arg2 = 0 ;
25295 bool temp2 = false ;
25296 PyObject * obj0 = 0 ;
25297 PyObject * obj1 = 0 ;
25298 char *kwnames[] = {
25299 (char *) "self",(char *) "title", NULL
25300 };
25301
25302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25304 if (SWIG_arg_fail(1)) SWIG_fail;
25305 {
25306 arg2 = wxString_in_helper(obj1);
25307 if (arg2 == NULL) SWIG_fail;
25308 temp2 = true;
25309 }
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 (arg1)->SetTitle((wxString const &)*arg2);
25313
25314 wxPyEndAllowThreads(__tstate);
25315 if (PyErr_Occurred()) SWIG_fail;
25316 }
25317 Py_INCREF(Py_None); resultobj = Py_None;
25318 {
25319 if (temp2)
25320 delete arg2;
25321 }
25322 return resultobj;
25323 fail:
25324 {
25325 if (temp2)
25326 delete arg2;
25327 }
25328 return NULL;
25329 }
25330
25331
25332 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25333 PyObject *resultobj;
25334 wxWindow *arg1 = (wxWindow *) 0 ;
25335 wxString result;
25336 PyObject * obj0 = 0 ;
25337 char *kwnames[] = {
25338 (char *) "self", NULL
25339 };
25340
25341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25343 if (SWIG_arg_fail(1)) SWIG_fail;
25344 {
25345 PyThreadState* __tstate = wxPyBeginAllowThreads();
25346 result = ((wxWindow const *)arg1)->GetTitle();
25347
25348 wxPyEndAllowThreads(__tstate);
25349 if (PyErr_Occurred()) SWIG_fail;
25350 }
25351 {
25352 #if wxUSE_UNICODE
25353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25354 #else
25355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25356 #endif
25357 }
25358 return resultobj;
25359 fail:
25360 return NULL;
25361 }
25362
25363
25364 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj;
25366 wxWindow *arg1 = (wxWindow *) 0 ;
25367 wxString *arg2 = 0 ;
25368 bool temp2 = false ;
25369 PyObject * obj0 = 0 ;
25370 PyObject * obj1 = 0 ;
25371 char *kwnames[] = {
25372 (char *) "self",(char *) "label", NULL
25373 };
25374
25375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25377 if (SWIG_arg_fail(1)) SWIG_fail;
25378 {
25379 arg2 = wxString_in_helper(obj1);
25380 if (arg2 == NULL) SWIG_fail;
25381 temp2 = true;
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 (arg1)->SetLabel((wxString const &)*arg2);
25386
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 Py_INCREF(Py_None); resultobj = Py_None;
25391 {
25392 if (temp2)
25393 delete arg2;
25394 }
25395 return resultobj;
25396 fail:
25397 {
25398 if (temp2)
25399 delete arg2;
25400 }
25401 return NULL;
25402 }
25403
25404
25405 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25406 PyObject *resultobj;
25407 wxWindow *arg1 = (wxWindow *) 0 ;
25408 wxString result;
25409 PyObject * obj0 = 0 ;
25410 char *kwnames[] = {
25411 (char *) "self", NULL
25412 };
25413
25414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25416 if (SWIG_arg_fail(1)) SWIG_fail;
25417 {
25418 PyThreadState* __tstate = wxPyBeginAllowThreads();
25419 result = ((wxWindow const *)arg1)->GetLabel();
25420
25421 wxPyEndAllowThreads(__tstate);
25422 if (PyErr_Occurred()) SWIG_fail;
25423 }
25424 {
25425 #if wxUSE_UNICODE
25426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25427 #else
25428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25429 #endif
25430 }
25431 return resultobj;
25432 fail:
25433 return NULL;
25434 }
25435
25436
25437 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25438 PyObject *resultobj;
25439 wxWindow *arg1 = (wxWindow *) 0 ;
25440 wxString *arg2 = 0 ;
25441 bool temp2 = false ;
25442 PyObject * obj0 = 0 ;
25443 PyObject * obj1 = 0 ;
25444 char *kwnames[] = {
25445 (char *) "self",(char *) "name", NULL
25446 };
25447
25448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25450 if (SWIG_arg_fail(1)) SWIG_fail;
25451 {
25452 arg2 = wxString_in_helper(obj1);
25453 if (arg2 == NULL) SWIG_fail;
25454 temp2 = true;
25455 }
25456 {
25457 PyThreadState* __tstate = wxPyBeginAllowThreads();
25458 (arg1)->SetName((wxString const &)*arg2);
25459
25460 wxPyEndAllowThreads(__tstate);
25461 if (PyErr_Occurred()) SWIG_fail;
25462 }
25463 Py_INCREF(Py_None); resultobj = Py_None;
25464 {
25465 if (temp2)
25466 delete arg2;
25467 }
25468 return resultobj;
25469 fail:
25470 {
25471 if (temp2)
25472 delete arg2;
25473 }
25474 return NULL;
25475 }
25476
25477
25478 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25479 PyObject *resultobj;
25480 wxWindow *arg1 = (wxWindow *) 0 ;
25481 wxString result;
25482 PyObject * obj0 = 0 ;
25483 char *kwnames[] = {
25484 (char *) "self", NULL
25485 };
25486
25487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25489 if (SWIG_arg_fail(1)) SWIG_fail;
25490 {
25491 PyThreadState* __tstate = wxPyBeginAllowThreads();
25492 result = ((wxWindow const *)arg1)->GetName();
25493
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 {
25498 #if wxUSE_UNICODE
25499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25500 #else
25501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25502 #endif
25503 }
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25511 PyObject *resultobj;
25512 wxWindow *arg1 = (wxWindow *) 0 ;
25513 wxWindowVariant arg2 ;
25514 PyObject * obj0 = 0 ;
25515 PyObject * obj1 = 0 ;
25516 char *kwnames[] = {
25517 (char *) "self",(char *) "variant", NULL
25518 };
25519
25520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25522 if (SWIG_arg_fail(1)) SWIG_fail;
25523 {
25524 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25525 if (SWIG_arg_fail(2)) SWIG_fail;
25526 }
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25530
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 Py_INCREF(Py_None); resultobj = Py_None;
25535 return resultobj;
25536 fail:
25537 return NULL;
25538 }
25539
25540
25541 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25542 PyObject *resultobj;
25543 wxWindow *arg1 = (wxWindow *) 0 ;
25544 wxWindowVariant result;
25545 PyObject * obj0 = 0 ;
25546 char *kwnames[] = {
25547 (char *) "self", NULL
25548 };
25549
25550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25552 if (SWIG_arg_fail(1)) SWIG_fail;
25553 {
25554 PyThreadState* __tstate = wxPyBeginAllowThreads();
25555 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25556
25557 wxPyEndAllowThreads(__tstate);
25558 if (PyErr_Occurred()) SWIG_fail;
25559 }
25560 resultobj = SWIG_From_int((result));
25561 return resultobj;
25562 fail:
25563 return NULL;
25564 }
25565
25566
25567 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25568 PyObject *resultobj;
25569 wxWindow *arg1 = (wxWindow *) 0 ;
25570 int arg2 ;
25571 PyObject * obj0 = 0 ;
25572 PyObject * obj1 = 0 ;
25573 char *kwnames[] = {
25574 (char *) "self",(char *) "winid", NULL
25575 };
25576
25577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25579 if (SWIG_arg_fail(1)) SWIG_fail;
25580 {
25581 arg2 = (int)(SWIG_As_int(obj1));
25582 if (SWIG_arg_fail(2)) SWIG_fail;
25583 }
25584 {
25585 PyThreadState* __tstate = wxPyBeginAllowThreads();
25586 (arg1)->SetId(arg2);
25587
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 Py_INCREF(Py_None); resultobj = Py_None;
25592 return resultobj;
25593 fail:
25594 return NULL;
25595 }
25596
25597
25598 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25599 PyObject *resultobj;
25600 wxWindow *arg1 = (wxWindow *) 0 ;
25601 int result;
25602 PyObject * obj0 = 0 ;
25603 char *kwnames[] = {
25604 (char *) "self", NULL
25605 };
25606
25607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25609 if (SWIG_arg_fail(1)) SWIG_fail;
25610 {
25611 PyThreadState* __tstate = wxPyBeginAllowThreads();
25612 result = (int)((wxWindow const *)arg1)->GetId();
25613
25614 wxPyEndAllowThreads(__tstate);
25615 if (PyErr_Occurred()) SWIG_fail;
25616 }
25617 {
25618 resultobj = SWIG_From_int((int)(result));
25619 }
25620 return resultobj;
25621 fail:
25622 return NULL;
25623 }
25624
25625
25626 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25627 PyObject *resultobj;
25628 int result;
25629 char *kwnames[] = {
25630 NULL
25631 };
25632
25633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 result = (int)wxWindow::NewControlId();
25637
25638 wxPyEndAllowThreads(__tstate);
25639 if (PyErr_Occurred()) SWIG_fail;
25640 }
25641 {
25642 resultobj = SWIG_From_int((int)(result));
25643 }
25644 return resultobj;
25645 fail:
25646 return NULL;
25647 }
25648
25649
25650 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25651 PyObject *resultobj;
25652 int arg1 ;
25653 int result;
25654 PyObject * obj0 = 0 ;
25655 char *kwnames[] = {
25656 (char *) "winid", NULL
25657 };
25658
25659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25660 {
25661 arg1 = (int)(SWIG_As_int(obj0));
25662 if (SWIG_arg_fail(1)) SWIG_fail;
25663 }
25664 {
25665 PyThreadState* __tstate = wxPyBeginAllowThreads();
25666 result = (int)wxWindow::NextControlId(arg1);
25667
25668 wxPyEndAllowThreads(__tstate);
25669 if (PyErr_Occurred()) SWIG_fail;
25670 }
25671 {
25672 resultobj = SWIG_From_int((int)(result));
25673 }
25674 return resultobj;
25675 fail:
25676 return NULL;
25677 }
25678
25679
25680 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25681 PyObject *resultobj;
25682 int arg1 ;
25683 int result;
25684 PyObject * obj0 = 0 ;
25685 char *kwnames[] = {
25686 (char *) "winid", NULL
25687 };
25688
25689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25690 {
25691 arg1 = (int)(SWIG_As_int(obj0));
25692 if (SWIG_arg_fail(1)) SWIG_fail;
25693 }
25694 {
25695 PyThreadState* __tstate = wxPyBeginAllowThreads();
25696 result = (int)wxWindow::PrevControlId(arg1);
25697
25698 wxPyEndAllowThreads(__tstate);
25699 if (PyErr_Occurred()) SWIG_fail;
25700 }
25701 {
25702 resultobj = SWIG_From_int((int)(result));
25703 }
25704 return resultobj;
25705 fail:
25706 return NULL;
25707 }
25708
25709
25710 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj;
25712 wxWindow *arg1 = (wxWindow *) 0 ;
25713 wxSize *arg2 = 0 ;
25714 wxSize temp2 ;
25715 PyObject * obj0 = 0 ;
25716 PyObject * obj1 = 0 ;
25717 char *kwnames[] = {
25718 (char *) "self",(char *) "size", NULL
25719 };
25720
25721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25723 if (SWIG_arg_fail(1)) SWIG_fail;
25724 {
25725 arg2 = &temp2;
25726 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25727 }
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 (arg1)->SetSize((wxSize const &)*arg2);
25731
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 Py_INCREF(Py_None); resultobj = Py_None;
25736 return resultobj;
25737 fail:
25738 return NULL;
25739 }
25740
25741
25742 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25743 PyObject *resultobj;
25744 wxWindow *arg1 = (wxWindow *) 0 ;
25745 int arg2 ;
25746 int arg3 ;
25747 int arg4 ;
25748 int arg5 ;
25749 int arg6 = (int) wxSIZE_AUTO ;
25750 PyObject * obj0 = 0 ;
25751 PyObject * obj1 = 0 ;
25752 PyObject * obj2 = 0 ;
25753 PyObject * obj3 = 0 ;
25754 PyObject * obj4 = 0 ;
25755 PyObject * obj5 = 0 ;
25756 char *kwnames[] = {
25757 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25758 };
25759
25760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25762 if (SWIG_arg_fail(1)) SWIG_fail;
25763 {
25764 arg2 = (int)(SWIG_As_int(obj1));
25765 if (SWIG_arg_fail(2)) SWIG_fail;
25766 }
25767 {
25768 arg3 = (int)(SWIG_As_int(obj2));
25769 if (SWIG_arg_fail(3)) SWIG_fail;
25770 }
25771 {
25772 arg4 = (int)(SWIG_As_int(obj3));
25773 if (SWIG_arg_fail(4)) SWIG_fail;
25774 }
25775 {
25776 arg5 = (int)(SWIG_As_int(obj4));
25777 if (SWIG_arg_fail(5)) SWIG_fail;
25778 }
25779 if (obj5) {
25780 {
25781 arg6 = (int)(SWIG_As_int(obj5));
25782 if (SWIG_arg_fail(6)) SWIG_fail;
25783 }
25784 }
25785 {
25786 PyThreadState* __tstate = wxPyBeginAllowThreads();
25787 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25788
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 Py_INCREF(Py_None); resultobj = Py_None;
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25800 PyObject *resultobj;
25801 wxWindow *arg1 = (wxWindow *) 0 ;
25802 wxRect *arg2 = 0 ;
25803 int arg3 = (int) wxSIZE_AUTO ;
25804 wxRect temp2 ;
25805 PyObject * obj0 = 0 ;
25806 PyObject * obj1 = 0 ;
25807 PyObject * obj2 = 0 ;
25808 char *kwnames[] = {
25809 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25810 };
25811
25812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25814 if (SWIG_arg_fail(1)) SWIG_fail;
25815 {
25816 arg2 = &temp2;
25817 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25818 }
25819 if (obj2) {
25820 {
25821 arg3 = (int)(SWIG_As_int(obj2));
25822 if (SWIG_arg_fail(3)) SWIG_fail;
25823 }
25824 }
25825 {
25826 PyThreadState* __tstate = wxPyBeginAllowThreads();
25827 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25828
25829 wxPyEndAllowThreads(__tstate);
25830 if (PyErr_Occurred()) SWIG_fail;
25831 }
25832 Py_INCREF(Py_None); resultobj = Py_None;
25833 return resultobj;
25834 fail:
25835 return NULL;
25836 }
25837
25838
25839 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25840 PyObject *resultobj;
25841 wxWindow *arg1 = (wxWindow *) 0 ;
25842 int arg2 ;
25843 int arg3 ;
25844 PyObject * obj0 = 0 ;
25845 PyObject * obj1 = 0 ;
25846 PyObject * obj2 = 0 ;
25847 char *kwnames[] = {
25848 (char *) "self",(char *) "width",(char *) "height", NULL
25849 };
25850
25851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25853 if (SWIG_arg_fail(1)) SWIG_fail;
25854 {
25855 arg2 = (int)(SWIG_As_int(obj1));
25856 if (SWIG_arg_fail(2)) SWIG_fail;
25857 }
25858 {
25859 arg3 = (int)(SWIG_As_int(obj2));
25860 if (SWIG_arg_fail(3)) SWIG_fail;
25861 }
25862 {
25863 PyThreadState* __tstate = wxPyBeginAllowThreads();
25864 (arg1)->SetSize(arg2,arg3);
25865
25866 wxPyEndAllowThreads(__tstate);
25867 if (PyErr_Occurred()) SWIG_fail;
25868 }
25869 Py_INCREF(Py_None); resultobj = Py_None;
25870 return resultobj;
25871 fail:
25872 return NULL;
25873 }
25874
25875
25876 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj;
25878 wxWindow *arg1 = (wxWindow *) 0 ;
25879 wxPoint *arg2 = 0 ;
25880 int arg3 = (int) wxSIZE_USE_EXISTING ;
25881 wxPoint temp2 ;
25882 PyObject * obj0 = 0 ;
25883 PyObject * obj1 = 0 ;
25884 PyObject * obj2 = 0 ;
25885 char *kwnames[] = {
25886 (char *) "self",(char *) "pt",(char *) "flags", NULL
25887 };
25888
25889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25891 if (SWIG_arg_fail(1)) SWIG_fail;
25892 {
25893 arg2 = &temp2;
25894 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25895 }
25896 if (obj2) {
25897 {
25898 arg3 = (int)(SWIG_As_int(obj2));
25899 if (SWIG_arg_fail(3)) SWIG_fail;
25900 }
25901 }
25902 {
25903 PyThreadState* __tstate = wxPyBeginAllowThreads();
25904 (arg1)->Move((wxPoint const &)*arg2,arg3);
25905
25906 wxPyEndAllowThreads(__tstate);
25907 if (PyErr_Occurred()) SWIG_fail;
25908 }
25909 Py_INCREF(Py_None); resultobj = Py_None;
25910 return resultobj;
25911 fail:
25912 return NULL;
25913 }
25914
25915
25916 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25917 PyObject *resultobj;
25918 wxWindow *arg1 = (wxWindow *) 0 ;
25919 int arg2 ;
25920 int arg3 ;
25921 int arg4 = (int) wxSIZE_USE_EXISTING ;
25922 PyObject * obj0 = 0 ;
25923 PyObject * obj1 = 0 ;
25924 PyObject * obj2 = 0 ;
25925 PyObject * obj3 = 0 ;
25926 char *kwnames[] = {
25927 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25928 };
25929
25930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25932 if (SWIG_arg_fail(1)) SWIG_fail;
25933 {
25934 arg2 = (int)(SWIG_As_int(obj1));
25935 if (SWIG_arg_fail(2)) SWIG_fail;
25936 }
25937 {
25938 arg3 = (int)(SWIG_As_int(obj2));
25939 if (SWIG_arg_fail(3)) SWIG_fail;
25940 }
25941 if (obj3) {
25942 {
25943 arg4 = (int)(SWIG_As_int(obj3));
25944 if (SWIG_arg_fail(4)) SWIG_fail;
25945 }
25946 }
25947 {
25948 PyThreadState* __tstate = wxPyBeginAllowThreads();
25949 (arg1)->Move(arg2,arg3,arg4);
25950
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 Py_INCREF(Py_None); resultobj = Py_None;
25955 return resultobj;
25956 fail:
25957 return NULL;
25958 }
25959
25960
25961 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25962 PyObject *resultobj;
25963 wxWindow *arg1 = (wxWindow *) 0 ;
25964 wxSize const &arg2_defvalue = wxDefaultSize ;
25965 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25966 wxSize temp2 ;
25967 PyObject * obj0 = 0 ;
25968 PyObject * obj1 = 0 ;
25969 char *kwnames[] = {
25970 (char *) "self",(char *) "size", NULL
25971 };
25972
25973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25975 if (SWIG_arg_fail(1)) SWIG_fail;
25976 if (obj1) {
25977 {
25978 arg2 = &temp2;
25979 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25980 }
25981 }
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25985
25986 wxPyEndAllowThreads(__tstate);
25987 if (PyErr_Occurred()) SWIG_fail;
25988 }
25989 Py_INCREF(Py_None); resultobj = Py_None;
25990 return resultobj;
25991 fail:
25992 return NULL;
25993 }
25994
25995
25996 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25997 PyObject *resultobj;
25998 wxWindow *arg1 = (wxWindow *) 0 ;
25999 PyObject * obj0 = 0 ;
26000 char *kwnames[] = {
26001 (char *) "self", NULL
26002 };
26003
26004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26006 if (SWIG_arg_fail(1)) SWIG_fail;
26007 {
26008 PyThreadState* __tstate = wxPyBeginAllowThreads();
26009 (arg1)->Raise();
26010
26011 wxPyEndAllowThreads(__tstate);
26012 if (PyErr_Occurred()) SWIG_fail;
26013 }
26014 Py_INCREF(Py_None); resultobj = Py_None;
26015 return resultobj;
26016 fail:
26017 return NULL;
26018 }
26019
26020
26021 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26022 PyObject *resultobj;
26023 wxWindow *arg1 = (wxWindow *) 0 ;
26024 PyObject * obj0 = 0 ;
26025 char *kwnames[] = {
26026 (char *) "self", NULL
26027 };
26028
26029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26031 if (SWIG_arg_fail(1)) SWIG_fail;
26032 {
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 (arg1)->Lower();
26035
26036 wxPyEndAllowThreads(__tstate);
26037 if (PyErr_Occurred()) SWIG_fail;
26038 }
26039 Py_INCREF(Py_None); resultobj = Py_None;
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj;
26048 wxWindow *arg1 = (wxWindow *) 0 ;
26049 wxSize *arg2 = 0 ;
26050 wxSize temp2 ;
26051 PyObject * obj0 = 0 ;
26052 PyObject * obj1 = 0 ;
26053 char *kwnames[] = {
26054 (char *) "self",(char *) "size", NULL
26055 };
26056
26057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26059 if (SWIG_arg_fail(1)) SWIG_fail;
26060 {
26061 arg2 = &temp2;
26062 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26063 }
26064 {
26065 PyThreadState* __tstate = wxPyBeginAllowThreads();
26066 (arg1)->SetClientSize((wxSize const &)*arg2);
26067
26068 wxPyEndAllowThreads(__tstate);
26069 if (PyErr_Occurred()) SWIG_fail;
26070 }
26071 Py_INCREF(Py_None); resultobj = Py_None;
26072 return resultobj;
26073 fail:
26074 return NULL;
26075 }
26076
26077
26078 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26079 PyObject *resultobj;
26080 wxWindow *arg1 = (wxWindow *) 0 ;
26081 int arg2 ;
26082 int arg3 ;
26083 PyObject * obj0 = 0 ;
26084 PyObject * obj1 = 0 ;
26085 PyObject * obj2 = 0 ;
26086 char *kwnames[] = {
26087 (char *) "self",(char *) "width",(char *) "height", NULL
26088 };
26089
26090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26092 if (SWIG_arg_fail(1)) SWIG_fail;
26093 {
26094 arg2 = (int)(SWIG_As_int(obj1));
26095 if (SWIG_arg_fail(2)) SWIG_fail;
26096 }
26097 {
26098 arg3 = (int)(SWIG_As_int(obj2));
26099 if (SWIG_arg_fail(3)) SWIG_fail;
26100 }
26101 {
26102 PyThreadState* __tstate = wxPyBeginAllowThreads();
26103 (arg1)->SetClientSize(arg2,arg3);
26104
26105 wxPyEndAllowThreads(__tstate);
26106 if (PyErr_Occurred()) SWIG_fail;
26107 }
26108 Py_INCREF(Py_None); resultobj = Py_None;
26109 return resultobj;
26110 fail:
26111 return NULL;
26112 }
26113
26114
26115 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26116 PyObject *resultobj;
26117 wxWindow *arg1 = (wxWindow *) 0 ;
26118 wxRect *arg2 = 0 ;
26119 wxRect temp2 ;
26120 PyObject * obj0 = 0 ;
26121 PyObject * obj1 = 0 ;
26122 char *kwnames[] = {
26123 (char *) "self",(char *) "rect", NULL
26124 };
26125
26126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26128 if (SWIG_arg_fail(1)) SWIG_fail;
26129 {
26130 arg2 = &temp2;
26131 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26132 }
26133 {
26134 PyThreadState* __tstate = wxPyBeginAllowThreads();
26135 (arg1)->SetClientSize((wxRect const &)*arg2);
26136
26137 wxPyEndAllowThreads(__tstate);
26138 if (PyErr_Occurred()) SWIG_fail;
26139 }
26140 Py_INCREF(Py_None); resultobj = Py_None;
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj;
26149 wxWindow *arg1 = (wxWindow *) 0 ;
26150 wxPoint result;
26151 PyObject * obj0 = 0 ;
26152 char *kwnames[] = {
26153 (char *) "self", NULL
26154 };
26155
26156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26158 if (SWIG_arg_fail(1)) SWIG_fail;
26159 {
26160 PyThreadState* __tstate = wxPyBeginAllowThreads();
26161 result = (arg1)->GetPosition();
26162
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 {
26167 wxPoint * resultptr;
26168 resultptr = new wxPoint((wxPoint &)(result));
26169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26170 }
26171 return resultobj;
26172 fail:
26173 return NULL;
26174 }
26175
26176
26177 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26178 PyObject *resultobj;
26179 wxWindow *arg1 = (wxWindow *) 0 ;
26180 int *arg2 = (int *) 0 ;
26181 int *arg3 = (int *) 0 ;
26182 int temp2 ;
26183 int res2 = 0 ;
26184 int temp3 ;
26185 int res3 = 0 ;
26186 PyObject * obj0 = 0 ;
26187 char *kwnames[] = {
26188 (char *) "self", NULL
26189 };
26190
26191 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26192 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26195 if (SWIG_arg_fail(1)) SWIG_fail;
26196 {
26197 PyThreadState* __tstate = wxPyBeginAllowThreads();
26198 (arg1)->GetPosition(arg2,arg3);
26199
26200 wxPyEndAllowThreads(__tstate);
26201 if (PyErr_Occurred()) SWIG_fail;
26202 }
26203 Py_INCREF(Py_None); resultobj = Py_None;
26204 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26205 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26206 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26207 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26208 return resultobj;
26209 fail:
26210 return NULL;
26211 }
26212
26213
26214 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26215 PyObject *resultobj;
26216 wxWindow *arg1 = (wxWindow *) 0 ;
26217 wxSize result;
26218 PyObject * obj0 = 0 ;
26219 char *kwnames[] = {
26220 (char *) "self", NULL
26221 };
26222
26223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26225 if (SWIG_arg_fail(1)) SWIG_fail;
26226 {
26227 PyThreadState* __tstate = wxPyBeginAllowThreads();
26228 result = ((wxWindow const *)arg1)->GetSize();
26229
26230 wxPyEndAllowThreads(__tstate);
26231 if (PyErr_Occurred()) SWIG_fail;
26232 }
26233 {
26234 wxSize * resultptr;
26235 resultptr = new wxSize((wxSize &)(result));
26236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26237 }
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26245 PyObject *resultobj;
26246 wxWindow *arg1 = (wxWindow *) 0 ;
26247 int *arg2 = (int *) 0 ;
26248 int *arg3 = (int *) 0 ;
26249 int temp2 ;
26250 int res2 = 0 ;
26251 int temp3 ;
26252 int res3 = 0 ;
26253 PyObject * obj0 = 0 ;
26254 char *kwnames[] = {
26255 (char *) "self", NULL
26256 };
26257
26258 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26259 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26262 if (SWIG_arg_fail(1)) SWIG_fail;
26263 {
26264 PyThreadState* __tstate = wxPyBeginAllowThreads();
26265 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26266
26267 wxPyEndAllowThreads(__tstate);
26268 if (PyErr_Occurred()) SWIG_fail;
26269 }
26270 Py_INCREF(Py_None); resultobj = Py_None;
26271 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26272 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26273 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26274 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26282 PyObject *resultobj;
26283 wxWindow *arg1 = (wxWindow *) 0 ;
26284 wxRect result;
26285 PyObject * obj0 = 0 ;
26286 char *kwnames[] = {
26287 (char *) "self", NULL
26288 };
26289
26290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26292 if (SWIG_arg_fail(1)) SWIG_fail;
26293 {
26294 PyThreadState* __tstate = wxPyBeginAllowThreads();
26295 result = ((wxWindow const *)arg1)->GetRect();
26296
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 {
26301 wxRect * resultptr;
26302 resultptr = new wxRect((wxRect &)(result));
26303 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26304 }
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26312 PyObject *resultobj;
26313 wxWindow *arg1 = (wxWindow *) 0 ;
26314 wxSize result;
26315 PyObject * obj0 = 0 ;
26316 char *kwnames[] = {
26317 (char *) "self", NULL
26318 };
26319
26320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26322 if (SWIG_arg_fail(1)) SWIG_fail;
26323 {
26324 PyThreadState* __tstate = wxPyBeginAllowThreads();
26325 result = ((wxWindow const *)arg1)->GetClientSize();
26326
26327 wxPyEndAllowThreads(__tstate);
26328 if (PyErr_Occurred()) SWIG_fail;
26329 }
26330 {
26331 wxSize * resultptr;
26332 resultptr = new wxSize((wxSize &)(result));
26333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26334 }
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj;
26343 wxWindow *arg1 = (wxWindow *) 0 ;
26344 int *arg2 = (int *) 0 ;
26345 int *arg3 = (int *) 0 ;
26346 int temp2 ;
26347 int res2 = 0 ;
26348 int temp3 ;
26349 int res3 = 0 ;
26350 PyObject * obj0 = 0 ;
26351 char *kwnames[] = {
26352 (char *) "self", NULL
26353 };
26354
26355 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26356 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26359 if (SWIG_arg_fail(1)) SWIG_fail;
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26363
26364 wxPyEndAllowThreads(__tstate);
26365 if (PyErr_Occurred()) SWIG_fail;
26366 }
26367 Py_INCREF(Py_None); resultobj = Py_None;
26368 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26369 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26370 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26371 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26379 PyObject *resultobj;
26380 wxWindow *arg1 = (wxWindow *) 0 ;
26381 wxPoint result;
26382 PyObject * obj0 = 0 ;
26383 char *kwnames[] = {
26384 (char *) "self", NULL
26385 };
26386
26387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26389 if (SWIG_arg_fail(1)) SWIG_fail;
26390 {
26391 PyThreadState* __tstate = wxPyBeginAllowThreads();
26392 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26393
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 {
26398 wxPoint * resultptr;
26399 resultptr = new wxPoint((wxPoint &)(result));
26400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26401 }
26402 return resultobj;
26403 fail:
26404 return NULL;
26405 }
26406
26407
26408 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26409 PyObject *resultobj;
26410 wxWindow *arg1 = (wxWindow *) 0 ;
26411 wxRect result;
26412 PyObject * obj0 = 0 ;
26413 char *kwnames[] = {
26414 (char *) "self", NULL
26415 };
26416
26417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26419 if (SWIG_arg_fail(1)) SWIG_fail;
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 result = ((wxWindow const *)arg1)->GetClientRect();
26423
26424 wxPyEndAllowThreads(__tstate);
26425 if (PyErr_Occurred()) SWIG_fail;
26426 }
26427 {
26428 wxRect * resultptr;
26429 resultptr = new wxRect((wxRect &)(result));
26430 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26431 }
26432 return resultobj;
26433 fail:
26434 return NULL;
26435 }
26436
26437
26438 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26439 PyObject *resultobj;
26440 wxWindow *arg1 = (wxWindow *) 0 ;
26441 wxSize result;
26442 PyObject * obj0 = 0 ;
26443 char *kwnames[] = {
26444 (char *) "self", NULL
26445 };
26446
26447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26449 if (SWIG_arg_fail(1)) SWIG_fail;
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = ((wxWindow const *)arg1)->GetBestSize();
26453
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 {
26458 wxSize * resultptr;
26459 resultptr = new wxSize((wxSize &)(result));
26460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26461 }
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26469 PyObject *resultobj;
26470 wxWindow *arg1 = (wxWindow *) 0 ;
26471 int *arg2 = (int *) 0 ;
26472 int *arg3 = (int *) 0 ;
26473 int temp2 ;
26474 int res2 = 0 ;
26475 int temp3 ;
26476 int res3 = 0 ;
26477 PyObject * obj0 = 0 ;
26478 char *kwnames[] = {
26479 (char *) "self", NULL
26480 };
26481
26482 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26483 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26486 if (SWIG_arg_fail(1)) SWIG_fail;
26487 {
26488 PyThreadState* __tstate = wxPyBeginAllowThreads();
26489 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26490
26491 wxPyEndAllowThreads(__tstate);
26492 if (PyErr_Occurred()) SWIG_fail;
26493 }
26494 Py_INCREF(Py_None); resultobj = Py_None;
26495 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26496 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26497 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26498 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26506 PyObject *resultobj;
26507 wxWindow *arg1 = (wxWindow *) 0 ;
26508 PyObject * obj0 = 0 ;
26509 char *kwnames[] = {
26510 (char *) "self", NULL
26511 };
26512
26513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26515 if (SWIG_arg_fail(1)) SWIG_fail;
26516 {
26517 PyThreadState* __tstate = wxPyBeginAllowThreads();
26518 (arg1)->InvalidateBestSize();
26519
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 Py_INCREF(Py_None); resultobj = Py_None;
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj;
26532 wxWindow *arg1 = (wxWindow *) 0 ;
26533 wxSize *arg2 = 0 ;
26534 wxSize temp2 ;
26535 PyObject * obj0 = 0 ;
26536 PyObject * obj1 = 0 ;
26537 char *kwnames[] = {
26538 (char *) "self",(char *) "size", NULL
26539 };
26540
26541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
26542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26543 if (SWIG_arg_fail(1)) SWIG_fail;
26544 {
26545 arg2 = &temp2;
26546 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26547 }
26548 {
26549 PyThreadState* __tstate = wxPyBeginAllowThreads();
26550 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
26551
26552 wxPyEndAllowThreads(__tstate);
26553 if (PyErr_Occurred()) SWIG_fail;
26554 }
26555 Py_INCREF(Py_None); resultobj = Py_None;
26556 return resultobj;
26557 fail:
26558 return NULL;
26559 }
26560
26561
26562 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26563 PyObject *resultobj;
26564 wxWindow *arg1 = (wxWindow *) 0 ;
26565 wxSize result;
26566 PyObject * obj0 = 0 ;
26567 char *kwnames[] = {
26568 (char *) "self", NULL
26569 };
26570
26571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26573 if (SWIG_arg_fail(1)) SWIG_fail;
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26577
26578 wxPyEndAllowThreads(__tstate);
26579 if (PyErr_Occurred()) SWIG_fail;
26580 }
26581 {
26582 wxSize * resultptr;
26583 resultptr = new wxSize((wxSize &)(result));
26584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26585 }
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26593 PyObject *resultobj;
26594 wxWindow *arg1 = (wxWindow *) 0 ;
26595 wxSize result;
26596 PyObject * obj0 = 0 ;
26597 char *kwnames[] = {
26598 (char *) "self", NULL
26599 };
26600
26601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26603 if (SWIG_arg_fail(1)) SWIG_fail;
26604 {
26605 PyThreadState* __tstate = wxPyBeginAllowThreads();
26606 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26607
26608 wxPyEndAllowThreads(__tstate);
26609 if (PyErr_Occurred()) SWIG_fail;
26610 }
26611 {
26612 wxSize * resultptr;
26613 resultptr = new wxSize((wxSize &)(result));
26614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26615 }
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26623 PyObject *resultobj;
26624 wxWindow *arg1 = (wxWindow *) 0 ;
26625 int arg2 = (int) wxBOTH ;
26626 PyObject * obj0 = 0 ;
26627 PyObject * obj1 = 0 ;
26628 char *kwnames[] = {
26629 (char *) "self",(char *) "direction", NULL
26630 };
26631
26632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26634 if (SWIG_arg_fail(1)) SWIG_fail;
26635 if (obj1) {
26636 {
26637 arg2 = (int)(SWIG_As_int(obj1));
26638 if (SWIG_arg_fail(2)) SWIG_fail;
26639 }
26640 }
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 (arg1)->Center(arg2);
26644
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 Py_INCREF(Py_None); resultobj = Py_None;
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26656 PyObject *resultobj;
26657 wxWindow *arg1 = (wxWindow *) 0 ;
26658 int arg2 = (int) wxBOTH ;
26659 PyObject * obj0 = 0 ;
26660 PyObject * obj1 = 0 ;
26661 char *kwnames[] = {
26662 (char *) "self",(char *) "dir", NULL
26663 };
26664
26665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26667 if (SWIG_arg_fail(1)) SWIG_fail;
26668 if (obj1) {
26669 {
26670 arg2 = (int)(SWIG_As_int(obj1));
26671 if (SWIG_arg_fail(2)) SWIG_fail;
26672 }
26673 }
26674 {
26675 PyThreadState* __tstate = wxPyBeginAllowThreads();
26676 (arg1)->CenterOnScreen(arg2);
26677
26678 wxPyEndAllowThreads(__tstate);
26679 if (PyErr_Occurred()) SWIG_fail;
26680 }
26681 Py_INCREF(Py_None); resultobj = Py_None;
26682 return resultobj;
26683 fail:
26684 return NULL;
26685 }
26686
26687
26688 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26689 PyObject *resultobj;
26690 wxWindow *arg1 = (wxWindow *) 0 ;
26691 int arg2 = (int) wxBOTH ;
26692 PyObject * obj0 = 0 ;
26693 PyObject * obj1 = 0 ;
26694 char *kwnames[] = {
26695 (char *) "self",(char *) "dir", NULL
26696 };
26697
26698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26700 if (SWIG_arg_fail(1)) SWIG_fail;
26701 if (obj1) {
26702 {
26703 arg2 = (int)(SWIG_As_int(obj1));
26704 if (SWIG_arg_fail(2)) SWIG_fail;
26705 }
26706 }
26707 {
26708 PyThreadState* __tstate = wxPyBeginAllowThreads();
26709 (arg1)->CenterOnParent(arg2);
26710
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 Py_INCREF(Py_None); resultobj = Py_None;
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj;
26723 wxWindow *arg1 = (wxWindow *) 0 ;
26724 PyObject * obj0 = 0 ;
26725 char *kwnames[] = {
26726 (char *) "self", NULL
26727 };
26728
26729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26731 if (SWIG_arg_fail(1)) SWIG_fail;
26732 {
26733 PyThreadState* __tstate = wxPyBeginAllowThreads();
26734 (arg1)->Fit();
26735
26736 wxPyEndAllowThreads(__tstate);
26737 if (PyErr_Occurred()) SWIG_fail;
26738 }
26739 Py_INCREF(Py_None); resultobj = Py_None;
26740 return resultobj;
26741 fail:
26742 return NULL;
26743 }
26744
26745
26746 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26747 PyObject *resultobj;
26748 wxWindow *arg1 = (wxWindow *) 0 ;
26749 PyObject * obj0 = 0 ;
26750 char *kwnames[] = {
26751 (char *) "self", NULL
26752 };
26753
26754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26756 if (SWIG_arg_fail(1)) SWIG_fail;
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 (arg1)->FitInside();
26760
26761 wxPyEndAllowThreads(__tstate);
26762 if (PyErr_Occurred()) SWIG_fail;
26763 }
26764 Py_INCREF(Py_None); resultobj = Py_None;
26765 return resultobj;
26766 fail:
26767 return NULL;
26768 }
26769
26770
26771 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26772 PyObject *resultobj;
26773 wxWindow *arg1 = (wxWindow *) 0 ;
26774 int arg2 ;
26775 int arg3 ;
26776 int arg4 = (int) -1 ;
26777 int arg5 = (int) -1 ;
26778 int arg6 = (int) -1 ;
26779 int arg7 = (int) -1 ;
26780 PyObject * obj0 = 0 ;
26781 PyObject * obj1 = 0 ;
26782 PyObject * obj2 = 0 ;
26783 PyObject * obj3 = 0 ;
26784 PyObject * obj4 = 0 ;
26785 PyObject * obj5 = 0 ;
26786 PyObject * obj6 = 0 ;
26787 char *kwnames[] = {
26788 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26789 };
26790
26791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26793 if (SWIG_arg_fail(1)) SWIG_fail;
26794 {
26795 arg2 = (int)(SWIG_As_int(obj1));
26796 if (SWIG_arg_fail(2)) SWIG_fail;
26797 }
26798 {
26799 arg3 = (int)(SWIG_As_int(obj2));
26800 if (SWIG_arg_fail(3)) SWIG_fail;
26801 }
26802 if (obj3) {
26803 {
26804 arg4 = (int)(SWIG_As_int(obj3));
26805 if (SWIG_arg_fail(4)) SWIG_fail;
26806 }
26807 }
26808 if (obj4) {
26809 {
26810 arg5 = (int)(SWIG_As_int(obj4));
26811 if (SWIG_arg_fail(5)) SWIG_fail;
26812 }
26813 }
26814 if (obj5) {
26815 {
26816 arg6 = (int)(SWIG_As_int(obj5));
26817 if (SWIG_arg_fail(6)) SWIG_fail;
26818 }
26819 }
26820 if (obj6) {
26821 {
26822 arg7 = (int)(SWIG_As_int(obj6));
26823 if (SWIG_arg_fail(7)) SWIG_fail;
26824 }
26825 }
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26829
26830 wxPyEndAllowThreads(__tstate);
26831 if (PyErr_Occurred()) SWIG_fail;
26832 }
26833 Py_INCREF(Py_None); resultobj = Py_None;
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26841 PyObject *resultobj;
26842 wxWindow *arg1 = (wxWindow *) 0 ;
26843 wxSize *arg2 = 0 ;
26844 wxSize const &arg3_defvalue = wxDefaultSize ;
26845 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26846 wxSize const &arg4_defvalue = wxDefaultSize ;
26847 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26848 wxSize temp2 ;
26849 wxSize temp3 ;
26850 wxSize temp4 ;
26851 PyObject * obj0 = 0 ;
26852 PyObject * obj1 = 0 ;
26853 PyObject * obj2 = 0 ;
26854 PyObject * obj3 = 0 ;
26855 char *kwnames[] = {
26856 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26857 };
26858
26859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26861 if (SWIG_arg_fail(1)) SWIG_fail;
26862 {
26863 arg2 = &temp2;
26864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26865 }
26866 if (obj2) {
26867 {
26868 arg3 = &temp3;
26869 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26870 }
26871 }
26872 if (obj3) {
26873 {
26874 arg4 = &temp4;
26875 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26876 }
26877 }
26878 {
26879 PyThreadState* __tstate = wxPyBeginAllowThreads();
26880 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26881
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 Py_INCREF(Py_None); resultobj = Py_None;
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj;
26894 wxWindow *arg1 = (wxWindow *) 0 ;
26895 int arg2 ;
26896 int arg3 ;
26897 int arg4 = (int) -1 ;
26898 int arg5 = (int) -1 ;
26899 PyObject * obj0 = 0 ;
26900 PyObject * obj1 = 0 ;
26901 PyObject * obj2 = 0 ;
26902 PyObject * obj3 = 0 ;
26903 PyObject * obj4 = 0 ;
26904 char *kwnames[] = {
26905 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26906 };
26907
26908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26910 if (SWIG_arg_fail(1)) SWIG_fail;
26911 {
26912 arg2 = (int)(SWIG_As_int(obj1));
26913 if (SWIG_arg_fail(2)) SWIG_fail;
26914 }
26915 {
26916 arg3 = (int)(SWIG_As_int(obj2));
26917 if (SWIG_arg_fail(3)) SWIG_fail;
26918 }
26919 if (obj3) {
26920 {
26921 arg4 = (int)(SWIG_As_int(obj3));
26922 if (SWIG_arg_fail(4)) SWIG_fail;
26923 }
26924 }
26925 if (obj4) {
26926 {
26927 arg5 = (int)(SWIG_As_int(obj4));
26928 if (SWIG_arg_fail(5)) SWIG_fail;
26929 }
26930 }
26931 {
26932 PyThreadState* __tstate = wxPyBeginAllowThreads();
26933 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26934
26935 wxPyEndAllowThreads(__tstate);
26936 if (PyErr_Occurred()) SWIG_fail;
26937 }
26938 Py_INCREF(Py_None); resultobj = Py_None;
26939 return resultobj;
26940 fail:
26941 return NULL;
26942 }
26943
26944
26945 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26946 PyObject *resultobj;
26947 wxWindow *arg1 = (wxWindow *) 0 ;
26948 wxSize *arg2 = 0 ;
26949 wxSize const &arg3_defvalue = wxDefaultSize ;
26950 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26951 wxSize temp2 ;
26952 wxSize temp3 ;
26953 PyObject * obj0 = 0 ;
26954 PyObject * obj1 = 0 ;
26955 PyObject * obj2 = 0 ;
26956 char *kwnames[] = {
26957 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26958 };
26959
26960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26962 if (SWIG_arg_fail(1)) SWIG_fail;
26963 {
26964 arg2 = &temp2;
26965 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26966 }
26967 if (obj2) {
26968 {
26969 arg3 = &temp3;
26970 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26971 }
26972 }
26973 {
26974 PyThreadState* __tstate = wxPyBeginAllowThreads();
26975 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26976
26977 wxPyEndAllowThreads(__tstate);
26978 if (PyErr_Occurred()) SWIG_fail;
26979 }
26980 Py_INCREF(Py_None); resultobj = Py_None;
26981 return resultobj;
26982 fail:
26983 return NULL;
26984 }
26985
26986
26987 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26988 PyObject *resultobj;
26989 wxWindow *arg1 = (wxWindow *) 0 ;
26990 wxSize result;
26991 PyObject * obj0 = 0 ;
26992 char *kwnames[] = {
26993 (char *) "self", NULL
26994 };
26995
26996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26998 if (SWIG_arg_fail(1)) SWIG_fail;
26999 {
27000 PyThreadState* __tstate = wxPyBeginAllowThreads();
27001 result = ((wxWindow const *)arg1)->GetMaxSize();
27002
27003 wxPyEndAllowThreads(__tstate);
27004 if (PyErr_Occurred()) SWIG_fail;
27005 }
27006 {
27007 wxSize * resultptr;
27008 resultptr = new wxSize((wxSize &)(result));
27009 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27010 }
27011 return resultobj;
27012 fail:
27013 return NULL;
27014 }
27015
27016
27017 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27018 PyObject *resultobj;
27019 wxWindow *arg1 = (wxWindow *) 0 ;
27020 wxSize result;
27021 PyObject * obj0 = 0 ;
27022 char *kwnames[] = {
27023 (char *) "self", NULL
27024 };
27025
27026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27028 if (SWIG_arg_fail(1)) SWIG_fail;
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 result = ((wxWindow const *)arg1)->GetMinSize();
27032
27033 wxPyEndAllowThreads(__tstate);
27034 if (PyErr_Occurred()) SWIG_fail;
27035 }
27036 {
27037 wxSize * resultptr;
27038 resultptr = new wxSize((wxSize &)(result));
27039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27040 }
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj;
27049 wxWindow *arg1 = (wxWindow *) 0 ;
27050 wxSize *arg2 = 0 ;
27051 wxSize temp2 ;
27052 PyObject * obj0 = 0 ;
27053 PyObject * obj1 = 0 ;
27054 char *kwnames[] = {
27055 (char *) "self",(char *) "minSize", NULL
27056 };
27057
27058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27060 if (SWIG_arg_fail(1)) SWIG_fail;
27061 {
27062 arg2 = &temp2;
27063 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27064 }
27065 {
27066 PyThreadState* __tstate = wxPyBeginAllowThreads();
27067 (arg1)->SetMinSize((wxSize const &)*arg2);
27068
27069 wxPyEndAllowThreads(__tstate);
27070 if (PyErr_Occurred()) SWIG_fail;
27071 }
27072 Py_INCREF(Py_None); resultobj = Py_None;
27073 return resultobj;
27074 fail:
27075 return NULL;
27076 }
27077
27078
27079 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27080 PyObject *resultobj;
27081 wxWindow *arg1 = (wxWindow *) 0 ;
27082 wxSize *arg2 = 0 ;
27083 wxSize temp2 ;
27084 PyObject * obj0 = 0 ;
27085 PyObject * obj1 = 0 ;
27086 char *kwnames[] = {
27087 (char *) "self",(char *) "maxSize", NULL
27088 };
27089
27090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27092 if (SWIG_arg_fail(1)) SWIG_fail;
27093 {
27094 arg2 = &temp2;
27095 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27096 }
27097 {
27098 PyThreadState* __tstate = wxPyBeginAllowThreads();
27099 (arg1)->SetMaxSize((wxSize const &)*arg2);
27100
27101 wxPyEndAllowThreads(__tstate);
27102 if (PyErr_Occurred()) SWIG_fail;
27103 }
27104 Py_INCREF(Py_None); resultobj = Py_None;
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27112 PyObject *resultobj;
27113 wxWindow *arg1 = (wxWindow *) 0 ;
27114 int result;
27115 PyObject * obj0 = 0 ;
27116 char *kwnames[] = {
27117 (char *) "self", NULL
27118 };
27119
27120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27122 if (SWIG_arg_fail(1)) SWIG_fail;
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27126
27127 wxPyEndAllowThreads(__tstate);
27128 if (PyErr_Occurred()) SWIG_fail;
27129 }
27130 {
27131 resultobj = SWIG_From_int((int)(result));
27132 }
27133 return resultobj;
27134 fail:
27135 return NULL;
27136 }
27137
27138
27139 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27140 PyObject *resultobj;
27141 wxWindow *arg1 = (wxWindow *) 0 ;
27142 int result;
27143 PyObject * obj0 = 0 ;
27144 char *kwnames[] = {
27145 (char *) "self", NULL
27146 };
27147
27148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27150 if (SWIG_arg_fail(1)) SWIG_fail;
27151 {
27152 PyThreadState* __tstate = wxPyBeginAllowThreads();
27153 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27154
27155 wxPyEndAllowThreads(__tstate);
27156 if (PyErr_Occurred()) SWIG_fail;
27157 }
27158 {
27159 resultobj = SWIG_From_int((int)(result));
27160 }
27161 return resultobj;
27162 fail:
27163 return NULL;
27164 }
27165
27166
27167 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27168 PyObject *resultobj;
27169 wxWindow *arg1 = (wxWindow *) 0 ;
27170 int result;
27171 PyObject * obj0 = 0 ;
27172 char *kwnames[] = {
27173 (char *) "self", NULL
27174 };
27175
27176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27178 if (SWIG_arg_fail(1)) SWIG_fail;
27179 {
27180 PyThreadState* __tstate = wxPyBeginAllowThreads();
27181 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27182
27183 wxPyEndAllowThreads(__tstate);
27184 if (PyErr_Occurred()) SWIG_fail;
27185 }
27186 {
27187 resultobj = SWIG_From_int((int)(result));
27188 }
27189 return resultobj;
27190 fail:
27191 return NULL;
27192 }
27193
27194
27195 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27196 PyObject *resultobj;
27197 wxWindow *arg1 = (wxWindow *) 0 ;
27198 int result;
27199 PyObject * obj0 = 0 ;
27200 char *kwnames[] = {
27201 (char *) "self", NULL
27202 };
27203
27204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27206 if (SWIG_arg_fail(1)) SWIG_fail;
27207 {
27208 PyThreadState* __tstate = wxPyBeginAllowThreads();
27209 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27210
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 {
27215 resultobj = SWIG_From_int((int)(result));
27216 }
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27224 PyObject *resultobj;
27225 wxWindow *arg1 = (wxWindow *) 0 ;
27226 wxSize *arg2 = 0 ;
27227 wxSize temp2 ;
27228 PyObject * obj0 = 0 ;
27229 PyObject * obj1 = 0 ;
27230 char *kwnames[] = {
27231 (char *) "self",(char *) "size", NULL
27232 };
27233
27234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27236 if (SWIG_arg_fail(1)) SWIG_fail;
27237 {
27238 arg2 = &temp2;
27239 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27240 }
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27244
27245 wxPyEndAllowThreads(__tstate);
27246 if (PyErr_Occurred()) SWIG_fail;
27247 }
27248 Py_INCREF(Py_None); resultobj = Py_None;
27249 return resultobj;
27250 fail:
27251 return NULL;
27252 }
27253
27254
27255 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27256 PyObject *resultobj;
27257 wxWindow *arg1 = (wxWindow *) 0 ;
27258 int arg2 ;
27259 int arg3 ;
27260 PyObject * obj0 = 0 ;
27261 PyObject * obj1 = 0 ;
27262 PyObject * obj2 = 0 ;
27263 char *kwnames[] = {
27264 (char *) "self",(char *) "w",(char *) "h", NULL
27265 };
27266
27267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27269 if (SWIG_arg_fail(1)) SWIG_fail;
27270 {
27271 arg2 = (int)(SWIG_As_int(obj1));
27272 if (SWIG_arg_fail(2)) SWIG_fail;
27273 }
27274 {
27275 arg3 = (int)(SWIG_As_int(obj2));
27276 if (SWIG_arg_fail(3)) SWIG_fail;
27277 }
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 (arg1)->SetVirtualSize(arg2,arg3);
27281
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 Py_INCREF(Py_None); resultobj = Py_None;
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27293 PyObject *resultobj;
27294 wxWindow *arg1 = (wxWindow *) 0 ;
27295 wxSize result;
27296 PyObject * obj0 = 0 ;
27297 char *kwnames[] = {
27298 (char *) "self", NULL
27299 };
27300
27301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27303 if (SWIG_arg_fail(1)) SWIG_fail;
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 result = ((wxWindow const *)arg1)->GetVirtualSize();
27307
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 {
27312 wxSize * resultptr;
27313 resultptr = new wxSize((wxSize &)(result));
27314 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27315 }
27316 return resultobj;
27317 fail:
27318 return NULL;
27319 }
27320
27321
27322 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27323 PyObject *resultobj;
27324 wxWindow *arg1 = (wxWindow *) 0 ;
27325 int *arg2 = (int *) 0 ;
27326 int *arg3 = (int *) 0 ;
27327 int temp2 ;
27328 int res2 = 0 ;
27329 int temp3 ;
27330 int res3 = 0 ;
27331 PyObject * obj0 = 0 ;
27332 char *kwnames[] = {
27333 (char *) "self", NULL
27334 };
27335
27336 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27337 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27340 if (SWIG_arg_fail(1)) SWIG_fail;
27341 {
27342 PyThreadState* __tstate = wxPyBeginAllowThreads();
27343 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27344
27345 wxPyEndAllowThreads(__tstate);
27346 if (PyErr_Occurred()) SWIG_fail;
27347 }
27348 Py_INCREF(Py_None); resultobj = Py_None;
27349 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27350 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27351 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27352 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27353 return resultobj;
27354 fail:
27355 return NULL;
27356 }
27357
27358
27359 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27360 PyObject *resultobj;
27361 wxWindow *arg1 = (wxWindow *) 0 ;
27362 wxSize result;
27363 PyObject * obj0 = 0 ;
27364 char *kwnames[] = {
27365 (char *) "self", NULL
27366 };
27367
27368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27370 if (SWIG_arg_fail(1)) SWIG_fail;
27371 {
27372 PyThreadState* __tstate = wxPyBeginAllowThreads();
27373 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27374
27375 wxPyEndAllowThreads(__tstate);
27376 if (PyErr_Occurred()) SWIG_fail;
27377 }
27378 {
27379 wxSize * resultptr;
27380 resultptr = new wxSize((wxSize &)(result));
27381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27382 }
27383 return resultobj;
27384 fail:
27385 return NULL;
27386 }
27387
27388
27389 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27390 PyObject *resultobj;
27391 wxWindow *arg1 = (wxWindow *) 0 ;
27392 bool arg2 = (bool) true ;
27393 bool result;
27394 PyObject * obj0 = 0 ;
27395 PyObject * obj1 = 0 ;
27396 char *kwnames[] = {
27397 (char *) "self",(char *) "show", NULL
27398 };
27399
27400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27402 if (SWIG_arg_fail(1)) SWIG_fail;
27403 if (obj1) {
27404 {
27405 arg2 = (bool)(SWIG_As_bool(obj1));
27406 if (SWIG_arg_fail(2)) SWIG_fail;
27407 }
27408 }
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 result = (bool)(arg1)->Show(arg2);
27412
27413 wxPyEndAllowThreads(__tstate);
27414 if (PyErr_Occurred()) SWIG_fail;
27415 }
27416 {
27417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27418 }
27419 return resultobj;
27420 fail:
27421 return NULL;
27422 }
27423
27424
27425 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27426 PyObject *resultobj;
27427 wxWindow *arg1 = (wxWindow *) 0 ;
27428 bool result;
27429 PyObject * obj0 = 0 ;
27430 char *kwnames[] = {
27431 (char *) "self", NULL
27432 };
27433
27434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27436 if (SWIG_arg_fail(1)) SWIG_fail;
27437 {
27438 PyThreadState* __tstate = wxPyBeginAllowThreads();
27439 result = (bool)(arg1)->Hide();
27440
27441 wxPyEndAllowThreads(__tstate);
27442 if (PyErr_Occurred()) SWIG_fail;
27443 }
27444 {
27445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27446 }
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27454 PyObject *resultobj;
27455 wxWindow *arg1 = (wxWindow *) 0 ;
27456 bool arg2 = (bool) true ;
27457 bool result;
27458 PyObject * obj0 = 0 ;
27459 PyObject * obj1 = 0 ;
27460 char *kwnames[] = {
27461 (char *) "self",(char *) "enable", NULL
27462 };
27463
27464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27466 if (SWIG_arg_fail(1)) SWIG_fail;
27467 if (obj1) {
27468 {
27469 arg2 = (bool)(SWIG_As_bool(obj1));
27470 if (SWIG_arg_fail(2)) SWIG_fail;
27471 }
27472 }
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 result = (bool)(arg1)->Enable(arg2);
27476
27477 wxPyEndAllowThreads(__tstate);
27478 if (PyErr_Occurred()) SWIG_fail;
27479 }
27480 {
27481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27482 }
27483 return resultobj;
27484 fail:
27485 return NULL;
27486 }
27487
27488
27489 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27490 PyObject *resultobj;
27491 wxWindow *arg1 = (wxWindow *) 0 ;
27492 bool result;
27493 PyObject * obj0 = 0 ;
27494 char *kwnames[] = {
27495 (char *) "self", NULL
27496 };
27497
27498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27500 if (SWIG_arg_fail(1)) SWIG_fail;
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 result = (bool)(arg1)->Disable();
27504
27505 wxPyEndAllowThreads(__tstate);
27506 if (PyErr_Occurred()) SWIG_fail;
27507 }
27508 {
27509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27510 }
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27518 PyObject *resultobj;
27519 wxWindow *arg1 = (wxWindow *) 0 ;
27520 bool result;
27521 PyObject * obj0 = 0 ;
27522 char *kwnames[] = {
27523 (char *) "self", NULL
27524 };
27525
27526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27528 if (SWIG_arg_fail(1)) SWIG_fail;
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = (bool)((wxWindow const *)arg1)->IsShown();
27532
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 {
27537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27538 }
27539 return resultobj;
27540 fail:
27541 return NULL;
27542 }
27543
27544
27545 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27546 PyObject *resultobj;
27547 wxWindow *arg1 = (wxWindow *) 0 ;
27548 bool result;
27549 PyObject * obj0 = 0 ;
27550 char *kwnames[] = {
27551 (char *) "self", NULL
27552 };
27553
27554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27556 if (SWIG_arg_fail(1)) SWIG_fail;
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27560
27561 wxPyEndAllowThreads(__tstate);
27562 if (PyErr_Occurred()) SWIG_fail;
27563 }
27564 {
27565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27566 }
27567 return resultobj;
27568 fail:
27569 return NULL;
27570 }
27571
27572
27573 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27574 PyObject *resultobj;
27575 wxWindow *arg1 = (wxWindow *) 0 ;
27576 long arg2 ;
27577 PyObject * obj0 = 0 ;
27578 PyObject * obj1 = 0 ;
27579 char *kwnames[] = {
27580 (char *) "self",(char *) "style", NULL
27581 };
27582
27583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27585 if (SWIG_arg_fail(1)) SWIG_fail;
27586 {
27587 arg2 = (long)(SWIG_As_long(obj1));
27588 if (SWIG_arg_fail(2)) SWIG_fail;
27589 }
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 (arg1)->SetWindowStyleFlag(arg2);
27593
27594 wxPyEndAllowThreads(__tstate);
27595 if (PyErr_Occurred()) SWIG_fail;
27596 }
27597 Py_INCREF(Py_None); resultobj = Py_None;
27598 return resultobj;
27599 fail:
27600 return NULL;
27601 }
27602
27603
27604 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27605 PyObject *resultobj;
27606 wxWindow *arg1 = (wxWindow *) 0 ;
27607 long result;
27608 PyObject * obj0 = 0 ;
27609 char *kwnames[] = {
27610 (char *) "self", NULL
27611 };
27612
27613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27615 if (SWIG_arg_fail(1)) SWIG_fail;
27616 {
27617 PyThreadState* __tstate = wxPyBeginAllowThreads();
27618 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27619
27620 wxPyEndAllowThreads(__tstate);
27621 if (PyErr_Occurred()) SWIG_fail;
27622 }
27623 {
27624 resultobj = SWIG_From_long((long)(result));
27625 }
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27633 PyObject *resultobj;
27634 wxWindow *arg1 = (wxWindow *) 0 ;
27635 int arg2 ;
27636 bool result;
27637 PyObject * obj0 = 0 ;
27638 PyObject * obj1 = 0 ;
27639 char *kwnames[] = {
27640 (char *) "self",(char *) "flag", NULL
27641 };
27642
27643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27645 if (SWIG_arg_fail(1)) SWIG_fail;
27646 {
27647 arg2 = (int)(SWIG_As_int(obj1));
27648 if (SWIG_arg_fail(2)) SWIG_fail;
27649 }
27650 {
27651 PyThreadState* __tstate = wxPyBeginAllowThreads();
27652 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27653
27654 wxPyEndAllowThreads(__tstate);
27655 if (PyErr_Occurred()) SWIG_fail;
27656 }
27657 {
27658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27659 }
27660 return resultobj;
27661 fail:
27662 return NULL;
27663 }
27664
27665
27666 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27667 PyObject *resultobj;
27668 wxWindow *arg1 = (wxWindow *) 0 ;
27669 bool result;
27670 PyObject * obj0 = 0 ;
27671 char *kwnames[] = {
27672 (char *) "self", NULL
27673 };
27674
27675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27677 if (SWIG_arg_fail(1)) SWIG_fail;
27678 {
27679 PyThreadState* __tstate = wxPyBeginAllowThreads();
27680 result = (bool)((wxWindow const *)arg1)->IsRetained();
27681
27682 wxPyEndAllowThreads(__tstate);
27683 if (PyErr_Occurred()) SWIG_fail;
27684 }
27685 {
27686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27687 }
27688 return resultobj;
27689 fail:
27690 return NULL;
27691 }
27692
27693
27694 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27695 PyObject *resultobj;
27696 wxWindow *arg1 = (wxWindow *) 0 ;
27697 long arg2 ;
27698 PyObject * obj0 = 0 ;
27699 PyObject * obj1 = 0 ;
27700 char *kwnames[] = {
27701 (char *) "self",(char *) "exStyle", NULL
27702 };
27703
27704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27706 if (SWIG_arg_fail(1)) SWIG_fail;
27707 {
27708 arg2 = (long)(SWIG_As_long(obj1));
27709 if (SWIG_arg_fail(2)) SWIG_fail;
27710 }
27711 {
27712 PyThreadState* __tstate = wxPyBeginAllowThreads();
27713 (arg1)->SetExtraStyle(arg2);
27714
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 Py_INCREF(Py_None); resultobj = Py_None;
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj;
27727 wxWindow *arg1 = (wxWindow *) 0 ;
27728 long result;
27729 PyObject * obj0 = 0 ;
27730 char *kwnames[] = {
27731 (char *) "self", NULL
27732 };
27733
27734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27736 if (SWIG_arg_fail(1)) SWIG_fail;
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27740
27741 wxPyEndAllowThreads(__tstate);
27742 if (PyErr_Occurred()) SWIG_fail;
27743 }
27744 {
27745 resultobj = SWIG_From_long((long)(result));
27746 }
27747 return resultobj;
27748 fail:
27749 return NULL;
27750 }
27751
27752
27753 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27754 PyObject *resultobj;
27755 wxWindow *arg1 = (wxWindow *) 0 ;
27756 bool arg2 = (bool) true ;
27757 PyObject * obj0 = 0 ;
27758 PyObject * obj1 = 0 ;
27759 char *kwnames[] = {
27760 (char *) "self",(char *) "modal", NULL
27761 };
27762
27763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27765 if (SWIG_arg_fail(1)) SWIG_fail;
27766 if (obj1) {
27767 {
27768 arg2 = (bool)(SWIG_As_bool(obj1));
27769 if (SWIG_arg_fail(2)) SWIG_fail;
27770 }
27771 }
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 (arg1)->MakeModal(arg2);
27775
27776 wxPyEndAllowThreads(__tstate);
27777 if (PyErr_Occurred()) SWIG_fail;
27778 }
27779 Py_INCREF(Py_None); resultobj = Py_None;
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27787 PyObject *resultobj;
27788 wxWindow *arg1 = (wxWindow *) 0 ;
27789 bool arg2 ;
27790 PyObject * obj0 = 0 ;
27791 PyObject * obj1 = 0 ;
27792 char *kwnames[] = {
27793 (char *) "self",(char *) "enableTheme", NULL
27794 };
27795
27796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27798 if (SWIG_arg_fail(1)) SWIG_fail;
27799 {
27800 arg2 = (bool)(SWIG_As_bool(obj1));
27801 if (SWIG_arg_fail(2)) SWIG_fail;
27802 }
27803 {
27804 PyThreadState* __tstate = wxPyBeginAllowThreads();
27805 (arg1)->SetThemeEnabled(arg2);
27806
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 Py_INCREF(Py_None); resultobj = Py_None;
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27818 PyObject *resultobj;
27819 wxWindow *arg1 = (wxWindow *) 0 ;
27820 bool result;
27821 PyObject * obj0 = 0 ;
27822 char *kwnames[] = {
27823 (char *) "self", NULL
27824 };
27825
27826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27828 if (SWIG_arg_fail(1)) SWIG_fail;
27829 {
27830 PyThreadState* __tstate = wxPyBeginAllowThreads();
27831 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27832
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 {
27837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27838 }
27839 return resultobj;
27840 fail:
27841 return NULL;
27842 }
27843
27844
27845 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27846 PyObject *resultobj;
27847 wxWindow *arg1 = (wxWindow *) 0 ;
27848 PyObject * obj0 = 0 ;
27849 char *kwnames[] = {
27850 (char *) "self", NULL
27851 };
27852
27853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27855 if (SWIG_arg_fail(1)) SWIG_fail;
27856 {
27857 PyThreadState* __tstate = wxPyBeginAllowThreads();
27858 (arg1)->SetFocus();
27859
27860 wxPyEndAllowThreads(__tstate);
27861 if (PyErr_Occurred()) SWIG_fail;
27862 }
27863 Py_INCREF(Py_None); resultobj = Py_None;
27864 return resultobj;
27865 fail:
27866 return NULL;
27867 }
27868
27869
27870 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27871 PyObject *resultobj;
27872 wxWindow *arg1 = (wxWindow *) 0 ;
27873 PyObject * obj0 = 0 ;
27874 char *kwnames[] = {
27875 (char *) "self", NULL
27876 };
27877
27878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27880 if (SWIG_arg_fail(1)) SWIG_fail;
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 (arg1)->SetFocusFromKbd();
27884
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 Py_INCREF(Py_None); resultobj = Py_None;
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27896 PyObject *resultobj;
27897 wxWindow *result;
27898 char *kwnames[] = {
27899 NULL
27900 };
27901
27902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27903 {
27904 if (!wxPyCheckForApp()) SWIG_fail;
27905 PyThreadState* __tstate = wxPyBeginAllowThreads();
27906 result = (wxWindow *)wxWindow::FindFocus();
27907
27908 wxPyEndAllowThreads(__tstate);
27909 if (PyErr_Occurred()) SWIG_fail;
27910 }
27911 {
27912 resultobj = wxPyMake_wxObject(result, 0);
27913 }
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27921 PyObject *resultobj;
27922 wxWindow *arg1 = (wxWindow *) 0 ;
27923 bool result;
27924 PyObject * obj0 = 0 ;
27925 char *kwnames[] = {
27926 (char *) "self", NULL
27927 };
27928
27929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27931 if (SWIG_arg_fail(1)) SWIG_fail;
27932 {
27933 PyThreadState* __tstate = wxPyBeginAllowThreads();
27934 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27935
27936 wxPyEndAllowThreads(__tstate);
27937 if (PyErr_Occurred()) SWIG_fail;
27938 }
27939 {
27940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27941 }
27942 return resultobj;
27943 fail:
27944 return NULL;
27945 }
27946
27947
27948 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27949 PyObject *resultobj;
27950 wxWindow *arg1 = (wxWindow *) 0 ;
27951 bool result;
27952 PyObject * obj0 = 0 ;
27953 char *kwnames[] = {
27954 (char *) "self", NULL
27955 };
27956
27957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27959 if (SWIG_arg_fail(1)) SWIG_fail;
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27963
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 {
27968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27969 }
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27977 PyObject *resultobj;
27978 wxWindow *arg1 = (wxWindow *) 0 ;
27979 wxWindow *result;
27980 PyObject * obj0 = 0 ;
27981 char *kwnames[] = {
27982 (char *) "self", NULL
27983 };
27984
27985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27987 if (SWIG_arg_fail(1)) SWIG_fail;
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27991
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 {
27996 resultobj = wxPyMake_wxObject(result, 0);
27997 }
27998 return resultobj;
27999 fail:
28000 return NULL;
28001 }
28002
28003
28004 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28005 PyObject *resultobj;
28006 wxWindow *arg1 = (wxWindow *) 0 ;
28007 wxWindow *arg2 = (wxWindow *) 0 ;
28008 wxWindow *result;
28009 PyObject * obj0 = 0 ;
28010 PyObject * obj1 = 0 ;
28011 char *kwnames[] = {
28012 (char *) "self",(char *) "child", NULL
28013 };
28014
28015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28017 if (SWIG_arg_fail(1)) SWIG_fail;
28018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28019 if (SWIG_arg_fail(2)) SWIG_fail;
28020 {
28021 PyThreadState* __tstate = wxPyBeginAllowThreads();
28022 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28023
28024 wxPyEndAllowThreads(__tstate);
28025 if (PyErr_Occurred()) SWIG_fail;
28026 }
28027 {
28028 resultobj = wxPyMake_wxObject(result, 0);
28029 }
28030 return resultobj;
28031 fail:
28032 return NULL;
28033 }
28034
28035
28036 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28037 PyObject *resultobj;
28038 wxWindow *arg1 = (wxWindow *) 0 ;
28039 wxWindow *arg2 = (wxWindow *) 0 ;
28040 PyObject * obj0 = 0 ;
28041 PyObject * obj1 = 0 ;
28042 char *kwnames[] = {
28043 (char *) "self",(char *) "win", NULL
28044 };
28045
28046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28048 if (SWIG_arg_fail(1)) SWIG_fail;
28049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28050 if (SWIG_arg_fail(2)) SWIG_fail;
28051 {
28052 PyThreadState* __tstate = wxPyBeginAllowThreads();
28053 (arg1)->SetTmpDefaultItem(arg2);
28054
28055 wxPyEndAllowThreads(__tstate);
28056 if (PyErr_Occurred()) SWIG_fail;
28057 }
28058 Py_INCREF(Py_None); resultobj = Py_None;
28059 return resultobj;
28060 fail:
28061 return NULL;
28062 }
28063
28064
28065 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28066 PyObject *resultobj;
28067 wxWindow *arg1 = (wxWindow *) 0 ;
28068 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28069 bool result;
28070 PyObject * obj0 = 0 ;
28071 PyObject * obj1 = 0 ;
28072 char *kwnames[] = {
28073 (char *) "self",(char *) "flags", NULL
28074 };
28075
28076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28078 if (SWIG_arg_fail(1)) SWIG_fail;
28079 if (obj1) {
28080 {
28081 arg2 = (int)(SWIG_As_int(obj1));
28082 if (SWIG_arg_fail(2)) SWIG_fail;
28083 }
28084 }
28085 {
28086 PyThreadState* __tstate = wxPyBeginAllowThreads();
28087 result = (bool)(arg1)->Navigate(arg2);
28088
28089 wxPyEndAllowThreads(__tstate);
28090 if (PyErr_Occurred()) SWIG_fail;
28091 }
28092 {
28093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28094 }
28095 return resultobj;
28096 fail:
28097 return NULL;
28098 }
28099
28100
28101 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28102 PyObject *resultobj;
28103 wxWindow *arg1 = (wxWindow *) 0 ;
28104 wxWindow *arg2 = (wxWindow *) 0 ;
28105 PyObject * obj0 = 0 ;
28106 PyObject * obj1 = 0 ;
28107 char *kwnames[] = {
28108 (char *) "self",(char *) "win", NULL
28109 };
28110
28111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28113 if (SWIG_arg_fail(1)) SWIG_fail;
28114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28115 if (SWIG_arg_fail(2)) SWIG_fail;
28116 {
28117 PyThreadState* __tstate = wxPyBeginAllowThreads();
28118 (arg1)->MoveAfterInTabOrder(arg2);
28119
28120 wxPyEndAllowThreads(__tstate);
28121 if (PyErr_Occurred()) SWIG_fail;
28122 }
28123 Py_INCREF(Py_None); resultobj = Py_None;
28124 return resultobj;
28125 fail:
28126 return NULL;
28127 }
28128
28129
28130 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28131 PyObject *resultobj;
28132 wxWindow *arg1 = (wxWindow *) 0 ;
28133 wxWindow *arg2 = (wxWindow *) 0 ;
28134 PyObject * obj0 = 0 ;
28135 PyObject * obj1 = 0 ;
28136 char *kwnames[] = {
28137 (char *) "self",(char *) "win", NULL
28138 };
28139
28140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28142 if (SWIG_arg_fail(1)) SWIG_fail;
28143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28144 if (SWIG_arg_fail(2)) SWIG_fail;
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 (arg1)->MoveBeforeInTabOrder(arg2);
28148
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 Py_INCREF(Py_None); resultobj = Py_None;
28153 return resultobj;
28154 fail:
28155 return NULL;
28156 }
28157
28158
28159 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28160 PyObject *resultobj;
28161 wxWindow *arg1 = (wxWindow *) 0 ;
28162 PyObject *result;
28163 PyObject * obj0 = 0 ;
28164 char *kwnames[] = {
28165 (char *) "self", NULL
28166 };
28167
28168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28170 if (SWIG_arg_fail(1)) SWIG_fail;
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 result = (PyObject *)wxWindow_GetChildren(arg1);
28174
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 resultobj = result;
28179 return resultobj;
28180 fail:
28181 return NULL;
28182 }
28183
28184
28185 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28186 PyObject *resultobj;
28187 wxWindow *arg1 = (wxWindow *) 0 ;
28188 wxWindow *result;
28189 PyObject * obj0 = 0 ;
28190 char *kwnames[] = {
28191 (char *) "self", NULL
28192 };
28193
28194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28196 if (SWIG_arg_fail(1)) SWIG_fail;
28197 {
28198 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28200
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 {
28205 resultobj = wxPyMake_wxObject(result, 0);
28206 }
28207 return resultobj;
28208 fail:
28209 return NULL;
28210 }
28211
28212
28213 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28214 PyObject *resultobj;
28215 wxWindow *arg1 = (wxWindow *) 0 ;
28216 wxWindow *result;
28217 PyObject * obj0 = 0 ;
28218 char *kwnames[] = {
28219 (char *) "self", NULL
28220 };
28221
28222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28224 if (SWIG_arg_fail(1)) SWIG_fail;
28225 {
28226 PyThreadState* __tstate = wxPyBeginAllowThreads();
28227 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28228
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 {
28233 resultobj = wxPyMake_wxObject(result, 0);
28234 }
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28242 PyObject *resultobj;
28243 wxWindow *arg1 = (wxWindow *) 0 ;
28244 bool result;
28245 PyObject * obj0 = 0 ;
28246 char *kwnames[] = {
28247 (char *) "self", NULL
28248 };
28249
28250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28252 if (SWIG_arg_fail(1)) SWIG_fail;
28253 {
28254 PyThreadState* __tstate = wxPyBeginAllowThreads();
28255 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28256
28257 wxPyEndAllowThreads(__tstate);
28258 if (PyErr_Occurred()) SWIG_fail;
28259 }
28260 {
28261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28262 }
28263 return resultobj;
28264 fail:
28265 return NULL;
28266 }
28267
28268
28269 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28270 PyObject *resultobj;
28271 wxWindow *arg1 = (wxWindow *) 0 ;
28272 wxWindow *arg2 = (wxWindow *) 0 ;
28273 bool result;
28274 PyObject * obj0 = 0 ;
28275 PyObject * obj1 = 0 ;
28276 char *kwnames[] = {
28277 (char *) "self",(char *) "newParent", NULL
28278 };
28279
28280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28282 if (SWIG_arg_fail(1)) SWIG_fail;
28283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28284 if (SWIG_arg_fail(2)) SWIG_fail;
28285 {
28286 PyThreadState* __tstate = wxPyBeginAllowThreads();
28287 result = (bool)(arg1)->Reparent(arg2);
28288
28289 wxPyEndAllowThreads(__tstate);
28290 if (PyErr_Occurred()) SWIG_fail;
28291 }
28292 {
28293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28294 }
28295 return resultobj;
28296 fail:
28297 return NULL;
28298 }
28299
28300
28301 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28302 PyObject *resultobj;
28303 wxWindow *arg1 = (wxWindow *) 0 ;
28304 wxWindow *arg2 = (wxWindow *) 0 ;
28305 PyObject * obj0 = 0 ;
28306 PyObject * obj1 = 0 ;
28307 char *kwnames[] = {
28308 (char *) "self",(char *) "child", NULL
28309 };
28310
28311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28313 if (SWIG_arg_fail(1)) SWIG_fail;
28314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28315 if (SWIG_arg_fail(2)) SWIG_fail;
28316 {
28317 PyThreadState* __tstate = wxPyBeginAllowThreads();
28318 (arg1)->AddChild(arg2);
28319
28320 wxPyEndAllowThreads(__tstate);
28321 if (PyErr_Occurred()) SWIG_fail;
28322 }
28323 Py_INCREF(Py_None); resultobj = Py_None;
28324 return resultobj;
28325 fail:
28326 return NULL;
28327 }
28328
28329
28330 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28331 PyObject *resultobj;
28332 wxWindow *arg1 = (wxWindow *) 0 ;
28333 wxWindow *arg2 = (wxWindow *) 0 ;
28334 PyObject * obj0 = 0 ;
28335 PyObject * obj1 = 0 ;
28336 char *kwnames[] = {
28337 (char *) "self",(char *) "child", NULL
28338 };
28339
28340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28342 if (SWIG_arg_fail(1)) SWIG_fail;
28343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28344 if (SWIG_arg_fail(2)) SWIG_fail;
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 (arg1)->RemoveChild(arg2);
28348
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 Py_INCREF(Py_None); resultobj = Py_None;
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj;
28361 wxWindow *arg1 = (wxWindow *) 0 ;
28362 long arg2 ;
28363 wxWindow *result;
28364 PyObject * obj0 = 0 ;
28365 PyObject * obj1 = 0 ;
28366 char *kwnames[] = {
28367 (char *) "self",(char *) "winid", NULL
28368 };
28369
28370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28372 if (SWIG_arg_fail(1)) SWIG_fail;
28373 {
28374 arg2 = (long)(SWIG_As_long(obj1));
28375 if (SWIG_arg_fail(2)) SWIG_fail;
28376 }
28377 {
28378 PyThreadState* __tstate = wxPyBeginAllowThreads();
28379 result = (wxWindow *)(arg1)->FindWindow(arg2);
28380
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 {
28385 resultobj = wxPyMake_wxObject(result, 0);
28386 }
28387 return resultobj;
28388 fail:
28389 return NULL;
28390 }
28391
28392
28393 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28394 PyObject *resultobj;
28395 wxWindow *arg1 = (wxWindow *) 0 ;
28396 wxString *arg2 = 0 ;
28397 wxWindow *result;
28398 bool temp2 = false ;
28399 PyObject * obj0 = 0 ;
28400 PyObject * obj1 = 0 ;
28401 char *kwnames[] = {
28402 (char *) "self",(char *) "name", NULL
28403 };
28404
28405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28407 if (SWIG_arg_fail(1)) SWIG_fail;
28408 {
28409 arg2 = wxString_in_helper(obj1);
28410 if (arg2 == NULL) SWIG_fail;
28411 temp2 = true;
28412 }
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28416
28417 wxPyEndAllowThreads(__tstate);
28418 if (PyErr_Occurred()) SWIG_fail;
28419 }
28420 {
28421 resultobj = wxPyMake_wxObject(result, 0);
28422 }
28423 {
28424 if (temp2)
28425 delete arg2;
28426 }
28427 return resultobj;
28428 fail:
28429 {
28430 if (temp2)
28431 delete arg2;
28432 }
28433 return NULL;
28434 }
28435
28436
28437 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28438 PyObject *resultobj;
28439 wxWindow *arg1 = (wxWindow *) 0 ;
28440 wxEvtHandler *result;
28441 PyObject * obj0 = 0 ;
28442 char *kwnames[] = {
28443 (char *) "self", NULL
28444 };
28445
28446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28448 if (SWIG_arg_fail(1)) SWIG_fail;
28449 {
28450 PyThreadState* __tstate = wxPyBeginAllowThreads();
28451 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28452
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 {
28457 resultobj = wxPyMake_wxObject(result, 0);
28458 }
28459 return resultobj;
28460 fail:
28461 return NULL;
28462 }
28463
28464
28465 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28466 PyObject *resultobj;
28467 wxWindow *arg1 = (wxWindow *) 0 ;
28468 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28469 PyObject * obj0 = 0 ;
28470 PyObject * obj1 = 0 ;
28471 char *kwnames[] = {
28472 (char *) "self",(char *) "handler", NULL
28473 };
28474
28475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28477 if (SWIG_arg_fail(1)) SWIG_fail;
28478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28479 if (SWIG_arg_fail(2)) SWIG_fail;
28480 {
28481 PyThreadState* __tstate = wxPyBeginAllowThreads();
28482 (arg1)->SetEventHandler(arg2);
28483
28484 wxPyEndAllowThreads(__tstate);
28485 if (PyErr_Occurred()) SWIG_fail;
28486 }
28487 Py_INCREF(Py_None); resultobj = Py_None;
28488 return resultobj;
28489 fail:
28490 return NULL;
28491 }
28492
28493
28494 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28495 PyObject *resultobj;
28496 wxWindow *arg1 = (wxWindow *) 0 ;
28497 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28498 PyObject * obj0 = 0 ;
28499 PyObject * obj1 = 0 ;
28500 char *kwnames[] = {
28501 (char *) "self",(char *) "handler", NULL
28502 };
28503
28504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28506 if (SWIG_arg_fail(1)) SWIG_fail;
28507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28508 if (SWIG_arg_fail(2)) SWIG_fail;
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 (arg1)->PushEventHandler(arg2);
28512
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 Py_INCREF(Py_None); resultobj = Py_None;
28517 return resultobj;
28518 fail:
28519 return NULL;
28520 }
28521
28522
28523 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28524 PyObject *resultobj;
28525 wxWindow *arg1 = (wxWindow *) 0 ;
28526 bool arg2 = (bool) false ;
28527 wxEvtHandler *result;
28528 PyObject * obj0 = 0 ;
28529 PyObject * obj1 = 0 ;
28530 char *kwnames[] = {
28531 (char *) "self",(char *) "deleteHandler", NULL
28532 };
28533
28534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28536 if (SWIG_arg_fail(1)) SWIG_fail;
28537 if (obj1) {
28538 {
28539 arg2 = (bool)(SWIG_As_bool(obj1));
28540 if (SWIG_arg_fail(2)) SWIG_fail;
28541 }
28542 }
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28546
28547 wxPyEndAllowThreads(__tstate);
28548 if (PyErr_Occurred()) SWIG_fail;
28549 }
28550 {
28551 resultobj = wxPyMake_wxObject(result, 0);
28552 }
28553 return resultobj;
28554 fail:
28555 return NULL;
28556 }
28557
28558
28559 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28560 PyObject *resultobj;
28561 wxWindow *arg1 = (wxWindow *) 0 ;
28562 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28563 bool result;
28564 PyObject * obj0 = 0 ;
28565 PyObject * obj1 = 0 ;
28566 char *kwnames[] = {
28567 (char *) "self",(char *) "handler", NULL
28568 };
28569
28570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28572 if (SWIG_arg_fail(1)) SWIG_fail;
28573 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28574 if (SWIG_arg_fail(2)) SWIG_fail;
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = (bool)(arg1)->RemoveEventHandler(arg2);
28578
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 {
28583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28584 }
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28592 PyObject *resultobj;
28593 wxWindow *arg1 = (wxWindow *) 0 ;
28594 wxValidator *arg2 = 0 ;
28595 PyObject * obj0 = 0 ;
28596 PyObject * obj1 = 0 ;
28597 char *kwnames[] = {
28598 (char *) "self",(char *) "validator", NULL
28599 };
28600
28601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28603 if (SWIG_arg_fail(1)) SWIG_fail;
28604 {
28605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28606 if (SWIG_arg_fail(2)) SWIG_fail;
28607 if (arg2 == NULL) {
28608 SWIG_null_ref("wxValidator");
28609 }
28610 if (SWIG_arg_fail(2)) SWIG_fail;
28611 }
28612 {
28613 PyThreadState* __tstate = wxPyBeginAllowThreads();
28614 (arg1)->SetValidator((wxValidator const &)*arg2);
28615
28616 wxPyEndAllowThreads(__tstate);
28617 if (PyErr_Occurred()) SWIG_fail;
28618 }
28619 Py_INCREF(Py_None); resultobj = Py_None;
28620 return resultobj;
28621 fail:
28622 return NULL;
28623 }
28624
28625
28626 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28627 PyObject *resultobj;
28628 wxWindow *arg1 = (wxWindow *) 0 ;
28629 wxValidator *result;
28630 PyObject * obj0 = 0 ;
28631 char *kwnames[] = {
28632 (char *) "self", NULL
28633 };
28634
28635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28637 if (SWIG_arg_fail(1)) SWIG_fail;
28638 {
28639 PyThreadState* __tstate = wxPyBeginAllowThreads();
28640 result = (wxValidator *)(arg1)->GetValidator();
28641
28642 wxPyEndAllowThreads(__tstate);
28643 if (PyErr_Occurred()) SWIG_fail;
28644 }
28645 {
28646 resultobj = wxPyMake_wxObject(result, 0);
28647 }
28648 return resultobj;
28649 fail:
28650 return NULL;
28651 }
28652
28653
28654 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28655 PyObject *resultobj;
28656 wxWindow *arg1 = (wxWindow *) 0 ;
28657 bool result;
28658 PyObject * obj0 = 0 ;
28659 char *kwnames[] = {
28660 (char *) "self", NULL
28661 };
28662
28663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28665 if (SWIG_arg_fail(1)) SWIG_fail;
28666 {
28667 PyThreadState* __tstate = wxPyBeginAllowThreads();
28668 result = (bool)(arg1)->Validate();
28669
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 {
28674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28675 }
28676 return resultobj;
28677 fail:
28678 return NULL;
28679 }
28680
28681
28682 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28683 PyObject *resultobj;
28684 wxWindow *arg1 = (wxWindow *) 0 ;
28685 bool result;
28686 PyObject * obj0 = 0 ;
28687 char *kwnames[] = {
28688 (char *) "self", NULL
28689 };
28690
28691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28693 if (SWIG_arg_fail(1)) SWIG_fail;
28694 {
28695 PyThreadState* __tstate = wxPyBeginAllowThreads();
28696 result = (bool)(arg1)->TransferDataToWindow();
28697
28698 wxPyEndAllowThreads(__tstate);
28699 if (PyErr_Occurred()) SWIG_fail;
28700 }
28701 {
28702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28703 }
28704 return resultobj;
28705 fail:
28706 return NULL;
28707 }
28708
28709
28710 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28711 PyObject *resultobj;
28712 wxWindow *arg1 = (wxWindow *) 0 ;
28713 bool result;
28714 PyObject * obj0 = 0 ;
28715 char *kwnames[] = {
28716 (char *) "self", NULL
28717 };
28718
28719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28721 if (SWIG_arg_fail(1)) SWIG_fail;
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 result = (bool)(arg1)->TransferDataFromWindow();
28725
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 {
28730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28731 }
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28739 PyObject *resultobj;
28740 wxWindow *arg1 = (wxWindow *) 0 ;
28741 PyObject * obj0 = 0 ;
28742 char *kwnames[] = {
28743 (char *) "self", NULL
28744 };
28745
28746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28748 if (SWIG_arg_fail(1)) SWIG_fail;
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 (arg1)->InitDialog();
28752
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 Py_INCREF(Py_None); resultobj = Py_None;
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28764 PyObject *resultobj;
28765 wxWindow *arg1 = (wxWindow *) 0 ;
28766 wxAcceleratorTable *arg2 = 0 ;
28767 PyObject * obj0 = 0 ;
28768 PyObject * obj1 = 0 ;
28769 char *kwnames[] = {
28770 (char *) "self",(char *) "accel", NULL
28771 };
28772
28773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28775 if (SWIG_arg_fail(1)) SWIG_fail;
28776 {
28777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28778 if (SWIG_arg_fail(2)) SWIG_fail;
28779 if (arg2 == NULL) {
28780 SWIG_null_ref("wxAcceleratorTable");
28781 }
28782 if (SWIG_arg_fail(2)) SWIG_fail;
28783 }
28784 {
28785 PyThreadState* __tstate = wxPyBeginAllowThreads();
28786 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28787
28788 wxPyEndAllowThreads(__tstate);
28789 if (PyErr_Occurred()) SWIG_fail;
28790 }
28791 Py_INCREF(Py_None); resultobj = Py_None;
28792 return resultobj;
28793 fail:
28794 return NULL;
28795 }
28796
28797
28798 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28799 PyObject *resultobj;
28800 wxWindow *arg1 = (wxWindow *) 0 ;
28801 wxAcceleratorTable *result;
28802 PyObject * obj0 = 0 ;
28803 char *kwnames[] = {
28804 (char *) "self", NULL
28805 };
28806
28807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28809 if (SWIG_arg_fail(1)) SWIG_fail;
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28813
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28825 PyObject *resultobj;
28826 wxWindow *arg1 = (wxWindow *) 0 ;
28827 int arg2 ;
28828 int arg3 ;
28829 int arg4 ;
28830 bool result;
28831 PyObject * obj0 = 0 ;
28832 PyObject * obj1 = 0 ;
28833 PyObject * obj2 = 0 ;
28834 PyObject * obj3 = 0 ;
28835 char *kwnames[] = {
28836 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28837 };
28838
28839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28841 if (SWIG_arg_fail(1)) SWIG_fail;
28842 {
28843 arg2 = (int)(SWIG_As_int(obj1));
28844 if (SWIG_arg_fail(2)) SWIG_fail;
28845 }
28846 {
28847 arg3 = (int)(SWIG_As_int(obj2));
28848 if (SWIG_arg_fail(3)) SWIG_fail;
28849 }
28850 {
28851 arg4 = (int)(SWIG_As_int(obj3));
28852 if (SWIG_arg_fail(4)) SWIG_fail;
28853 }
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28857
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 {
28862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28863 }
28864 return resultobj;
28865 fail:
28866 return NULL;
28867 }
28868
28869
28870 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28871 PyObject *resultobj;
28872 wxWindow *arg1 = (wxWindow *) 0 ;
28873 int arg2 ;
28874 bool result;
28875 PyObject * obj0 = 0 ;
28876 PyObject * obj1 = 0 ;
28877 char *kwnames[] = {
28878 (char *) "self",(char *) "hotkeyId", NULL
28879 };
28880
28881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28883 if (SWIG_arg_fail(1)) SWIG_fail;
28884 {
28885 arg2 = (int)(SWIG_As_int(obj1));
28886 if (SWIG_arg_fail(2)) SWIG_fail;
28887 }
28888 {
28889 PyThreadState* __tstate = wxPyBeginAllowThreads();
28890 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28891
28892 wxPyEndAllowThreads(__tstate);
28893 if (PyErr_Occurred()) SWIG_fail;
28894 }
28895 {
28896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28897 }
28898 return resultobj;
28899 fail:
28900 return NULL;
28901 }
28902
28903
28904 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28905 PyObject *resultobj;
28906 wxWindow *arg1 = (wxWindow *) 0 ;
28907 wxPoint *arg2 = 0 ;
28908 wxPoint result;
28909 wxPoint temp2 ;
28910 PyObject * obj0 = 0 ;
28911 PyObject * obj1 = 0 ;
28912 char *kwnames[] = {
28913 (char *) "self",(char *) "pt", NULL
28914 };
28915
28916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28918 if (SWIG_arg_fail(1)) SWIG_fail;
28919 {
28920 arg2 = &temp2;
28921 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28922 }
28923 {
28924 PyThreadState* __tstate = wxPyBeginAllowThreads();
28925 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28926
28927 wxPyEndAllowThreads(__tstate);
28928 if (PyErr_Occurred()) SWIG_fail;
28929 }
28930 {
28931 wxPoint * resultptr;
28932 resultptr = new wxPoint((wxPoint &)(result));
28933 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28934 }
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28942 PyObject *resultobj;
28943 wxWindow *arg1 = (wxWindow *) 0 ;
28944 wxSize *arg2 = 0 ;
28945 wxSize result;
28946 wxSize temp2 ;
28947 PyObject * obj0 = 0 ;
28948 PyObject * obj1 = 0 ;
28949 char *kwnames[] = {
28950 (char *) "self",(char *) "sz", NULL
28951 };
28952
28953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28955 if (SWIG_arg_fail(1)) SWIG_fail;
28956 {
28957 arg2 = &temp2;
28958 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28959 }
28960 {
28961 PyThreadState* __tstate = wxPyBeginAllowThreads();
28962 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28963
28964 wxPyEndAllowThreads(__tstate);
28965 if (PyErr_Occurred()) SWIG_fail;
28966 }
28967 {
28968 wxSize * resultptr;
28969 resultptr = new wxSize((wxSize &)(result));
28970 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28971 }
28972 return resultobj;
28973 fail:
28974 return NULL;
28975 }
28976
28977
28978 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28979 PyObject *resultobj;
28980 wxWindow *arg1 = (wxWindow *) 0 ;
28981 wxPoint *arg2 = 0 ;
28982 wxPoint result;
28983 wxPoint temp2 ;
28984 PyObject * obj0 = 0 ;
28985 PyObject * obj1 = 0 ;
28986 char *kwnames[] = {
28987 (char *) "self",(char *) "pt", NULL
28988 };
28989
28990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28992 if (SWIG_arg_fail(1)) SWIG_fail;
28993 {
28994 arg2 = &temp2;
28995 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28996 }
28997 {
28998 PyThreadState* __tstate = wxPyBeginAllowThreads();
28999 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29000
29001 wxPyEndAllowThreads(__tstate);
29002 if (PyErr_Occurred()) SWIG_fail;
29003 }
29004 {
29005 wxPoint * resultptr;
29006 resultptr = new wxPoint((wxPoint &)(result));
29007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29008 }
29009 return resultobj;
29010 fail:
29011 return NULL;
29012 }
29013
29014
29015 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29016 PyObject *resultobj;
29017 wxWindow *arg1 = (wxWindow *) 0 ;
29018 wxSize *arg2 = 0 ;
29019 wxSize result;
29020 wxSize temp2 ;
29021 PyObject * obj0 = 0 ;
29022 PyObject * obj1 = 0 ;
29023 char *kwnames[] = {
29024 (char *) "self",(char *) "sz", NULL
29025 };
29026
29027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29029 if (SWIG_arg_fail(1)) SWIG_fail;
29030 {
29031 arg2 = &temp2;
29032 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29033 }
29034 {
29035 PyThreadState* __tstate = wxPyBeginAllowThreads();
29036 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29037
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 {
29042 wxSize * resultptr;
29043 resultptr = new wxSize((wxSize &)(result));
29044 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29045 }
29046 return resultobj;
29047 fail:
29048 return NULL;
29049 }
29050
29051
29052 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29053 PyObject *resultobj;
29054 wxWindow *arg1 = (wxWindow *) 0 ;
29055 wxPoint *arg2 = 0 ;
29056 wxPoint result;
29057 wxPoint temp2 ;
29058 PyObject * obj0 = 0 ;
29059 PyObject * obj1 = 0 ;
29060 char *kwnames[] = {
29061 (char *) "self",(char *) "pt", NULL
29062 };
29063
29064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29066 if (SWIG_arg_fail(1)) SWIG_fail;
29067 {
29068 arg2 = &temp2;
29069 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29070 }
29071 {
29072 PyThreadState* __tstate = wxPyBeginAllowThreads();
29073 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29074
29075 wxPyEndAllowThreads(__tstate);
29076 if (PyErr_Occurred()) SWIG_fail;
29077 }
29078 {
29079 wxPoint * resultptr;
29080 resultptr = new wxPoint((wxPoint &)(result));
29081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29082 }
29083 return resultobj;
29084 fail:
29085 return NULL;
29086 }
29087
29088
29089 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29090 PyObject *resultobj;
29091 wxWindow *arg1 = (wxWindow *) 0 ;
29092 wxSize *arg2 = 0 ;
29093 wxSize result;
29094 wxSize temp2 ;
29095 PyObject * obj0 = 0 ;
29096 PyObject * obj1 = 0 ;
29097 char *kwnames[] = {
29098 (char *) "self",(char *) "sz", NULL
29099 };
29100
29101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29103 if (SWIG_arg_fail(1)) SWIG_fail;
29104 {
29105 arg2 = &temp2;
29106 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29107 }
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29111
29112 wxPyEndAllowThreads(__tstate);
29113 if (PyErr_Occurred()) SWIG_fail;
29114 }
29115 {
29116 wxSize * resultptr;
29117 resultptr = new wxSize((wxSize &)(result));
29118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29119 }
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29127 PyObject *resultobj;
29128 wxWindow *arg1 = (wxWindow *) 0 ;
29129 int arg2 ;
29130 int arg3 ;
29131 PyObject * obj0 = 0 ;
29132 PyObject * obj1 = 0 ;
29133 PyObject * obj2 = 0 ;
29134 char *kwnames[] = {
29135 (char *) "self",(char *) "x",(char *) "y", NULL
29136 };
29137
29138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29140 if (SWIG_arg_fail(1)) SWIG_fail;
29141 {
29142 arg2 = (int)(SWIG_As_int(obj1));
29143 if (SWIG_arg_fail(2)) SWIG_fail;
29144 }
29145 {
29146 arg3 = (int)(SWIG_As_int(obj2));
29147 if (SWIG_arg_fail(3)) SWIG_fail;
29148 }
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 (arg1)->WarpPointer(arg2,arg3);
29152
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 Py_INCREF(Py_None); resultobj = Py_None;
29157 return resultobj;
29158 fail:
29159 return NULL;
29160 }
29161
29162
29163 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29164 PyObject *resultobj;
29165 wxWindow *arg1 = (wxWindow *) 0 ;
29166 PyObject * obj0 = 0 ;
29167 char *kwnames[] = {
29168 (char *) "self", NULL
29169 };
29170
29171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29173 if (SWIG_arg_fail(1)) SWIG_fail;
29174 {
29175 PyThreadState* __tstate = wxPyBeginAllowThreads();
29176 (arg1)->CaptureMouse();
29177
29178 wxPyEndAllowThreads(__tstate);
29179 if (PyErr_Occurred()) SWIG_fail;
29180 }
29181 Py_INCREF(Py_None); resultobj = Py_None;
29182 return resultobj;
29183 fail:
29184 return NULL;
29185 }
29186
29187
29188 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29189 PyObject *resultobj;
29190 wxWindow *arg1 = (wxWindow *) 0 ;
29191 PyObject * obj0 = 0 ;
29192 char *kwnames[] = {
29193 (char *) "self", NULL
29194 };
29195
29196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29198 if (SWIG_arg_fail(1)) SWIG_fail;
29199 {
29200 PyThreadState* __tstate = wxPyBeginAllowThreads();
29201 (arg1)->ReleaseMouse();
29202
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 Py_INCREF(Py_None); resultobj = Py_None;
29207 return resultobj;
29208 fail:
29209 return NULL;
29210 }
29211
29212
29213 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29214 PyObject *resultobj;
29215 wxWindow *result;
29216 char *kwnames[] = {
29217 NULL
29218 };
29219
29220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29221 {
29222 if (!wxPyCheckForApp()) SWIG_fail;
29223 PyThreadState* __tstate = wxPyBeginAllowThreads();
29224 result = (wxWindow *)wxWindow::GetCapture();
29225
29226 wxPyEndAllowThreads(__tstate);
29227 if (PyErr_Occurred()) SWIG_fail;
29228 }
29229 {
29230 resultobj = wxPyMake_wxObject(result, 0);
29231 }
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29239 PyObject *resultobj;
29240 wxWindow *arg1 = (wxWindow *) 0 ;
29241 bool result;
29242 PyObject * obj0 = 0 ;
29243 char *kwnames[] = {
29244 (char *) "self", NULL
29245 };
29246
29247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29249 if (SWIG_arg_fail(1)) SWIG_fail;
29250 {
29251 PyThreadState* __tstate = wxPyBeginAllowThreads();
29252 result = (bool)((wxWindow const *)arg1)->HasCapture();
29253
29254 wxPyEndAllowThreads(__tstate);
29255 if (PyErr_Occurred()) SWIG_fail;
29256 }
29257 {
29258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29259 }
29260 return resultobj;
29261 fail:
29262 return NULL;
29263 }
29264
29265
29266 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29267 PyObject *resultobj;
29268 wxWindow *arg1 = (wxWindow *) 0 ;
29269 bool arg2 = (bool) true ;
29270 wxRect *arg3 = (wxRect *) NULL ;
29271 PyObject * obj0 = 0 ;
29272 PyObject * obj1 = 0 ;
29273 PyObject * obj2 = 0 ;
29274 char *kwnames[] = {
29275 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29276 };
29277
29278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29280 if (SWIG_arg_fail(1)) SWIG_fail;
29281 if (obj1) {
29282 {
29283 arg2 = (bool)(SWIG_As_bool(obj1));
29284 if (SWIG_arg_fail(2)) SWIG_fail;
29285 }
29286 }
29287 if (obj2) {
29288 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29289 if (SWIG_arg_fail(3)) SWIG_fail;
29290 }
29291 {
29292 PyThreadState* __tstate = wxPyBeginAllowThreads();
29293 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29294
29295 wxPyEndAllowThreads(__tstate);
29296 if (PyErr_Occurred()) SWIG_fail;
29297 }
29298 Py_INCREF(Py_None); resultobj = Py_None;
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29306 PyObject *resultobj;
29307 wxWindow *arg1 = (wxWindow *) 0 ;
29308 wxRect *arg2 = 0 ;
29309 bool arg3 = (bool) true ;
29310 wxRect temp2 ;
29311 PyObject * obj0 = 0 ;
29312 PyObject * obj1 = 0 ;
29313 PyObject * obj2 = 0 ;
29314 char *kwnames[] = {
29315 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29316 };
29317
29318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29320 if (SWIG_arg_fail(1)) SWIG_fail;
29321 {
29322 arg2 = &temp2;
29323 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29324 }
29325 if (obj2) {
29326 {
29327 arg3 = (bool)(SWIG_As_bool(obj2));
29328 if (SWIG_arg_fail(3)) SWIG_fail;
29329 }
29330 }
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29334
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 Py_INCREF(Py_None); resultobj = Py_None;
29339 return resultobj;
29340 fail:
29341 return NULL;
29342 }
29343
29344
29345 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29346 PyObject *resultobj;
29347 wxWindow *arg1 = (wxWindow *) 0 ;
29348 PyObject * obj0 = 0 ;
29349 char *kwnames[] = {
29350 (char *) "self", NULL
29351 };
29352
29353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29355 if (SWIG_arg_fail(1)) SWIG_fail;
29356 {
29357 PyThreadState* __tstate = wxPyBeginAllowThreads();
29358 (arg1)->Update();
29359
29360 wxPyEndAllowThreads(__tstate);
29361 if (PyErr_Occurred()) SWIG_fail;
29362 }
29363 Py_INCREF(Py_None); resultobj = Py_None;
29364 return resultobj;
29365 fail:
29366 return NULL;
29367 }
29368
29369
29370 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29371 PyObject *resultobj;
29372 wxWindow *arg1 = (wxWindow *) 0 ;
29373 PyObject * obj0 = 0 ;
29374 char *kwnames[] = {
29375 (char *) "self", NULL
29376 };
29377
29378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29380 if (SWIG_arg_fail(1)) SWIG_fail;
29381 {
29382 PyThreadState* __tstate = wxPyBeginAllowThreads();
29383 (arg1)->ClearBackground();
29384
29385 wxPyEndAllowThreads(__tstate);
29386 if (PyErr_Occurred()) SWIG_fail;
29387 }
29388 Py_INCREF(Py_None); resultobj = Py_None;
29389 return resultobj;
29390 fail:
29391 return NULL;
29392 }
29393
29394
29395 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29396 PyObject *resultobj;
29397 wxWindow *arg1 = (wxWindow *) 0 ;
29398 PyObject * obj0 = 0 ;
29399 char *kwnames[] = {
29400 (char *) "self", NULL
29401 };
29402
29403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29405 if (SWIG_arg_fail(1)) SWIG_fail;
29406 {
29407 PyThreadState* __tstate = wxPyBeginAllowThreads();
29408 (arg1)->Freeze();
29409
29410 wxPyEndAllowThreads(__tstate);
29411 if (PyErr_Occurred()) SWIG_fail;
29412 }
29413 Py_INCREF(Py_None); resultobj = Py_None;
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj;
29422 wxWindow *arg1 = (wxWindow *) 0 ;
29423 PyObject * obj0 = 0 ;
29424 char *kwnames[] = {
29425 (char *) "self", NULL
29426 };
29427
29428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29430 if (SWIG_arg_fail(1)) SWIG_fail;
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 (arg1)->Thaw();
29434
29435 wxPyEndAllowThreads(__tstate);
29436 if (PyErr_Occurred()) SWIG_fail;
29437 }
29438 Py_INCREF(Py_None); resultobj = Py_None;
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj;
29447 wxWindow *arg1 = (wxWindow *) 0 ;
29448 wxDC *arg2 = 0 ;
29449 PyObject * obj0 = 0 ;
29450 PyObject * obj1 = 0 ;
29451 char *kwnames[] = {
29452 (char *) "self",(char *) "dc", NULL
29453 };
29454
29455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29457 if (SWIG_arg_fail(1)) SWIG_fail;
29458 {
29459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29460 if (SWIG_arg_fail(2)) SWIG_fail;
29461 if (arg2 == NULL) {
29462 SWIG_null_ref("wxDC");
29463 }
29464 if (SWIG_arg_fail(2)) SWIG_fail;
29465 }
29466 {
29467 PyThreadState* __tstate = wxPyBeginAllowThreads();
29468 (arg1)->PrepareDC(*arg2);
29469
29470 wxPyEndAllowThreads(__tstate);
29471 if (PyErr_Occurred()) SWIG_fail;
29472 }
29473 Py_INCREF(Py_None); resultobj = Py_None;
29474 return resultobj;
29475 fail:
29476 return NULL;
29477 }
29478
29479
29480 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29481 PyObject *resultobj;
29482 wxWindow *arg1 = (wxWindow *) 0 ;
29483 wxRegion *result;
29484 PyObject * obj0 = 0 ;
29485 char *kwnames[] = {
29486 (char *) "self", NULL
29487 };
29488
29489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29491 if (SWIG_arg_fail(1)) SWIG_fail;
29492 {
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 {
29495 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29496 result = (wxRegion *) &_result_ref;
29497 }
29498
29499 wxPyEndAllowThreads(__tstate);
29500 if (PyErr_Occurred()) SWIG_fail;
29501 }
29502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29510 PyObject *resultobj;
29511 wxWindow *arg1 = (wxWindow *) 0 ;
29512 wxRect result;
29513 PyObject * obj0 = 0 ;
29514 char *kwnames[] = {
29515 (char *) "self", NULL
29516 };
29517
29518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29520 if (SWIG_arg_fail(1)) SWIG_fail;
29521 {
29522 PyThreadState* __tstate = wxPyBeginAllowThreads();
29523 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29524
29525 wxPyEndAllowThreads(__tstate);
29526 if (PyErr_Occurred()) SWIG_fail;
29527 }
29528 {
29529 wxRect * resultptr;
29530 resultptr = new wxRect((wxRect &)(result));
29531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29532 }
29533 return resultobj;
29534 fail:
29535 return NULL;
29536 }
29537
29538
29539 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29540 PyObject *resultobj;
29541 wxWindow *arg1 = (wxWindow *) 0 ;
29542 int arg2 ;
29543 int arg3 ;
29544 int arg4 = (int) 1 ;
29545 int arg5 = (int) 1 ;
29546 bool result;
29547 PyObject * obj0 = 0 ;
29548 PyObject * obj1 = 0 ;
29549 PyObject * obj2 = 0 ;
29550 PyObject * obj3 = 0 ;
29551 PyObject * obj4 = 0 ;
29552 char *kwnames[] = {
29553 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29554 };
29555
29556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29558 if (SWIG_arg_fail(1)) SWIG_fail;
29559 {
29560 arg2 = (int)(SWIG_As_int(obj1));
29561 if (SWIG_arg_fail(2)) SWIG_fail;
29562 }
29563 {
29564 arg3 = (int)(SWIG_As_int(obj2));
29565 if (SWIG_arg_fail(3)) SWIG_fail;
29566 }
29567 if (obj3) {
29568 {
29569 arg4 = (int)(SWIG_As_int(obj3));
29570 if (SWIG_arg_fail(4)) SWIG_fail;
29571 }
29572 }
29573 if (obj4) {
29574 {
29575 arg5 = (int)(SWIG_As_int(obj4));
29576 if (SWIG_arg_fail(5)) SWIG_fail;
29577 }
29578 }
29579 {
29580 PyThreadState* __tstate = wxPyBeginAllowThreads();
29581 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29582
29583 wxPyEndAllowThreads(__tstate);
29584 if (PyErr_Occurred()) SWIG_fail;
29585 }
29586 {
29587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29588 }
29589 return resultobj;
29590 fail:
29591 return NULL;
29592 }
29593
29594
29595 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29596 PyObject *resultobj;
29597 wxWindow *arg1 = (wxWindow *) 0 ;
29598 wxPoint *arg2 = 0 ;
29599 bool result;
29600 wxPoint temp2 ;
29601 PyObject * obj0 = 0 ;
29602 PyObject * obj1 = 0 ;
29603 char *kwnames[] = {
29604 (char *) "self",(char *) "pt", NULL
29605 };
29606
29607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29609 if (SWIG_arg_fail(1)) SWIG_fail;
29610 {
29611 arg2 = &temp2;
29612 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29613 }
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29617
29618 wxPyEndAllowThreads(__tstate);
29619 if (PyErr_Occurred()) SWIG_fail;
29620 }
29621 {
29622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29623 }
29624 return resultobj;
29625 fail:
29626 return NULL;
29627 }
29628
29629
29630 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29631 PyObject *resultobj;
29632 wxWindow *arg1 = (wxWindow *) 0 ;
29633 wxRect *arg2 = 0 ;
29634 bool result;
29635 wxRect temp2 ;
29636 PyObject * obj0 = 0 ;
29637 PyObject * obj1 = 0 ;
29638 char *kwnames[] = {
29639 (char *) "self",(char *) "rect", NULL
29640 };
29641
29642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29644 if (SWIG_arg_fail(1)) SWIG_fail;
29645 {
29646 arg2 = &temp2;
29647 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29648 }
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29652
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 {
29657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29658 }
29659 return resultobj;
29660 fail:
29661 return NULL;
29662 }
29663
29664
29665 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29666 PyObject *resultobj;
29667 wxWindow *arg1 = (wxWindow *) 0 ;
29668 wxVisualAttributes result;
29669 PyObject * obj0 = 0 ;
29670 char *kwnames[] = {
29671 (char *) "self", NULL
29672 };
29673
29674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29676 if (SWIG_arg_fail(1)) SWIG_fail;
29677 {
29678 PyThreadState* __tstate = wxPyBeginAllowThreads();
29679 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29680
29681 wxPyEndAllowThreads(__tstate);
29682 if (PyErr_Occurred()) SWIG_fail;
29683 }
29684 {
29685 wxVisualAttributes * resultptr;
29686 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29687 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29688 }
29689 return resultobj;
29690 fail:
29691 return NULL;
29692 }
29693
29694
29695 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29696 PyObject *resultobj;
29697 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29698 wxVisualAttributes result;
29699 PyObject * obj0 = 0 ;
29700 char *kwnames[] = {
29701 (char *) "variant", NULL
29702 };
29703
29704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29705 if (obj0) {
29706 {
29707 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29708 if (SWIG_arg_fail(1)) SWIG_fail;
29709 }
29710 }
29711 {
29712 if (!wxPyCheckForApp()) SWIG_fail;
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29715
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 {
29720 wxVisualAttributes * resultptr;
29721 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29722 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29723 }
29724 return resultobj;
29725 fail:
29726 return NULL;
29727 }
29728
29729
29730 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29731 PyObject *resultobj;
29732 wxWindow *arg1 = (wxWindow *) 0 ;
29733 wxColour *arg2 = 0 ;
29734 bool result;
29735 wxColour temp2 ;
29736 PyObject * obj0 = 0 ;
29737 PyObject * obj1 = 0 ;
29738 char *kwnames[] = {
29739 (char *) "self",(char *) "colour", NULL
29740 };
29741
29742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29744 if (SWIG_arg_fail(1)) SWIG_fail;
29745 {
29746 arg2 = &temp2;
29747 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29748 }
29749 {
29750 PyThreadState* __tstate = wxPyBeginAllowThreads();
29751 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29752
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 {
29757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29758 }
29759 return resultobj;
29760 fail:
29761 return NULL;
29762 }
29763
29764
29765 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29766 PyObject *resultobj;
29767 wxWindow *arg1 = (wxWindow *) 0 ;
29768 wxColour *arg2 = 0 ;
29769 wxColour temp2 ;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 char *kwnames[] = {
29773 (char *) "self",(char *) "colour", NULL
29774 };
29775
29776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29778 if (SWIG_arg_fail(1)) SWIG_fail;
29779 {
29780 arg2 = &temp2;
29781 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29782 }
29783 {
29784 PyThreadState* __tstate = wxPyBeginAllowThreads();
29785 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29786
29787 wxPyEndAllowThreads(__tstate);
29788 if (PyErr_Occurred()) SWIG_fail;
29789 }
29790 Py_INCREF(Py_None); resultobj = Py_None;
29791 return resultobj;
29792 fail:
29793 return NULL;
29794 }
29795
29796
29797 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29798 PyObject *resultobj;
29799 wxWindow *arg1 = (wxWindow *) 0 ;
29800 wxColour *arg2 = 0 ;
29801 bool result;
29802 wxColour temp2 ;
29803 PyObject * obj0 = 0 ;
29804 PyObject * obj1 = 0 ;
29805 char *kwnames[] = {
29806 (char *) "self",(char *) "colour", NULL
29807 };
29808
29809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29811 if (SWIG_arg_fail(1)) SWIG_fail;
29812 {
29813 arg2 = &temp2;
29814 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29815 }
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29819
29820 wxPyEndAllowThreads(__tstate);
29821 if (PyErr_Occurred()) SWIG_fail;
29822 }
29823 {
29824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29825 }
29826 return resultobj;
29827 fail:
29828 return NULL;
29829 }
29830
29831
29832 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29833 PyObject *resultobj;
29834 wxWindow *arg1 = (wxWindow *) 0 ;
29835 wxColour *arg2 = 0 ;
29836 wxColour temp2 ;
29837 PyObject * obj0 = 0 ;
29838 PyObject * obj1 = 0 ;
29839 char *kwnames[] = {
29840 (char *) "self",(char *) "colour", NULL
29841 };
29842
29843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29845 if (SWIG_arg_fail(1)) SWIG_fail;
29846 {
29847 arg2 = &temp2;
29848 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29849 }
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29853
29854 wxPyEndAllowThreads(__tstate);
29855 if (PyErr_Occurred()) SWIG_fail;
29856 }
29857 Py_INCREF(Py_None); resultobj = Py_None;
29858 return resultobj;
29859 fail:
29860 return NULL;
29861 }
29862
29863
29864 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29865 PyObject *resultobj;
29866 wxWindow *arg1 = (wxWindow *) 0 ;
29867 wxColour result;
29868 PyObject * obj0 = 0 ;
29869 char *kwnames[] = {
29870 (char *) "self", NULL
29871 };
29872
29873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29875 if (SWIG_arg_fail(1)) SWIG_fail;
29876 {
29877 PyThreadState* __tstate = wxPyBeginAllowThreads();
29878 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29879
29880 wxPyEndAllowThreads(__tstate);
29881 if (PyErr_Occurred()) SWIG_fail;
29882 }
29883 {
29884 wxColour * resultptr;
29885 resultptr = new wxColour((wxColour &)(result));
29886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29887 }
29888 return resultobj;
29889 fail:
29890 return NULL;
29891 }
29892
29893
29894 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29895 PyObject *resultobj;
29896 wxWindow *arg1 = (wxWindow *) 0 ;
29897 wxColour result;
29898 PyObject * obj0 = 0 ;
29899 char *kwnames[] = {
29900 (char *) "self", NULL
29901 };
29902
29903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29905 if (SWIG_arg_fail(1)) SWIG_fail;
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 result = ((wxWindow const *)arg1)->GetForegroundColour();
29909
29910 wxPyEndAllowThreads(__tstate);
29911 if (PyErr_Occurred()) SWIG_fail;
29912 }
29913 {
29914 wxColour * resultptr;
29915 resultptr = new wxColour((wxColour &)(result));
29916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29917 }
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29925 PyObject *resultobj;
29926 wxWindow *arg1 = (wxWindow *) 0 ;
29927 bool result;
29928 PyObject * obj0 = 0 ;
29929 char *kwnames[] = {
29930 (char *) "self", NULL
29931 };
29932
29933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29935 if (SWIG_arg_fail(1)) SWIG_fail;
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29939
29940 wxPyEndAllowThreads(__tstate);
29941 if (PyErr_Occurred()) SWIG_fail;
29942 }
29943 {
29944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29945 }
29946 return resultobj;
29947 fail:
29948 return NULL;
29949 }
29950
29951
29952 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29953 PyObject *resultobj;
29954 wxWindow *arg1 = (wxWindow *) 0 ;
29955 bool result;
29956 PyObject * obj0 = 0 ;
29957 char *kwnames[] = {
29958 (char *) "self", NULL
29959 };
29960
29961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29963 if (SWIG_arg_fail(1)) SWIG_fail;
29964 {
29965 PyThreadState* __tstate = wxPyBeginAllowThreads();
29966 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29967
29968 wxPyEndAllowThreads(__tstate);
29969 if (PyErr_Occurred()) SWIG_fail;
29970 }
29971 {
29972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29973 }
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29981 PyObject *resultobj;
29982 wxWindow *arg1 = (wxWindow *) 0 ;
29983 wxBackgroundStyle arg2 ;
29984 bool result;
29985 PyObject * obj0 = 0 ;
29986 PyObject * obj1 = 0 ;
29987 char *kwnames[] = {
29988 (char *) "self",(char *) "style", NULL
29989 };
29990
29991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29993 if (SWIG_arg_fail(1)) SWIG_fail;
29994 {
29995 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29996 if (SWIG_arg_fail(2)) SWIG_fail;
29997 }
29998 {
29999 PyThreadState* __tstate = wxPyBeginAllowThreads();
30000 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
30001
30002 wxPyEndAllowThreads(__tstate);
30003 if (PyErr_Occurred()) SWIG_fail;
30004 }
30005 {
30006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30007 }
30008 return resultobj;
30009 fail:
30010 return NULL;
30011 }
30012
30013
30014 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30015 PyObject *resultobj;
30016 wxWindow *arg1 = (wxWindow *) 0 ;
30017 wxBackgroundStyle result;
30018 PyObject * obj0 = 0 ;
30019 char *kwnames[] = {
30020 (char *) "self", NULL
30021 };
30022
30023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30025 if (SWIG_arg_fail(1)) SWIG_fail;
30026 {
30027 PyThreadState* __tstate = wxPyBeginAllowThreads();
30028 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30029
30030 wxPyEndAllowThreads(__tstate);
30031 if (PyErr_Occurred()) SWIG_fail;
30032 }
30033 resultobj = SWIG_From_int((result));
30034 return resultobj;
30035 fail:
30036 return NULL;
30037 }
30038
30039
30040 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30041 PyObject *resultobj;
30042 wxWindow *arg1 = (wxWindow *) 0 ;
30043 bool result;
30044 PyObject * obj0 = 0 ;
30045 char *kwnames[] = {
30046 (char *) "self", NULL
30047 };
30048
30049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30051 if (SWIG_arg_fail(1)) SWIG_fail;
30052 {
30053 PyThreadState* __tstate = wxPyBeginAllowThreads();
30054 result = (bool)(arg1)->HasTransparentBackground();
30055
30056 wxPyEndAllowThreads(__tstate);
30057 if (PyErr_Occurred()) SWIG_fail;
30058 }
30059 {
30060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30061 }
30062 return resultobj;
30063 fail:
30064 return NULL;
30065 }
30066
30067
30068 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30069 PyObject *resultobj;
30070 wxWindow *arg1 = (wxWindow *) 0 ;
30071 wxCursor *arg2 = 0 ;
30072 bool result;
30073 PyObject * obj0 = 0 ;
30074 PyObject * obj1 = 0 ;
30075 char *kwnames[] = {
30076 (char *) "self",(char *) "cursor", NULL
30077 };
30078
30079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30081 if (SWIG_arg_fail(1)) SWIG_fail;
30082 {
30083 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30084 if (SWIG_arg_fail(2)) SWIG_fail;
30085 if (arg2 == NULL) {
30086 SWIG_null_ref("wxCursor");
30087 }
30088 if (SWIG_arg_fail(2)) SWIG_fail;
30089 }
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30093
30094 wxPyEndAllowThreads(__tstate);
30095 if (PyErr_Occurred()) SWIG_fail;
30096 }
30097 {
30098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30099 }
30100 return resultobj;
30101 fail:
30102 return NULL;
30103 }
30104
30105
30106 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30107 PyObject *resultobj;
30108 wxWindow *arg1 = (wxWindow *) 0 ;
30109 wxCursor result;
30110 PyObject * obj0 = 0 ;
30111 char *kwnames[] = {
30112 (char *) "self", NULL
30113 };
30114
30115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30117 if (SWIG_arg_fail(1)) SWIG_fail;
30118 {
30119 PyThreadState* __tstate = wxPyBeginAllowThreads();
30120 result = (arg1)->GetCursor();
30121
30122 wxPyEndAllowThreads(__tstate);
30123 if (PyErr_Occurred()) SWIG_fail;
30124 }
30125 {
30126 wxCursor * resultptr;
30127 resultptr = new wxCursor((wxCursor &)(result));
30128 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30129 }
30130 return resultobj;
30131 fail:
30132 return NULL;
30133 }
30134
30135
30136 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30137 PyObject *resultobj;
30138 wxWindow *arg1 = (wxWindow *) 0 ;
30139 wxFont *arg2 = 0 ;
30140 bool result;
30141 PyObject * obj0 = 0 ;
30142 PyObject * obj1 = 0 ;
30143 char *kwnames[] = {
30144 (char *) "self",(char *) "font", NULL
30145 };
30146
30147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30149 if (SWIG_arg_fail(1)) SWIG_fail;
30150 {
30151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30152 if (SWIG_arg_fail(2)) SWIG_fail;
30153 if (arg2 == NULL) {
30154 SWIG_null_ref("wxFont");
30155 }
30156 if (SWIG_arg_fail(2)) SWIG_fail;
30157 }
30158 {
30159 PyThreadState* __tstate = wxPyBeginAllowThreads();
30160 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30161
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 {
30166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30167 }
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30175 PyObject *resultobj;
30176 wxWindow *arg1 = (wxWindow *) 0 ;
30177 wxFont *arg2 = 0 ;
30178 PyObject * obj0 = 0 ;
30179 PyObject * obj1 = 0 ;
30180 char *kwnames[] = {
30181 (char *) "self",(char *) "font", NULL
30182 };
30183
30184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30186 if (SWIG_arg_fail(1)) SWIG_fail;
30187 {
30188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30189 if (SWIG_arg_fail(2)) SWIG_fail;
30190 if (arg2 == NULL) {
30191 SWIG_null_ref("wxFont");
30192 }
30193 if (SWIG_arg_fail(2)) SWIG_fail;
30194 }
30195 {
30196 PyThreadState* __tstate = wxPyBeginAllowThreads();
30197 (arg1)->SetOwnFont((wxFont const &)*arg2);
30198
30199 wxPyEndAllowThreads(__tstate);
30200 if (PyErr_Occurred()) SWIG_fail;
30201 }
30202 Py_INCREF(Py_None); resultobj = Py_None;
30203 return resultobj;
30204 fail:
30205 return NULL;
30206 }
30207
30208
30209 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30210 PyObject *resultobj;
30211 wxWindow *arg1 = (wxWindow *) 0 ;
30212 wxFont result;
30213 PyObject * obj0 = 0 ;
30214 char *kwnames[] = {
30215 (char *) "self", NULL
30216 };
30217
30218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30220 if (SWIG_arg_fail(1)) SWIG_fail;
30221 {
30222 PyThreadState* __tstate = wxPyBeginAllowThreads();
30223 result = (arg1)->GetFont();
30224
30225 wxPyEndAllowThreads(__tstate);
30226 if (PyErr_Occurred()) SWIG_fail;
30227 }
30228 {
30229 wxFont * resultptr;
30230 resultptr = new wxFont((wxFont &)(result));
30231 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30232 }
30233 return resultobj;
30234 fail:
30235 return NULL;
30236 }
30237
30238
30239 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30240 PyObject *resultobj;
30241 wxWindow *arg1 = (wxWindow *) 0 ;
30242 wxCaret *arg2 = (wxCaret *) 0 ;
30243 PyObject * obj0 = 0 ;
30244 PyObject * obj1 = 0 ;
30245 char *kwnames[] = {
30246 (char *) "self",(char *) "caret", NULL
30247 };
30248
30249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30251 if (SWIG_arg_fail(1)) SWIG_fail;
30252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30253 if (SWIG_arg_fail(2)) SWIG_fail;
30254 {
30255 PyThreadState* __tstate = wxPyBeginAllowThreads();
30256 (arg1)->SetCaret(arg2);
30257
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 Py_INCREF(Py_None); resultobj = Py_None;
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj;
30270 wxWindow *arg1 = (wxWindow *) 0 ;
30271 wxCaret *result;
30272 PyObject * obj0 = 0 ;
30273 char *kwnames[] = {
30274 (char *) "self", NULL
30275 };
30276
30277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30279 if (SWIG_arg_fail(1)) SWIG_fail;
30280 {
30281 PyThreadState* __tstate = wxPyBeginAllowThreads();
30282 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30283
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30295 PyObject *resultobj;
30296 wxWindow *arg1 = (wxWindow *) 0 ;
30297 int result;
30298 PyObject * obj0 = 0 ;
30299 char *kwnames[] = {
30300 (char *) "self", NULL
30301 };
30302
30303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30305 if (SWIG_arg_fail(1)) SWIG_fail;
30306 {
30307 PyThreadState* __tstate = wxPyBeginAllowThreads();
30308 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30309
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 {
30314 resultobj = SWIG_From_int((int)(result));
30315 }
30316 return resultobj;
30317 fail:
30318 return NULL;
30319 }
30320
30321
30322 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30323 PyObject *resultobj;
30324 wxWindow *arg1 = (wxWindow *) 0 ;
30325 int result;
30326 PyObject * obj0 = 0 ;
30327 char *kwnames[] = {
30328 (char *) "self", NULL
30329 };
30330
30331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30333 if (SWIG_arg_fail(1)) SWIG_fail;
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30337
30338 wxPyEndAllowThreads(__tstate);
30339 if (PyErr_Occurred()) SWIG_fail;
30340 }
30341 {
30342 resultobj = SWIG_From_int((int)(result));
30343 }
30344 return resultobj;
30345 fail:
30346 return NULL;
30347 }
30348
30349
30350 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30351 PyObject *resultobj;
30352 wxWindow *arg1 = (wxWindow *) 0 ;
30353 wxString *arg2 = 0 ;
30354 int *arg3 = (int *) 0 ;
30355 int *arg4 = (int *) 0 ;
30356 bool temp2 = false ;
30357 int temp3 ;
30358 int res3 = 0 ;
30359 int temp4 ;
30360 int res4 = 0 ;
30361 PyObject * obj0 = 0 ;
30362 PyObject * obj1 = 0 ;
30363 char *kwnames[] = {
30364 (char *) "self",(char *) "string", NULL
30365 };
30366
30367 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30368 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30371 if (SWIG_arg_fail(1)) SWIG_fail;
30372 {
30373 arg2 = wxString_in_helper(obj1);
30374 if (arg2 == NULL) SWIG_fail;
30375 temp2 = true;
30376 }
30377 {
30378 PyThreadState* __tstate = wxPyBeginAllowThreads();
30379 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30380
30381 wxPyEndAllowThreads(__tstate);
30382 if (PyErr_Occurred()) SWIG_fail;
30383 }
30384 Py_INCREF(Py_None); resultobj = Py_None;
30385 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30386 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30387 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30388 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30389 {
30390 if (temp2)
30391 delete arg2;
30392 }
30393 return resultobj;
30394 fail:
30395 {
30396 if (temp2)
30397 delete arg2;
30398 }
30399 return NULL;
30400 }
30401
30402
30403 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30404 PyObject *resultobj;
30405 wxWindow *arg1 = (wxWindow *) 0 ;
30406 wxString *arg2 = 0 ;
30407 int *arg3 = (int *) 0 ;
30408 int *arg4 = (int *) 0 ;
30409 int *arg5 = (int *) 0 ;
30410 int *arg6 = (int *) 0 ;
30411 wxFont *arg7 = (wxFont *) NULL ;
30412 bool temp2 = false ;
30413 int temp3 ;
30414 int res3 = 0 ;
30415 int temp4 ;
30416 int res4 = 0 ;
30417 int temp5 ;
30418 int res5 = 0 ;
30419 int temp6 ;
30420 int res6 = 0 ;
30421 PyObject * obj0 = 0 ;
30422 PyObject * obj1 = 0 ;
30423 PyObject * obj2 = 0 ;
30424 char *kwnames[] = {
30425 (char *) "self",(char *) "string",(char *) "font", NULL
30426 };
30427
30428 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30429 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30430 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30431 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30434 if (SWIG_arg_fail(1)) SWIG_fail;
30435 {
30436 arg2 = wxString_in_helper(obj1);
30437 if (arg2 == NULL) SWIG_fail;
30438 temp2 = true;
30439 }
30440 if (obj2) {
30441 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30442 if (SWIG_arg_fail(7)) SWIG_fail;
30443 }
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30447
30448 wxPyEndAllowThreads(__tstate);
30449 if (PyErr_Occurred()) SWIG_fail;
30450 }
30451 Py_INCREF(Py_None); resultobj = Py_None;
30452 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30453 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30454 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30455 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30456 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30457 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30458 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30459 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30460 {
30461 if (temp2)
30462 delete arg2;
30463 }
30464 return resultobj;
30465 fail:
30466 {
30467 if (temp2)
30468 delete arg2;
30469 }
30470 return NULL;
30471 }
30472
30473
30474 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30475 PyObject *resultobj;
30476 wxWindow *arg1 = (wxWindow *) 0 ;
30477 int *arg2 = (int *) 0 ;
30478 int *arg3 = (int *) 0 ;
30479 int temp2 ;
30480 int res2 = 0 ;
30481 int temp3 ;
30482 int res3 = 0 ;
30483 PyObject * obj0 = 0 ;
30484 PyObject * obj1 = 0 ;
30485 PyObject * obj2 = 0 ;
30486 char *kwnames[] = {
30487 (char *) "self",(char *) "x",(char *) "y", NULL
30488 };
30489
30490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30492 if (SWIG_arg_fail(1)) SWIG_fail;
30493 {
30494 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30495 temp2 = SWIG_As_int(obj1);
30496 if (SWIG_arg_fail(2)) SWIG_fail;
30497 arg2 = &temp2;
30498 res2 = SWIG_NEWOBJ;
30499 }
30500 }
30501 {
30502 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30503 temp3 = SWIG_As_int(obj2);
30504 if (SWIG_arg_fail(3)) SWIG_fail;
30505 arg3 = &temp3;
30506 res3 = SWIG_NEWOBJ;
30507 }
30508 }
30509 {
30510 PyThreadState* __tstate = wxPyBeginAllowThreads();
30511 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30512
30513 wxPyEndAllowThreads(__tstate);
30514 if (PyErr_Occurred()) SWIG_fail;
30515 }
30516 Py_INCREF(Py_None); resultobj = Py_None;
30517 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30518 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30519 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30520 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30521 return resultobj;
30522 fail:
30523 return NULL;
30524 }
30525
30526
30527 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30528 PyObject *resultobj;
30529 wxWindow *arg1 = (wxWindow *) 0 ;
30530 int *arg2 = (int *) 0 ;
30531 int *arg3 = (int *) 0 ;
30532 int temp2 ;
30533 int res2 = 0 ;
30534 int temp3 ;
30535 int res3 = 0 ;
30536 PyObject * obj0 = 0 ;
30537 PyObject * obj1 = 0 ;
30538 PyObject * obj2 = 0 ;
30539 char *kwnames[] = {
30540 (char *) "self",(char *) "x",(char *) "y", NULL
30541 };
30542
30543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30545 if (SWIG_arg_fail(1)) SWIG_fail;
30546 {
30547 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30548 temp2 = SWIG_As_int(obj1);
30549 if (SWIG_arg_fail(2)) SWIG_fail;
30550 arg2 = &temp2;
30551 res2 = SWIG_NEWOBJ;
30552 }
30553 }
30554 {
30555 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30556 temp3 = SWIG_As_int(obj2);
30557 if (SWIG_arg_fail(3)) SWIG_fail;
30558 arg3 = &temp3;
30559 res3 = SWIG_NEWOBJ;
30560 }
30561 }
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30565
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 Py_INCREF(Py_None); resultobj = Py_None;
30570 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30571 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30572 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30573 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj;
30582 wxWindow *arg1 = (wxWindow *) 0 ;
30583 wxPoint *arg2 = 0 ;
30584 wxPoint result;
30585 wxPoint temp2 ;
30586 PyObject * obj0 = 0 ;
30587 PyObject * obj1 = 0 ;
30588 char *kwnames[] = {
30589 (char *) "self",(char *) "pt", NULL
30590 };
30591
30592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30594 if (SWIG_arg_fail(1)) SWIG_fail;
30595 {
30596 arg2 = &temp2;
30597 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30598 }
30599 {
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30602
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 {
30607 wxPoint * resultptr;
30608 resultptr = new wxPoint((wxPoint &)(result));
30609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30610 }
30611 return resultobj;
30612 fail:
30613 return NULL;
30614 }
30615
30616
30617 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj;
30619 wxWindow *arg1 = (wxWindow *) 0 ;
30620 wxPoint *arg2 = 0 ;
30621 wxPoint result;
30622 wxPoint temp2 ;
30623 PyObject * obj0 = 0 ;
30624 PyObject * obj1 = 0 ;
30625 char *kwnames[] = {
30626 (char *) "self",(char *) "pt", NULL
30627 };
30628
30629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30631 if (SWIG_arg_fail(1)) SWIG_fail;
30632 {
30633 arg2 = &temp2;
30634 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30635 }
30636 {
30637 PyThreadState* __tstate = wxPyBeginAllowThreads();
30638 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30639
30640 wxPyEndAllowThreads(__tstate);
30641 if (PyErr_Occurred()) SWIG_fail;
30642 }
30643 {
30644 wxPoint * resultptr;
30645 resultptr = new wxPoint((wxPoint &)(result));
30646 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30647 }
30648 return resultobj;
30649 fail:
30650 return NULL;
30651 }
30652
30653
30654 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30655 PyObject *resultobj;
30656 wxWindow *arg1 = (wxWindow *) 0 ;
30657 int arg2 ;
30658 int arg3 ;
30659 wxHitTest result;
30660 PyObject * obj0 = 0 ;
30661 PyObject * obj1 = 0 ;
30662 PyObject * obj2 = 0 ;
30663 char *kwnames[] = {
30664 (char *) "self",(char *) "x",(char *) "y", NULL
30665 };
30666
30667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30669 if (SWIG_arg_fail(1)) SWIG_fail;
30670 {
30671 arg2 = (int)(SWIG_As_int(obj1));
30672 if (SWIG_arg_fail(2)) SWIG_fail;
30673 }
30674 {
30675 arg3 = (int)(SWIG_As_int(obj2));
30676 if (SWIG_arg_fail(3)) SWIG_fail;
30677 }
30678 {
30679 PyThreadState* __tstate = wxPyBeginAllowThreads();
30680 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30681
30682 wxPyEndAllowThreads(__tstate);
30683 if (PyErr_Occurred()) SWIG_fail;
30684 }
30685 resultobj = SWIG_From_int((result));
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj;
30694 wxWindow *arg1 = (wxWindow *) 0 ;
30695 wxPoint *arg2 = 0 ;
30696 wxHitTest result;
30697 wxPoint temp2 ;
30698 PyObject * obj0 = 0 ;
30699 PyObject * obj1 = 0 ;
30700 char *kwnames[] = {
30701 (char *) "self",(char *) "pt", NULL
30702 };
30703
30704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30706 if (SWIG_arg_fail(1)) SWIG_fail;
30707 {
30708 arg2 = &temp2;
30709 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30710 }
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30714
30715 wxPyEndAllowThreads(__tstate);
30716 if (PyErr_Occurred()) SWIG_fail;
30717 }
30718 resultobj = SWIG_From_int((result));
30719 return resultobj;
30720 fail:
30721 return NULL;
30722 }
30723
30724
30725 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30726 PyObject *resultobj;
30727 wxWindow *arg1 = (wxWindow *) 0 ;
30728 long arg2 ;
30729 wxBorder result;
30730 PyObject * obj0 = 0 ;
30731 PyObject * obj1 = 0 ;
30732
30733 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30735 if (SWIG_arg_fail(1)) SWIG_fail;
30736 {
30737 arg2 = (long)(SWIG_As_long(obj1));
30738 if (SWIG_arg_fail(2)) SWIG_fail;
30739 }
30740 {
30741 PyThreadState* __tstate = wxPyBeginAllowThreads();
30742 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30743
30744 wxPyEndAllowThreads(__tstate);
30745 if (PyErr_Occurred()) SWIG_fail;
30746 }
30747 resultobj = SWIG_From_int((result));
30748 return resultobj;
30749 fail:
30750 return NULL;
30751 }
30752
30753
30754 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30755 PyObject *resultobj;
30756 wxWindow *arg1 = (wxWindow *) 0 ;
30757 wxBorder result;
30758 PyObject * obj0 = 0 ;
30759
30760 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30762 if (SWIG_arg_fail(1)) SWIG_fail;
30763 {
30764 PyThreadState* __tstate = wxPyBeginAllowThreads();
30765 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30766
30767 wxPyEndAllowThreads(__tstate);
30768 if (PyErr_Occurred()) SWIG_fail;
30769 }
30770 resultobj = SWIG_From_int((result));
30771 return resultobj;
30772 fail:
30773 return NULL;
30774 }
30775
30776
30777 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30778 int argc;
30779 PyObject *argv[3];
30780 int ii;
30781
30782 argc = PyObject_Length(args);
30783 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30784 argv[ii] = PyTuple_GetItem(args,ii);
30785 }
30786 if (argc == 1) {
30787 int _v;
30788 {
30789 void *ptr;
30790 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30791 _v = 0;
30792 PyErr_Clear();
30793 } else {
30794 _v = 1;
30795 }
30796 }
30797 if (_v) {
30798 return _wrap_Window_GetBorder__SWIG_1(self,args);
30799 }
30800 }
30801 if (argc == 2) {
30802 int _v;
30803 {
30804 void *ptr;
30805 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30806 _v = 0;
30807 PyErr_Clear();
30808 } else {
30809 _v = 1;
30810 }
30811 }
30812 if (_v) {
30813 _v = SWIG_Check_long(argv[1]);
30814 if (_v) {
30815 return _wrap_Window_GetBorder__SWIG_0(self,args);
30816 }
30817 }
30818 }
30819
30820 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30821 return NULL;
30822 }
30823
30824
30825 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30826 PyObject *resultobj;
30827 wxWindow *arg1 = (wxWindow *) 0 ;
30828 long arg2 = (long) wxUPDATE_UI_NONE ;
30829 PyObject * obj0 = 0 ;
30830 PyObject * obj1 = 0 ;
30831 char *kwnames[] = {
30832 (char *) "self",(char *) "flags", NULL
30833 };
30834
30835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30837 if (SWIG_arg_fail(1)) SWIG_fail;
30838 if (obj1) {
30839 {
30840 arg2 = (long)(SWIG_As_long(obj1));
30841 if (SWIG_arg_fail(2)) SWIG_fail;
30842 }
30843 }
30844 {
30845 PyThreadState* __tstate = wxPyBeginAllowThreads();
30846 (arg1)->UpdateWindowUI(arg2);
30847
30848 wxPyEndAllowThreads(__tstate);
30849 if (PyErr_Occurred()) SWIG_fail;
30850 }
30851 Py_INCREF(Py_None); resultobj = Py_None;
30852 return resultobj;
30853 fail:
30854 return NULL;
30855 }
30856
30857
30858 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30859 PyObject *resultobj;
30860 wxWindow *arg1 = (wxWindow *) 0 ;
30861 wxMenu *arg2 = (wxMenu *) 0 ;
30862 int arg3 = (int) -1 ;
30863 int arg4 = (int) -1 ;
30864 bool result;
30865 PyObject * obj0 = 0 ;
30866 PyObject * obj1 = 0 ;
30867 PyObject * obj2 = 0 ;
30868 PyObject * obj3 = 0 ;
30869 char *kwnames[] = {
30870 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30871 };
30872
30873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30875 if (SWIG_arg_fail(1)) SWIG_fail;
30876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30877 if (SWIG_arg_fail(2)) SWIG_fail;
30878 if (obj2) {
30879 {
30880 arg3 = (int)(SWIG_As_int(obj2));
30881 if (SWIG_arg_fail(3)) SWIG_fail;
30882 }
30883 }
30884 if (obj3) {
30885 {
30886 arg4 = (int)(SWIG_As_int(obj3));
30887 if (SWIG_arg_fail(4)) SWIG_fail;
30888 }
30889 }
30890 {
30891 PyThreadState* __tstate = wxPyBeginAllowThreads();
30892 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30893
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 {
30898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30899 }
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30907 PyObject *resultobj;
30908 wxWindow *arg1 = (wxWindow *) 0 ;
30909 wxMenu *arg2 = (wxMenu *) 0 ;
30910 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30911 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30912 bool result;
30913 wxPoint temp3 ;
30914 PyObject * obj0 = 0 ;
30915 PyObject * obj1 = 0 ;
30916 PyObject * obj2 = 0 ;
30917 char *kwnames[] = {
30918 (char *) "self",(char *) "menu",(char *) "pos", NULL
30919 };
30920
30921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30923 if (SWIG_arg_fail(1)) SWIG_fail;
30924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30925 if (SWIG_arg_fail(2)) SWIG_fail;
30926 if (obj2) {
30927 {
30928 arg3 = &temp3;
30929 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30930 }
30931 }
30932 {
30933 PyThreadState* __tstate = wxPyBeginAllowThreads();
30934 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30935
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 {
30940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30941 }
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj;
30950 wxWindow *arg1 = (wxWindow *) 0 ;
30951 long result;
30952 PyObject * obj0 = 0 ;
30953 char *kwnames[] = {
30954 (char *) "self", NULL
30955 };
30956
30957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30959 if (SWIG_arg_fail(1)) SWIG_fail;
30960 {
30961 PyThreadState* __tstate = wxPyBeginAllowThreads();
30962 result = (long)wxWindow_GetHandle(arg1);
30963
30964 wxPyEndAllowThreads(__tstate);
30965 if (PyErr_Occurred()) SWIG_fail;
30966 }
30967 {
30968 resultobj = SWIG_From_long((long)(result));
30969 }
30970 return resultobj;
30971 fail:
30972 return NULL;
30973 }
30974
30975
30976 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30977 PyObject *resultobj;
30978 wxWindow *arg1 = (wxWindow *) 0 ;
30979 long arg2 ;
30980 PyObject * obj0 = 0 ;
30981 PyObject * obj1 = 0 ;
30982 char *kwnames[] = {
30983 (char *) "self",(char *) "handle", NULL
30984 };
30985
30986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30988 if (SWIG_arg_fail(1)) SWIG_fail;
30989 {
30990 arg2 = (long)(SWIG_As_long(obj1));
30991 if (SWIG_arg_fail(2)) SWIG_fail;
30992 }
30993 {
30994 PyThreadState* __tstate = wxPyBeginAllowThreads();
30995 wxWindow_AssociateHandle(arg1,arg2);
30996
30997 wxPyEndAllowThreads(__tstate);
30998 if (PyErr_Occurred()) SWIG_fail;
30999 }
31000 Py_INCREF(Py_None); resultobj = Py_None;
31001 return resultobj;
31002 fail:
31003 return NULL;
31004 }
31005
31006
31007 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31008 PyObject *resultobj;
31009 wxWindow *arg1 = (wxWindow *) 0 ;
31010 PyObject * obj0 = 0 ;
31011 char *kwnames[] = {
31012 (char *) "self", NULL
31013 };
31014
31015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31017 if (SWIG_arg_fail(1)) SWIG_fail;
31018 {
31019 PyThreadState* __tstate = wxPyBeginAllowThreads();
31020 (arg1)->DissociateHandle();
31021
31022 wxPyEndAllowThreads(__tstate);
31023 if (PyErr_Occurred()) SWIG_fail;
31024 }
31025 Py_INCREF(Py_None); resultobj = Py_None;
31026 return resultobj;
31027 fail:
31028 return NULL;
31029 }
31030
31031
31032 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
31033 PyObject *resultobj;
31034 wxWindow *arg1 = (wxWindow *) 0 ;
31035 wxPaintEvent *arg2 = 0 ;
31036 PyObject * obj0 = 0 ;
31037 PyObject * obj1 = 0 ;
31038 char *kwnames[] = {
31039 (char *) "self",(char *) "event", NULL
31040 };
31041
31042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
31043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31044 if (SWIG_arg_fail(1)) SWIG_fail;
31045 {
31046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
31047 if (SWIG_arg_fail(2)) SWIG_fail;
31048 if (arg2 == NULL) {
31049 SWIG_null_ref("wxPaintEvent");
31050 }
31051 if (SWIG_arg_fail(2)) SWIG_fail;
31052 }
31053 {
31054 PyThreadState* __tstate = wxPyBeginAllowThreads();
31055 (arg1)->OnPaint(*arg2);
31056
31057 wxPyEndAllowThreads(__tstate);
31058 if (PyErr_Occurred()) SWIG_fail;
31059 }
31060 Py_INCREF(Py_None); resultobj = Py_None;
31061 return resultobj;
31062 fail:
31063 return NULL;
31064 }
31065
31066
31067 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31068 PyObject *resultobj;
31069 wxWindow *arg1 = (wxWindow *) 0 ;
31070 int arg2 ;
31071 bool result;
31072 PyObject * obj0 = 0 ;
31073 PyObject * obj1 = 0 ;
31074 char *kwnames[] = {
31075 (char *) "self",(char *) "orient", NULL
31076 };
31077
31078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31080 if (SWIG_arg_fail(1)) SWIG_fail;
31081 {
31082 arg2 = (int)(SWIG_As_int(obj1));
31083 if (SWIG_arg_fail(2)) SWIG_fail;
31084 }
31085 {
31086 PyThreadState* __tstate = wxPyBeginAllowThreads();
31087 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31088
31089 wxPyEndAllowThreads(__tstate);
31090 if (PyErr_Occurred()) SWIG_fail;
31091 }
31092 {
31093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31094 }
31095 return resultobj;
31096 fail:
31097 return NULL;
31098 }
31099
31100
31101 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31102 PyObject *resultobj;
31103 wxWindow *arg1 = (wxWindow *) 0 ;
31104 int arg2 ;
31105 int arg3 ;
31106 int arg4 ;
31107 int arg5 ;
31108 bool arg6 = (bool) true ;
31109 PyObject * obj0 = 0 ;
31110 PyObject * obj1 = 0 ;
31111 PyObject * obj2 = 0 ;
31112 PyObject * obj3 = 0 ;
31113 PyObject * obj4 = 0 ;
31114 PyObject * obj5 = 0 ;
31115 char *kwnames[] = {
31116 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31117 };
31118
31119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31121 if (SWIG_arg_fail(1)) SWIG_fail;
31122 {
31123 arg2 = (int)(SWIG_As_int(obj1));
31124 if (SWIG_arg_fail(2)) SWIG_fail;
31125 }
31126 {
31127 arg3 = (int)(SWIG_As_int(obj2));
31128 if (SWIG_arg_fail(3)) SWIG_fail;
31129 }
31130 {
31131 arg4 = (int)(SWIG_As_int(obj3));
31132 if (SWIG_arg_fail(4)) SWIG_fail;
31133 }
31134 {
31135 arg5 = (int)(SWIG_As_int(obj4));
31136 if (SWIG_arg_fail(5)) SWIG_fail;
31137 }
31138 if (obj5) {
31139 {
31140 arg6 = (bool)(SWIG_As_bool(obj5));
31141 if (SWIG_arg_fail(6)) SWIG_fail;
31142 }
31143 }
31144 {
31145 PyThreadState* __tstate = wxPyBeginAllowThreads();
31146 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31147
31148 wxPyEndAllowThreads(__tstate);
31149 if (PyErr_Occurred()) SWIG_fail;
31150 }
31151 Py_INCREF(Py_None); resultobj = Py_None;
31152 return resultobj;
31153 fail:
31154 return NULL;
31155 }
31156
31157
31158 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31159 PyObject *resultobj;
31160 wxWindow *arg1 = (wxWindow *) 0 ;
31161 int arg2 ;
31162 int arg3 ;
31163 bool arg4 = (bool) true ;
31164 PyObject * obj0 = 0 ;
31165 PyObject * obj1 = 0 ;
31166 PyObject * obj2 = 0 ;
31167 PyObject * obj3 = 0 ;
31168 char *kwnames[] = {
31169 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31170 };
31171
31172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31174 if (SWIG_arg_fail(1)) SWIG_fail;
31175 {
31176 arg2 = (int)(SWIG_As_int(obj1));
31177 if (SWIG_arg_fail(2)) SWIG_fail;
31178 }
31179 {
31180 arg3 = (int)(SWIG_As_int(obj2));
31181 if (SWIG_arg_fail(3)) SWIG_fail;
31182 }
31183 if (obj3) {
31184 {
31185 arg4 = (bool)(SWIG_As_bool(obj3));
31186 if (SWIG_arg_fail(4)) SWIG_fail;
31187 }
31188 }
31189 {
31190 PyThreadState* __tstate = wxPyBeginAllowThreads();
31191 (arg1)->SetScrollPos(arg2,arg3,arg4);
31192
31193 wxPyEndAllowThreads(__tstate);
31194 if (PyErr_Occurred()) SWIG_fail;
31195 }
31196 Py_INCREF(Py_None); resultobj = Py_None;
31197 return resultobj;
31198 fail:
31199 return NULL;
31200 }
31201
31202
31203 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31204 PyObject *resultobj;
31205 wxWindow *arg1 = (wxWindow *) 0 ;
31206 int arg2 ;
31207 int result;
31208 PyObject * obj0 = 0 ;
31209 PyObject * obj1 = 0 ;
31210 char *kwnames[] = {
31211 (char *) "self",(char *) "orientation", NULL
31212 };
31213
31214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31216 if (SWIG_arg_fail(1)) SWIG_fail;
31217 {
31218 arg2 = (int)(SWIG_As_int(obj1));
31219 if (SWIG_arg_fail(2)) SWIG_fail;
31220 }
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31224
31225 wxPyEndAllowThreads(__tstate);
31226 if (PyErr_Occurred()) SWIG_fail;
31227 }
31228 {
31229 resultobj = SWIG_From_int((int)(result));
31230 }
31231 return resultobj;
31232 fail:
31233 return NULL;
31234 }
31235
31236
31237 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31238 PyObject *resultobj;
31239 wxWindow *arg1 = (wxWindow *) 0 ;
31240 int arg2 ;
31241 int result;
31242 PyObject * obj0 = 0 ;
31243 PyObject * obj1 = 0 ;
31244 char *kwnames[] = {
31245 (char *) "self",(char *) "orientation", NULL
31246 };
31247
31248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31250 if (SWIG_arg_fail(1)) SWIG_fail;
31251 {
31252 arg2 = (int)(SWIG_As_int(obj1));
31253 if (SWIG_arg_fail(2)) SWIG_fail;
31254 }
31255 {
31256 PyThreadState* __tstate = wxPyBeginAllowThreads();
31257 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31258
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 {
31263 resultobj = SWIG_From_int((int)(result));
31264 }
31265 return resultobj;
31266 fail:
31267 return NULL;
31268 }
31269
31270
31271 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31272 PyObject *resultobj;
31273 wxWindow *arg1 = (wxWindow *) 0 ;
31274 int arg2 ;
31275 int result;
31276 PyObject * obj0 = 0 ;
31277 PyObject * obj1 = 0 ;
31278 char *kwnames[] = {
31279 (char *) "self",(char *) "orientation", NULL
31280 };
31281
31282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31284 if (SWIG_arg_fail(1)) SWIG_fail;
31285 {
31286 arg2 = (int)(SWIG_As_int(obj1));
31287 if (SWIG_arg_fail(2)) SWIG_fail;
31288 }
31289 {
31290 PyThreadState* __tstate = wxPyBeginAllowThreads();
31291 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31292
31293 wxPyEndAllowThreads(__tstate);
31294 if (PyErr_Occurred()) SWIG_fail;
31295 }
31296 {
31297 resultobj = SWIG_From_int((int)(result));
31298 }
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31306 PyObject *resultobj;
31307 wxWindow *arg1 = (wxWindow *) 0 ;
31308 int arg2 ;
31309 int arg3 ;
31310 wxRect *arg4 = (wxRect *) NULL ;
31311 PyObject * obj0 = 0 ;
31312 PyObject * obj1 = 0 ;
31313 PyObject * obj2 = 0 ;
31314 PyObject * obj3 = 0 ;
31315 char *kwnames[] = {
31316 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31317 };
31318
31319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg3 = (int)(SWIG_As_int(obj2));
31328 if (SWIG_arg_fail(3)) SWIG_fail;
31329 }
31330 if (obj3) {
31331 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31332 if (SWIG_arg_fail(4)) SWIG_fail;
31333 }
31334 {
31335 PyThreadState* __tstate = wxPyBeginAllowThreads();
31336 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31337
31338 wxPyEndAllowThreads(__tstate);
31339 if (PyErr_Occurred()) SWIG_fail;
31340 }
31341 Py_INCREF(Py_None); resultobj = Py_None;
31342 return resultobj;
31343 fail:
31344 return NULL;
31345 }
31346
31347
31348 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31349 PyObject *resultobj;
31350 wxWindow *arg1 = (wxWindow *) 0 ;
31351 int arg2 ;
31352 bool result;
31353 PyObject * obj0 = 0 ;
31354 PyObject * obj1 = 0 ;
31355 char *kwnames[] = {
31356 (char *) "self",(char *) "lines", NULL
31357 };
31358
31359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31361 if (SWIG_arg_fail(1)) SWIG_fail;
31362 {
31363 arg2 = (int)(SWIG_As_int(obj1));
31364 if (SWIG_arg_fail(2)) SWIG_fail;
31365 }
31366 {
31367 PyThreadState* __tstate = wxPyBeginAllowThreads();
31368 result = (bool)(arg1)->ScrollLines(arg2);
31369
31370 wxPyEndAllowThreads(__tstate);
31371 if (PyErr_Occurred()) SWIG_fail;
31372 }
31373 {
31374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31375 }
31376 return resultobj;
31377 fail:
31378 return NULL;
31379 }
31380
31381
31382 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31383 PyObject *resultobj;
31384 wxWindow *arg1 = (wxWindow *) 0 ;
31385 int arg2 ;
31386 bool result;
31387 PyObject * obj0 = 0 ;
31388 PyObject * obj1 = 0 ;
31389 char *kwnames[] = {
31390 (char *) "self",(char *) "pages", NULL
31391 };
31392
31393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31395 if (SWIG_arg_fail(1)) SWIG_fail;
31396 {
31397 arg2 = (int)(SWIG_As_int(obj1));
31398 if (SWIG_arg_fail(2)) SWIG_fail;
31399 }
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 result = (bool)(arg1)->ScrollPages(arg2);
31403
31404 wxPyEndAllowThreads(__tstate);
31405 if (PyErr_Occurred()) SWIG_fail;
31406 }
31407 {
31408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31409 }
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31417 PyObject *resultobj;
31418 wxWindow *arg1 = (wxWindow *) 0 ;
31419 bool result;
31420 PyObject * obj0 = 0 ;
31421 char *kwnames[] = {
31422 (char *) "self", NULL
31423 };
31424
31425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31427 if (SWIG_arg_fail(1)) SWIG_fail;
31428 {
31429 PyThreadState* __tstate = wxPyBeginAllowThreads();
31430 result = (bool)(arg1)->LineUp();
31431
31432 wxPyEndAllowThreads(__tstate);
31433 if (PyErr_Occurred()) SWIG_fail;
31434 }
31435 {
31436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31437 }
31438 return resultobj;
31439 fail:
31440 return NULL;
31441 }
31442
31443
31444 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31445 PyObject *resultobj;
31446 wxWindow *arg1 = (wxWindow *) 0 ;
31447 bool result;
31448 PyObject * obj0 = 0 ;
31449 char *kwnames[] = {
31450 (char *) "self", NULL
31451 };
31452
31453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31455 if (SWIG_arg_fail(1)) SWIG_fail;
31456 {
31457 PyThreadState* __tstate = wxPyBeginAllowThreads();
31458 result = (bool)(arg1)->LineDown();
31459
31460 wxPyEndAllowThreads(__tstate);
31461 if (PyErr_Occurred()) SWIG_fail;
31462 }
31463 {
31464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31465 }
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31473 PyObject *resultobj;
31474 wxWindow *arg1 = (wxWindow *) 0 ;
31475 bool result;
31476 PyObject * obj0 = 0 ;
31477 char *kwnames[] = {
31478 (char *) "self", NULL
31479 };
31480
31481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31483 if (SWIG_arg_fail(1)) SWIG_fail;
31484 {
31485 PyThreadState* __tstate = wxPyBeginAllowThreads();
31486 result = (bool)(arg1)->PageUp();
31487
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 {
31492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31493 }
31494 return resultobj;
31495 fail:
31496 return NULL;
31497 }
31498
31499
31500 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31501 PyObject *resultobj;
31502 wxWindow *arg1 = (wxWindow *) 0 ;
31503 bool result;
31504 PyObject * obj0 = 0 ;
31505 char *kwnames[] = {
31506 (char *) "self", NULL
31507 };
31508
31509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31511 if (SWIG_arg_fail(1)) SWIG_fail;
31512 {
31513 PyThreadState* __tstate = wxPyBeginAllowThreads();
31514 result = (bool)(arg1)->PageDown();
31515
31516 wxPyEndAllowThreads(__tstate);
31517 if (PyErr_Occurred()) SWIG_fail;
31518 }
31519 {
31520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31521 }
31522 return resultobj;
31523 fail:
31524 return NULL;
31525 }
31526
31527
31528 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31529 PyObject *resultobj;
31530 wxWindow *arg1 = (wxWindow *) 0 ;
31531 wxString *arg2 = 0 ;
31532 bool temp2 = false ;
31533 PyObject * obj0 = 0 ;
31534 PyObject * obj1 = 0 ;
31535 char *kwnames[] = {
31536 (char *) "self",(char *) "text", NULL
31537 };
31538
31539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31541 if (SWIG_arg_fail(1)) SWIG_fail;
31542 {
31543 arg2 = wxString_in_helper(obj1);
31544 if (arg2 == NULL) SWIG_fail;
31545 temp2 = true;
31546 }
31547 {
31548 PyThreadState* __tstate = wxPyBeginAllowThreads();
31549 (arg1)->SetHelpText((wxString const &)*arg2);
31550
31551 wxPyEndAllowThreads(__tstate);
31552 if (PyErr_Occurred()) SWIG_fail;
31553 }
31554 Py_INCREF(Py_None); resultobj = Py_None;
31555 {
31556 if (temp2)
31557 delete arg2;
31558 }
31559 return resultobj;
31560 fail:
31561 {
31562 if (temp2)
31563 delete arg2;
31564 }
31565 return NULL;
31566 }
31567
31568
31569 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31570 PyObject *resultobj;
31571 wxWindow *arg1 = (wxWindow *) 0 ;
31572 wxString *arg2 = 0 ;
31573 bool temp2 = false ;
31574 PyObject * obj0 = 0 ;
31575 PyObject * obj1 = 0 ;
31576 char *kwnames[] = {
31577 (char *) "self",(char *) "text", NULL
31578 };
31579
31580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31582 if (SWIG_arg_fail(1)) SWIG_fail;
31583 {
31584 arg2 = wxString_in_helper(obj1);
31585 if (arg2 == NULL) SWIG_fail;
31586 temp2 = true;
31587 }
31588 {
31589 PyThreadState* __tstate = wxPyBeginAllowThreads();
31590 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31591
31592 wxPyEndAllowThreads(__tstate);
31593 if (PyErr_Occurred()) SWIG_fail;
31594 }
31595 Py_INCREF(Py_None); resultobj = Py_None;
31596 {
31597 if (temp2)
31598 delete arg2;
31599 }
31600 return resultobj;
31601 fail:
31602 {
31603 if (temp2)
31604 delete arg2;
31605 }
31606 return NULL;
31607 }
31608
31609
31610 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31611 PyObject *resultobj;
31612 wxWindow *arg1 = (wxWindow *) 0 ;
31613 wxString result;
31614 PyObject * obj0 = 0 ;
31615 char *kwnames[] = {
31616 (char *) "self", NULL
31617 };
31618
31619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) 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 {
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 result = ((wxWindow const *)arg1)->GetHelpText();
31625
31626 wxPyEndAllowThreads(__tstate);
31627 if (PyErr_Occurred()) SWIG_fail;
31628 }
31629 {
31630 #if wxUSE_UNICODE
31631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31632 #else
31633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31634 #endif
31635 }
31636 return resultobj;
31637 fail:
31638 return NULL;
31639 }
31640
31641
31642 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31643 PyObject *resultobj;
31644 wxWindow *arg1 = (wxWindow *) 0 ;
31645 wxString *arg2 = 0 ;
31646 bool temp2 = false ;
31647 PyObject * obj0 = 0 ;
31648 PyObject * obj1 = 0 ;
31649 char *kwnames[] = {
31650 (char *) "self",(char *) "tip", NULL
31651 };
31652
31653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31655 if (SWIG_arg_fail(1)) SWIG_fail;
31656 {
31657 arg2 = wxString_in_helper(obj1);
31658 if (arg2 == NULL) SWIG_fail;
31659 temp2 = true;
31660 }
31661 {
31662 PyThreadState* __tstate = wxPyBeginAllowThreads();
31663 (arg1)->SetToolTip((wxString const &)*arg2);
31664
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 Py_INCREF(Py_None); resultobj = Py_None;
31669 {
31670 if (temp2)
31671 delete arg2;
31672 }
31673 return resultobj;
31674 fail:
31675 {
31676 if (temp2)
31677 delete arg2;
31678 }
31679 return NULL;
31680 }
31681
31682
31683 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31684 PyObject *resultobj;
31685 wxWindow *arg1 = (wxWindow *) 0 ;
31686 wxToolTip *arg2 = (wxToolTip *) 0 ;
31687 PyObject * obj0 = 0 ;
31688 PyObject * obj1 = 0 ;
31689 char *kwnames[] = {
31690 (char *) "self",(char *) "tip", NULL
31691 };
31692
31693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31695 if (SWIG_arg_fail(1)) SWIG_fail;
31696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31697 if (SWIG_arg_fail(2)) SWIG_fail;
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 (arg1)->SetToolTip(arg2);
31701
31702 wxPyEndAllowThreads(__tstate);
31703 if (PyErr_Occurred()) SWIG_fail;
31704 }
31705 Py_INCREF(Py_None); resultobj = Py_None;
31706 return resultobj;
31707 fail:
31708 return NULL;
31709 }
31710
31711
31712 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31713 PyObject *resultobj;
31714 wxWindow *arg1 = (wxWindow *) 0 ;
31715 wxToolTip *result;
31716 PyObject * obj0 = 0 ;
31717 char *kwnames[] = {
31718 (char *) "self", NULL
31719 };
31720
31721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31723 if (SWIG_arg_fail(1)) SWIG_fail;
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31727
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 {
31732 resultobj = wxPyMake_wxObject(result, 0);
31733 }
31734 return resultobj;
31735 fail:
31736 return NULL;
31737 }
31738
31739
31740 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31741 PyObject *resultobj;
31742 wxWindow *arg1 = (wxWindow *) 0 ;
31743 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31744 PyObject * obj0 = 0 ;
31745 PyObject * obj1 = 0 ;
31746 char *kwnames[] = {
31747 (char *) "self",(char *) "dropTarget", NULL
31748 };
31749
31750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31752 if (SWIG_arg_fail(1)) SWIG_fail;
31753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31754 if (SWIG_arg_fail(2)) SWIG_fail;
31755 {
31756 PyThreadState* __tstate = wxPyBeginAllowThreads();
31757 (arg1)->SetDropTarget(arg2);
31758
31759 wxPyEndAllowThreads(__tstate);
31760 if (PyErr_Occurred()) SWIG_fail;
31761 }
31762 Py_INCREF(Py_None); resultobj = Py_None;
31763 return resultobj;
31764 fail:
31765 return NULL;
31766 }
31767
31768
31769 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31770 PyObject *resultobj;
31771 wxWindow *arg1 = (wxWindow *) 0 ;
31772 wxPyDropTarget *result;
31773 PyObject * obj0 = 0 ;
31774 char *kwnames[] = {
31775 (char *) "self", NULL
31776 };
31777
31778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31780 if (SWIG_arg_fail(1)) SWIG_fail;
31781 {
31782 PyThreadState* __tstate = wxPyBeginAllowThreads();
31783 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31784
31785 wxPyEndAllowThreads(__tstate);
31786 if (PyErr_Occurred()) SWIG_fail;
31787 }
31788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31789 return resultobj;
31790 fail:
31791 return NULL;
31792 }
31793
31794
31795 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31796 PyObject *resultobj;
31797 wxWindow *arg1 = (wxWindow *) 0 ;
31798 bool arg2 ;
31799 PyObject * obj0 = 0 ;
31800 PyObject * obj1 = 0 ;
31801 char *kwnames[] = {
31802 (char *) "self",(char *) "accept", NULL
31803 };
31804
31805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31807 if (SWIG_arg_fail(1)) SWIG_fail;
31808 {
31809 arg2 = (bool)(SWIG_As_bool(obj1));
31810 if (SWIG_arg_fail(2)) SWIG_fail;
31811 }
31812 {
31813 PyThreadState* __tstate = wxPyBeginAllowThreads();
31814 (arg1)->DragAcceptFiles(arg2);
31815
31816 wxPyEndAllowThreads(__tstate);
31817 if (PyErr_Occurred()) SWIG_fail;
31818 }
31819 Py_INCREF(Py_None); resultobj = Py_None;
31820 return resultobj;
31821 fail:
31822 return NULL;
31823 }
31824
31825
31826 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31827 PyObject *resultobj;
31828 wxWindow *arg1 = (wxWindow *) 0 ;
31829 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31830 PyObject * obj0 = 0 ;
31831 PyObject * obj1 = 0 ;
31832 char *kwnames[] = {
31833 (char *) "self",(char *) "constraints", NULL
31834 };
31835
31836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31838 if (SWIG_arg_fail(1)) SWIG_fail;
31839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31840 if (SWIG_arg_fail(2)) SWIG_fail;
31841 {
31842 PyThreadState* __tstate = wxPyBeginAllowThreads();
31843 (arg1)->SetConstraints(arg2);
31844
31845 wxPyEndAllowThreads(__tstate);
31846 if (PyErr_Occurred()) SWIG_fail;
31847 }
31848 Py_INCREF(Py_None); resultobj = Py_None;
31849 return resultobj;
31850 fail:
31851 return NULL;
31852 }
31853
31854
31855 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31856 PyObject *resultobj;
31857 wxWindow *arg1 = (wxWindow *) 0 ;
31858 wxLayoutConstraints *result;
31859 PyObject * obj0 = 0 ;
31860 char *kwnames[] = {
31861 (char *) "self", NULL
31862 };
31863
31864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31866 if (SWIG_arg_fail(1)) SWIG_fail;
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31870
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31875 return resultobj;
31876 fail:
31877 return NULL;
31878 }
31879
31880
31881 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31882 PyObject *resultobj;
31883 wxWindow *arg1 = (wxWindow *) 0 ;
31884 bool arg2 ;
31885 PyObject * obj0 = 0 ;
31886 PyObject * obj1 = 0 ;
31887 char *kwnames[] = {
31888 (char *) "self",(char *) "autoLayout", NULL
31889 };
31890
31891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31893 if (SWIG_arg_fail(1)) SWIG_fail;
31894 {
31895 arg2 = (bool)(SWIG_As_bool(obj1));
31896 if (SWIG_arg_fail(2)) SWIG_fail;
31897 }
31898 {
31899 PyThreadState* __tstate = wxPyBeginAllowThreads();
31900 (arg1)->SetAutoLayout(arg2);
31901
31902 wxPyEndAllowThreads(__tstate);
31903 if (PyErr_Occurred()) SWIG_fail;
31904 }
31905 Py_INCREF(Py_None); resultobj = Py_None;
31906 return resultobj;
31907 fail:
31908 return NULL;
31909 }
31910
31911
31912 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31913 PyObject *resultobj;
31914 wxWindow *arg1 = (wxWindow *) 0 ;
31915 bool result;
31916 PyObject * obj0 = 0 ;
31917 char *kwnames[] = {
31918 (char *) "self", NULL
31919 };
31920
31921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31923 if (SWIG_arg_fail(1)) SWIG_fail;
31924 {
31925 PyThreadState* __tstate = wxPyBeginAllowThreads();
31926 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31927
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 {
31932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31933 }
31934 return resultobj;
31935 fail:
31936 return NULL;
31937 }
31938
31939
31940 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31941 PyObject *resultobj;
31942 wxWindow *arg1 = (wxWindow *) 0 ;
31943 bool result;
31944 PyObject * obj0 = 0 ;
31945 char *kwnames[] = {
31946 (char *) "self", NULL
31947 };
31948
31949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31951 if (SWIG_arg_fail(1)) SWIG_fail;
31952 {
31953 PyThreadState* __tstate = wxPyBeginAllowThreads();
31954 result = (bool)(arg1)->Layout();
31955
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 {
31960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31961 }
31962 return resultobj;
31963 fail:
31964 return NULL;
31965 }
31966
31967
31968 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31969 PyObject *resultobj;
31970 wxWindow *arg1 = (wxWindow *) 0 ;
31971 wxSizer *arg2 = (wxSizer *) 0 ;
31972 bool arg3 = (bool) true ;
31973 PyObject * obj0 = 0 ;
31974 PyObject * obj1 = 0 ;
31975 PyObject * obj2 = 0 ;
31976 char *kwnames[] = {
31977 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31978 };
31979
31980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31982 if (SWIG_arg_fail(1)) SWIG_fail;
31983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31984 if (SWIG_arg_fail(2)) SWIG_fail;
31985 if (obj2) {
31986 {
31987 arg3 = (bool)(SWIG_As_bool(obj2));
31988 if (SWIG_arg_fail(3)) SWIG_fail;
31989 }
31990 }
31991 {
31992 PyThreadState* __tstate = wxPyBeginAllowThreads();
31993 (arg1)->SetSizer(arg2,arg3);
31994
31995 wxPyEndAllowThreads(__tstate);
31996 if (PyErr_Occurred()) SWIG_fail;
31997 }
31998 Py_INCREF(Py_None); resultobj = Py_None;
31999 return resultobj;
32000 fail:
32001 return NULL;
32002 }
32003
32004
32005 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32006 PyObject *resultobj;
32007 wxWindow *arg1 = (wxWindow *) 0 ;
32008 wxSizer *arg2 = (wxSizer *) 0 ;
32009 bool arg3 = (bool) true ;
32010 PyObject * obj0 = 0 ;
32011 PyObject * obj1 = 0 ;
32012 PyObject * obj2 = 0 ;
32013 char *kwnames[] = {
32014 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32015 };
32016
32017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32019 if (SWIG_arg_fail(1)) SWIG_fail;
32020 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32021 if (SWIG_arg_fail(2)) SWIG_fail;
32022 if (obj2) {
32023 {
32024 arg3 = (bool)(SWIG_As_bool(obj2));
32025 if (SWIG_arg_fail(3)) SWIG_fail;
32026 }
32027 }
32028 {
32029 PyThreadState* __tstate = wxPyBeginAllowThreads();
32030 (arg1)->SetSizerAndFit(arg2,arg3);
32031
32032 wxPyEndAllowThreads(__tstate);
32033 if (PyErr_Occurred()) SWIG_fail;
32034 }
32035 Py_INCREF(Py_None); resultobj = Py_None;
32036 return resultobj;
32037 fail:
32038 return NULL;
32039 }
32040
32041
32042 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32043 PyObject *resultobj;
32044 wxWindow *arg1 = (wxWindow *) 0 ;
32045 wxSizer *result;
32046 PyObject * obj0 = 0 ;
32047 char *kwnames[] = {
32048 (char *) "self", NULL
32049 };
32050
32051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32053 if (SWIG_arg_fail(1)) SWIG_fail;
32054 {
32055 PyThreadState* __tstate = wxPyBeginAllowThreads();
32056 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32057
32058 wxPyEndAllowThreads(__tstate);
32059 if (PyErr_Occurred()) SWIG_fail;
32060 }
32061 {
32062 resultobj = wxPyMake_wxObject(result, 0);
32063 }
32064 return resultobj;
32065 fail:
32066 return NULL;
32067 }
32068
32069
32070 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32071 PyObject *resultobj;
32072 wxWindow *arg1 = (wxWindow *) 0 ;
32073 wxSizer *arg2 = (wxSizer *) 0 ;
32074 PyObject * obj0 = 0 ;
32075 PyObject * obj1 = 0 ;
32076 char *kwnames[] = {
32077 (char *) "self",(char *) "sizer", NULL
32078 };
32079
32080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32082 if (SWIG_arg_fail(1)) SWIG_fail;
32083 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32084 if (SWIG_arg_fail(2)) SWIG_fail;
32085 {
32086 PyThreadState* __tstate = wxPyBeginAllowThreads();
32087 (arg1)->SetContainingSizer(arg2);
32088
32089 wxPyEndAllowThreads(__tstate);
32090 if (PyErr_Occurred()) SWIG_fail;
32091 }
32092 Py_INCREF(Py_None); resultobj = Py_None;
32093 return resultobj;
32094 fail:
32095 return NULL;
32096 }
32097
32098
32099 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32100 PyObject *resultobj;
32101 wxWindow *arg1 = (wxWindow *) 0 ;
32102 wxSizer *result;
32103 PyObject * obj0 = 0 ;
32104 char *kwnames[] = {
32105 (char *) "self", NULL
32106 };
32107
32108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32110 if (SWIG_arg_fail(1)) SWIG_fail;
32111 {
32112 PyThreadState* __tstate = wxPyBeginAllowThreads();
32113 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32114
32115 wxPyEndAllowThreads(__tstate);
32116 if (PyErr_Occurred()) SWIG_fail;
32117 }
32118 {
32119 resultobj = wxPyMake_wxObject(result, 0);
32120 }
32121 return resultobj;
32122 fail:
32123 return NULL;
32124 }
32125
32126
32127 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32128 PyObject *resultobj;
32129 wxWindow *arg1 = (wxWindow *) 0 ;
32130 PyObject * obj0 = 0 ;
32131 char *kwnames[] = {
32132 (char *) "self", NULL
32133 };
32134
32135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32137 if (SWIG_arg_fail(1)) SWIG_fail;
32138 {
32139 PyThreadState* __tstate = wxPyBeginAllowThreads();
32140 (arg1)->InheritAttributes();
32141
32142 wxPyEndAllowThreads(__tstate);
32143 if (PyErr_Occurred()) SWIG_fail;
32144 }
32145 Py_INCREF(Py_None); resultobj = Py_None;
32146 return resultobj;
32147 fail:
32148 return NULL;
32149 }
32150
32151
32152 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32153 PyObject *resultobj;
32154 wxWindow *arg1 = (wxWindow *) 0 ;
32155 bool result;
32156 PyObject * obj0 = 0 ;
32157 char *kwnames[] = {
32158 (char *) "self", NULL
32159 };
32160
32161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32163 if (SWIG_arg_fail(1)) SWIG_fail;
32164 {
32165 PyThreadState* __tstate = wxPyBeginAllowThreads();
32166 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32167
32168 wxPyEndAllowThreads(__tstate);
32169 if (PyErr_Occurred()) SWIG_fail;
32170 }
32171 {
32172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32173 }
32174 return resultobj;
32175 fail:
32176 return NULL;
32177 }
32178
32179
32180 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32181 PyObject *obj;
32182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32183 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32184 Py_INCREF(obj);
32185 return Py_BuildValue((char *)"");
32186 }
32187 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32188 PyObject *resultobj;
32189 long arg1 ;
32190 wxWindow *arg2 = (wxWindow *) NULL ;
32191 wxWindow *result;
32192 PyObject * obj0 = 0 ;
32193 PyObject * obj1 = 0 ;
32194 char *kwnames[] = {
32195 (char *) "id",(char *) "parent", NULL
32196 };
32197
32198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32199 {
32200 arg1 = (long)(SWIG_As_long(obj0));
32201 if (SWIG_arg_fail(1)) SWIG_fail;
32202 }
32203 if (obj1) {
32204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32205 if (SWIG_arg_fail(2)) SWIG_fail;
32206 }
32207 {
32208 if (!wxPyCheckForApp()) SWIG_fail;
32209 PyThreadState* __tstate = wxPyBeginAllowThreads();
32210 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32211
32212 wxPyEndAllowThreads(__tstate);
32213 if (PyErr_Occurred()) SWIG_fail;
32214 }
32215 {
32216 resultobj = wxPyMake_wxObject(result, 0);
32217 }
32218 return resultobj;
32219 fail:
32220 return NULL;
32221 }
32222
32223
32224 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32225 PyObject *resultobj;
32226 wxString *arg1 = 0 ;
32227 wxWindow *arg2 = (wxWindow *) NULL ;
32228 wxWindow *result;
32229 bool temp1 = false ;
32230 PyObject * obj0 = 0 ;
32231 PyObject * obj1 = 0 ;
32232 char *kwnames[] = {
32233 (char *) "name",(char *) "parent", NULL
32234 };
32235
32236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32237 {
32238 arg1 = wxString_in_helper(obj0);
32239 if (arg1 == NULL) SWIG_fail;
32240 temp1 = true;
32241 }
32242 if (obj1) {
32243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32244 if (SWIG_arg_fail(2)) SWIG_fail;
32245 }
32246 {
32247 if (!wxPyCheckForApp()) SWIG_fail;
32248 PyThreadState* __tstate = wxPyBeginAllowThreads();
32249 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32250
32251 wxPyEndAllowThreads(__tstate);
32252 if (PyErr_Occurred()) SWIG_fail;
32253 }
32254 {
32255 resultobj = wxPyMake_wxObject(result, 0);
32256 }
32257 {
32258 if (temp1)
32259 delete arg1;
32260 }
32261 return resultobj;
32262 fail:
32263 {
32264 if (temp1)
32265 delete arg1;
32266 }
32267 return NULL;
32268 }
32269
32270
32271 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32272 PyObject *resultobj;
32273 wxString *arg1 = 0 ;
32274 wxWindow *arg2 = (wxWindow *) NULL ;
32275 wxWindow *result;
32276 bool temp1 = false ;
32277 PyObject * obj0 = 0 ;
32278 PyObject * obj1 = 0 ;
32279 char *kwnames[] = {
32280 (char *) "label",(char *) "parent", NULL
32281 };
32282
32283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32284 {
32285 arg1 = wxString_in_helper(obj0);
32286 if (arg1 == NULL) SWIG_fail;
32287 temp1 = true;
32288 }
32289 if (obj1) {
32290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32291 if (SWIG_arg_fail(2)) SWIG_fail;
32292 }
32293 {
32294 if (!wxPyCheckForApp()) SWIG_fail;
32295 PyThreadState* __tstate = wxPyBeginAllowThreads();
32296 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32297
32298 wxPyEndAllowThreads(__tstate);
32299 if (PyErr_Occurred()) SWIG_fail;
32300 }
32301 {
32302 resultobj = wxPyMake_wxObject(result, 0);
32303 }
32304 {
32305 if (temp1)
32306 delete arg1;
32307 }
32308 return resultobj;
32309 fail:
32310 {
32311 if (temp1)
32312 delete arg1;
32313 }
32314 return NULL;
32315 }
32316
32317
32318 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32319 PyObject *resultobj;
32320 wxWindow *arg1 = (wxWindow *) 0 ;
32321 unsigned long arg2 ;
32322 wxWindow *result;
32323 PyObject * obj0 = 0 ;
32324 PyObject * obj1 = 0 ;
32325 char *kwnames[] = {
32326 (char *) "parent",(char *) "_hWnd", NULL
32327 };
32328
32329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32331 if (SWIG_arg_fail(1)) SWIG_fail;
32332 {
32333 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32334 if (SWIG_arg_fail(2)) SWIG_fail;
32335 }
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32339
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 {
32344 resultobj = wxPyMake_wxObject(result, 0);
32345 }
32346 return resultobj;
32347 fail:
32348 return NULL;
32349 }
32350
32351
32352 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32353 PyObject *resultobj;
32354 PyObject *result;
32355 char *kwnames[] = {
32356 NULL
32357 };
32358
32359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32360 {
32361 PyThreadState* __tstate = wxPyBeginAllowThreads();
32362 result = (PyObject *)GetTopLevelWindows();
32363
32364 wxPyEndAllowThreads(__tstate);
32365 if (PyErr_Occurred()) SWIG_fail;
32366 }
32367 resultobj = result;
32368 return resultobj;
32369 fail:
32370 return NULL;
32371 }
32372
32373
32374 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32375 PyObject *resultobj;
32376 wxValidator *result;
32377 char *kwnames[] = {
32378 NULL
32379 };
32380
32381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32382 {
32383 PyThreadState* __tstate = wxPyBeginAllowThreads();
32384 result = (wxValidator *)new wxValidator();
32385
32386 wxPyEndAllowThreads(__tstate);
32387 if (PyErr_Occurred()) SWIG_fail;
32388 }
32389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32390 return resultobj;
32391 fail:
32392 return NULL;
32393 }
32394
32395
32396 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32397 PyObject *resultobj;
32398 wxValidator *arg1 = (wxValidator *) 0 ;
32399 wxValidator *result;
32400 PyObject * obj0 = 0 ;
32401 char *kwnames[] = {
32402 (char *) "self", NULL
32403 };
32404
32405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32407 if (SWIG_arg_fail(1)) SWIG_fail;
32408 {
32409 PyThreadState* __tstate = wxPyBeginAllowThreads();
32410 result = (wxValidator *)(arg1)->Clone();
32411
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 {
32416 resultobj = wxPyMake_wxObject(result, 0);
32417 }
32418 return resultobj;
32419 fail:
32420 return NULL;
32421 }
32422
32423
32424 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32425 PyObject *resultobj;
32426 wxValidator *arg1 = (wxValidator *) 0 ;
32427 wxWindow *arg2 = (wxWindow *) 0 ;
32428 bool result;
32429 PyObject * obj0 = 0 ;
32430 PyObject * obj1 = 0 ;
32431 char *kwnames[] = {
32432 (char *) "self",(char *) "parent", NULL
32433 };
32434
32435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32437 if (SWIG_arg_fail(1)) SWIG_fail;
32438 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32439 if (SWIG_arg_fail(2)) SWIG_fail;
32440 {
32441 PyThreadState* __tstate = wxPyBeginAllowThreads();
32442 result = (bool)(arg1)->Validate(arg2);
32443
32444 wxPyEndAllowThreads(__tstate);
32445 if (PyErr_Occurred()) SWIG_fail;
32446 }
32447 {
32448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32449 }
32450 return resultobj;
32451 fail:
32452 return NULL;
32453 }
32454
32455
32456 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32457 PyObject *resultobj;
32458 wxValidator *arg1 = (wxValidator *) 0 ;
32459 bool result;
32460 PyObject * obj0 = 0 ;
32461 char *kwnames[] = {
32462 (char *) "self", NULL
32463 };
32464
32465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32467 if (SWIG_arg_fail(1)) SWIG_fail;
32468 {
32469 PyThreadState* __tstate = wxPyBeginAllowThreads();
32470 result = (bool)(arg1)->TransferToWindow();
32471
32472 wxPyEndAllowThreads(__tstate);
32473 if (PyErr_Occurred()) SWIG_fail;
32474 }
32475 {
32476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32477 }
32478 return resultobj;
32479 fail:
32480 return NULL;
32481 }
32482
32483
32484 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32485 PyObject *resultobj;
32486 wxValidator *arg1 = (wxValidator *) 0 ;
32487 bool result;
32488 PyObject * obj0 = 0 ;
32489 char *kwnames[] = {
32490 (char *) "self", NULL
32491 };
32492
32493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32495 if (SWIG_arg_fail(1)) SWIG_fail;
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 result = (bool)(arg1)->TransferFromWindow();
32499
32500 wxPyEndAllowThreads(__tstate);
32501 if (PyErr_Occurred()) SWIG_fail;
32502 }
32503 {
32504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32505 }
32506 return resultobj;
32507 fail:
32508 return NULL;
32509 }
32510
32511
32512 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32513 PyObject *resultobj;
32514 wxValidator *arg1 = (wxValidator *) 0 ;
32515 wxWindow *result;
32516 PyObject * obj0 = 0 ;
32517 char *kwnames[] = {
32518 (char *) "self", NULL
32519 };
32520
32521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32523 if (SWIG_arg_fail(1)) SWIG_fail;
32524 {
32525 PyThreadState* __tstate = wxPyBeginAllowThreads();
32526 result = (wxWindow *)(arg1)->GetWindow();
32527
32528 wxPyEndAllowThreads(__tstate);
32529 if (PyErr_Occurred()) SWIG_fail;
32530 }
32531 {
32532 resultobj = wxPyMake_wxObject(result, 0);
32533 }
32534 return resultobj;
32535 fail:
32536 return NULL;
32537 }
32538
32539
32540 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32541 PyObject *resultobj;
32542 wxValidator *arg1 = (wxValidator *) 0 ;
32543 wxWindow *arg2 = (wxWindow *) 0 ;
32544 PyObject * obj0 = 0 ;
32545 PyObject * obj1 = 0 ;
32546 char *kwnames[] = {
32547 (char *) "self",(char *) "window", NULL
32548 };
32549
32550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32552 if (SWIG_arg_fail(1)) SWIG_fail;
32553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32554 if (SWIG_arg_fail(2)) SWIG_fail;
32555 {
32556 PyThreadState* __tstate = wxPyBeginAllowThreads();
32557 (arg1)->SetWindow(arg2);
32558
32559 wxPyEndAllowThreads(__tstate);
32560 if (PyErr_Occurred()) SWIG_fail;
32561 }
32562 Py_INCREF(Py_None); resultobj = Py_None;
32563 return resultobj;
32564 fail:
32565 return NULL;
32566 }
32567
32568
32569 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32570 PyObject *resultobj;
32571 bool result;
32572 char *kwnames[] = {
32573 NULL
32574 };
32575
32576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32577 {
32578 PyThreadState* __tstate = wxPyBeginAllowThreads();
32579 result = (bool)wxValidator::IsSilent();
32580
32581 wxPyEndAllowThreads(__tstate);
32582 if (PyErr_Occurred()) SWIG_fail;
32583 }
32584 {
32585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32586 }
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32594 PyObject *resultobj;
32595 int arg1 = (int) true ;
32596 PyObject * obj0 = 0 ;
32597 char *kwnames[] = {
32598 (char *) "doIt", NULL
32599 };
32600
32601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32602 if (obj0) {
32603 {
32604 arg1 = (int)(SWIG_As_int(obj0));
32605 if (SWIG_arg_fail(1)) SWIG_fail;
32606 }
32607 }
32608 {
32609 PyThreadState* __tstate = wxPyBeginAllowThreads();
32610 wxValidator::SetBellOnError(arg1);
32611
32612 wxPyEndAllowThreads(__tstate);
32613 if (PyErr_Occurred()) SWIG_fail;
32614 }
32615 Py_INCREF(Py_None); resultobj = Py_None;
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32623 PyObject *obj;
32624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32625 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32626 Py_INCREF(obj);
32627 return Py_BuildValue((char *)"");
32628 }
32629 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32630 PyObject *resultobj;
32631 wxPyValidator *result;
32632 char *kwnames[] = {
32633 NULL
32634 };
32635
32636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32637 {
32638 PyThreadState* __tstate = wxPyBeginAllowThreads();
32639 result = (wxPyValidator *)new wxPyValidator();
32640
32641 wxPyEndAllowThreads(__tstate);
32642 if (PyErr_Occurred()) SWIG_fail;
32643 }
32644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32645 return resultobj;
32646 fail:
32647 return NULL;
32648 }
32649
32650
32651 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32652 PyObject *resultobj;
32653 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32654 PyObject *arg2 = (PyObject *) 0 ;
32655 PyObject *arg3 = (PyObject *) 0 ;
32656 int arg4 = (int) true ;
32657 PyObject * obj0 = 0 ;
32658 PyObject * obj1 = 0 ;
32659 PyObject * obj2 = 0 ;
32660 PyObject * obj3 = 0 ;
32661 char *kwnames[] = {
32662 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32663 };
32664
32665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32667 if (SWIG_arg_fail(1)) SWIG_fail;
32668 arg2 = obj1;
32669 arg3 = obj2;
32670 if (obj3) {
32671 {
32672 arg4 = (int)(SWIG_As_int(obj3));
32673 if (SWIG_arg_fail(4)) SWIG_fail;
32674 }
32675 }
32676 {
32677 PyThreadState* __tstate = wxPyBeginAllowThreads();
32678 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32679
32680 wxPyEndAllowThreads(__tstate);
32681 if (PyErr_Occurred()) SWIG_fail;
32682 }
32683 Py_INCREF(Py_None); resultobj = Py_None;
32684 return resultobj;
32685 fail:
32686 return NULL;
32687 }
32688
32689
32690 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32691 PyObject *obj;
32692 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32693 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32694 Py_INCREF(obj);
32695 return Py_BuildValue((char *)"");
32696 }
32697 static int _wrap_DefaultValidator_set(PyObject *) {
32698 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32699 return 1;
32700 }
32701
32702
32703 static PyObject *_wrap_DefaultValidator_get(void) {
32704 PyObject *pyobj;
32705
32706 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32707 return pyobj;
32708 }
32709
32710
32711 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32712 PyObject *resultobj;
32713 wxString const &arg1_defvalue = wxPyEmptyString ;
32714 wxString *arg1 = (wxString *) &arg1_defvalue ;
32715 long arg2 = (long) 0 ;
32716 wxMenu *result;
32717 bool temp1 = false ;
32718 PyObject * obj0 = 0 ;
32719 PyObject * obj1 = 0 ;
32720 char *kwnames[] = {
32721 (char *) "title",(char *) "style", NULL
32722 };
32723
32724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32725 if (obj0) {
32726 {
32727 arg1 = wxString_in_helper(obj0);
32728 if (arg1 == NULL) SWIG_fail;
32729 temp1 = true;
32730 }
32731 }
32732 if (obj1) {
32733 {
32734 arg2 = (long)(SWIG_As_long(obj1));
32735 if (SWIG_arg_fail(2)) SWIG_fail;
32736 }
32737 }
32738 {
32739 if (!wxPyCheckForApp()) SWIG_fail;
32740 PyThreadState* __tstate = wxPyBeginAllowThreads();
32741 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32742
32743 wxPyEndAllowThreads(__tstate);
32744 if (PyErr_Occurred()) SWIG_fail;
32745 }
32746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32747 {
32748 if (temp1)
32749 delete arg1;
32750 }
32751 return resultobj;
32752 fail:
32753 {
32754 if (temp1)
32755 delete arg1;
32756 }
32757 return NULL;
32758 }
32759
32760
32761 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32762 PyObject *resultobj;
32763 wxMenu *arg1 = (wxMenu *) 0 ;
32764 int arg2 ;
32765 wxString *arg3 = 0 ;
32766 wxString const &arg4_defvalue = wxPyEmptyString ;
32767 wxString *arg4 = (wxString *) &arg4_defvalue ;
32768 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32769 wxMenuItem *result;
32770 bool temp3 = false ;
32771 bool temp4 = false ;
32772 PyObject * obj0 = 0 ;
32773 PyObject * obj1 = 0 ;
32774 PyObject * obj2 = 0 ;
32775 PyObject * obj3 = 0 ;
32776 PyObject * obj4 = 0 ;
32777 char *kwnames[] = {
32778 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32779 };
32780
32781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32783 if (SWIG_arg_fail(1)) SWIG_fail;
32784 {
32785 arg2 = (int)(SWIG_As_int(obj1));
32786 if (SWIG_arg_fail(2)) SWIG_fail;
32787 }
32788 {
32789 arg3 = wxString_in_helper(obj2);
32790 if (arg3 == NULL) SWIG_fail;
32791 temp3 = true;
32792 }
32793 if (obj3) {
32794 {
32795 arg4 = wxString_in_helper(obj3);
32796 if (arg4 == NULL) SWIG_fail;
32797 temp4 = true;
32798 }
32799 }
32800 if (obj4) {
32801 {
32802 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32803 if (SWIG_arg_fail(5)) SWIG_fail;
32804 }
32805 }
32806 {
32807 PyThreadState* __tstate = wxPyBeginAllowThreads();
32808 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32809
32810 wxPyEndAllowThreads(__tstate);
32811 if (PyErr_Occurred()) SWIG_fail;
32812 }
32813 {
32814 resultobj = wxPyMake_wxObject(result, 0);
32815 }
32816 {
32817 if (temp3)
32818 delete arg3;
32819 }
32820 {
32821 if (temp4)
32822 delete arg4;
32823 }
32824 return resultobj;
32825 fail:
32826 {
32827 if (temp3)
32828 delete arg3;
32829 }
32830 {
32831 if (temp4)
32832 delete arg4;
32833 }
32834 return NULL;
32835 }
32836
32837
32838 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32839 PyObject *resultobj;
32840 wxMenu *arg1 = (wxMenu *) 0 ;
32841 wxMenuItem *result;
32842 PyObject * obj0 = 0 ;
32843 char *kwnames[] = {
32844 (char *) "self", NULL
32845 };
32846
32847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32849 if (SWIG_arg_fail(1)) SWIG_fail;
32850 {
32851 PyThreadState* __tstate = wxPyBeginAllowThreads();
32852 result = (wxMenuItem *)(arg1)->AppendSeparator();
32853
32854 wxPyEndAllowThreads(__tstate);
32855 if (PyErr_Occurred()) SWIG_fail;
32856 }
32857 {
32858 resultobj = wxPyMake_wxObject(result, 0);
32859 }
32860 return resultobj;
32861 fail:
32862 return NULL;
32863 }
32864
32865
32866 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32867 PyObject *resultobj;
32868 wxMenu *arg1 = (wxMenu *) 0 ;
32869 int arg2 ;
32870 wxString *arg3 = 0 ;
32871 wxString const &arg4_defvalue = wxPyEmptyString ;
32872 wxString *arg4 = (wxString *) &arg4_defvalue ;
32873 wxMenuItem *result;
32874 bool temp3 = false ;
32875 bool temp4 = false ;
32876 PyObject * obj0 = 0 ;
32877 PyObject * obj1 = 0 ;
32878 PyObject * obj2 = 0 ;
32879 PyObject * obj3 = 0 ;
32880 char *kwnames[] = {
32881 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32882 };
32883
32884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32886 if (SWIG_arg_fail(1)) SWIG_fail;
32887 {
32888 arg2 = (int)(SWIG_As_int(obj1));
32889 if (SWIG_arg_fail(2)) SWIG_fail;
32890 }
32891 {
32892 arg3 = wxString_in_helper(obj2);
32893 if (arg3 == NULL) SWIG_fail;
32894 temp3 = true;
32895 }
32896 if (obj3) {
32897 {
32898 arg4 = wxString_in_helper(obj3);
32899 if (arg4 == NULL) SWIG_fail;
32900 temp4 = true;
32901 }
32902 }
32903 {
32904 PyThreadState* __tstate = wxPyBeginAllowThreads();
32905 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32906
32907 wxPyEndAllowThreads(__tstate);
32908 if (PyErr_Occurred()) SWIG_fail;
32909 }
32910 {
32911 resultobj = wxPyMake_wxObject(result, 0);
32912 }
32913 {
32914 if (temp3)
32915 delete arg3;
32916 }
32917 {
32918 if (temp4)
32919 delete arg4;
32920 }
32921 return resultobj;
32922 fail:
32923 {
32924 if (temp3)
32925 delete arg3;
32926 }
32927 {
32928 if (temp4)
32929 delete arg4;
32930 }
32931 return NULL;
32932 }
32933
32934
32935 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32936 PyObject *resultobj;
32937 wxMenu *arg1 = (wxMenu *) 0 ;
32938 int arg2 ;
32939 wxString *arg3 = 0 ;
32940 wxString const &arg4_defvalue = wxPyEmptyString ;
32941 wxString *arg4 = (wxString *) &arg4_defvalue ;
32942 wxMenuItem *result;
32943 bool temp3 = false ;
32944 bool temp4 = false ;
32945 PyObject * obj0 = 0 ;
32946 PyObject * obj1 = 0 ;
32947 PyObject * obj2 = 0 ;
32948 PyObject * obj3 = 0 ;
32949 char *kwnames[] = {
32950 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32951 };
32952
32953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32955 if (SWIG_arg_fail(1)) SWIG_fail;
32956 {
32957 arg2 = (int)(SWIG_As_int(obj1));
32958 if (SWIG_arg_fail(2)) SWIG_fail;
32959 }
32960 {
32961 arg3 = wxString_in_helper(obj2);
32962 if (arg3 == NULL) SWIG_fail;
32963 temp3 = true;
32964 }
32965 if (obj3) {
32966 {
32967 arg4 = wxString_in_helper(obj3);
32968 if (arg4 == NULL) SWIG_fail;
32969 temp4 = true;
32970 }
32971 }
32972 {
32973 PyThreadState* __tstate = wxPyBeginAllowThreads();
32974 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32975
32976 wxPyEndAllowThreads(__tstate);
32977 if (PyErr_Occurred()) SWIG_fail;
32978 }
32979 {
32980 resultobj = wxPyMake_wxObject(result, 0);
32981 }
32982 {
32983 if (temp3)
32984 delete arg3;
32985 }
32986 {
32987 if (temp4)
32988 delete arg4;
32989 }
32990 return resultobj;
32991 fail:
32992 {
32993 if (temp3)
32994 delete arg3;
32995 }
32996 {
32997 if (temp4)
32998 delete arg4;
32999 }
33000 return NULL;
33001 }
33002
33003
33004 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33005 PyObject *resultobj;
33006 wxMenu *arg1 = (wxMenu *) 0 ;
33007 int arg2 ;
33008 wxString *arg3 = 0 ;
33009 wxMenu *arg4 = (wxMenu *) 0 ;
33010 wxString const &arg5_defvalue = wxPyEmptyString ;
33011 wxString *arg5 = (wxString *) &arg5_defvalue ;
33012 wxMenuItem *result;
33013 bool temp3 = false ;
33014 bool temp5 = false ;
33015 PyObject * obj0 = 0 ;
33016 PyObject * obj1 = 0 ;
33017 PyObject * obj2 = 0 ;
33018 PyObject * obj3 = 0 ;
33019 PyObject * obj4 = 0 ;
33020 char *kwnames[] = {
33021 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33022 };
33023
33024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33026 if (SWIG_arg_fail(1)) SWIG_fail;
33027 {
33028 arg2 = (int)(SWIG_As_int(obj1));
33029 if (SWIG_arg_fail(2)) SWIG_fail;
33030 }
33031 {
33032 arg3 = wxString_in_helper(obj2);
33033 if (arg3 == NULL) SWIG_fail;
33034 temp3 = true;
33035 }
33036 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33037 if (SWIG_arg_fail(4)) SWIG_fail;
33038 if (obj4) {
33039 {
33040 arg5 = wxString_in_helper(obj4);
33041 if (arg5 == NULL) SWIG_fail;
33042 temp5 = true;
33043 }
33044 }
33045 {
33046 PyThreadState* __tstate = wxPyBeginAllowThreads();
33047 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33048
33049 wxPyEndAllowThreads(__tstate);
33050 if (PyErr_Occurred()) SWIG_fail;
33051 }
33052 {
33053 resultobj = wxPyMake_wxObject(result, 0);
33054 }
33055 {
33056 if (temp3)
33057 delete arg3;
33058 }
33059 {
33060 if (temp5)
33061 delete arg5;
33062 }
33063 return resultobj;
33064 fail:
33065 {
33066 if (temp3)
33067 delete arg3;
33068 }
33069 {
33070 if (temp5)
33071 delete arg5;
33072 }
33073 return NULL;
33074 }
33075
33076
33077 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33078 PyObject *resultobj;
33079 wxMenu *arg1 = (wxMenu *) 0 ;
33080 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33081 wxMenuItem *result;
33082 PyObject * obj0 = 0 ;
33083 PyObject * obj1 = 0 ;
33084 char *kwnames[] = {
33085 (char *) "self",(char *) "item", NULL
33086 };
33087
33088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33090 if (SWIG_arg_fail(1)) SWIG_fail;
33091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33092 if (SWIG_arg_fail(2)) SWIG_fail;
33093 {
33094 PyThreadState* __tstate = wxPyBeginAllowThreads();
33095 result = (wxMenuItem *)(arg1)->Append(arg2);
33096
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 {
33101 resultobj = wxPyMake_wxObject(result, 0);
33102 }
33103 return resultobj;
33104 fail:
33105 return NULL;
33106 }
33107
33108
33109 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33110 PyObject *resultobj;
33111 wxMenu *arg1 = (wxMenu *) 0 ;
33112 PyObject * obj0 = 0 ;
33113 char *kwnames[] = {
33114 (char *) "self", NULL
33115 };
33116
33117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33119 if (SWIG_arg_fail(1)) SWIG_fail;
33120 {
33121 PyThreadState* __tstate = wxPyBeginAllowThreads();
33122 (arg1)->Break();
33123
33124 wxPyEndAllowThreads(__tstate);
33125 if (PyErr_Occurred()) SWIG_fail;
33126 }
33127 Py_INCREF(Py_None); resultobj = Py_None;
33128 return resultobj;
33129 fail:
33130 return NULL;
33131 }
33132
33133
33134 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33135 PyObject *resultobj;
33136 wxMenu *arg1 = (wxMenu *) 0 ;
33137 size_t arg2 ;
33138 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33139 wxMenuItem *result;
33140 PyObject * obj0 = 0 ;
33141 PyObject * obj1 = 0 ;
33142 PyObject * obj2 = 0 ;
33143 char *kwnames[] = {
33144 (char *) "self",(char *) "pos",(char *) "item", NULL
33145 };
33146
33147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33149 if (SWIG_arg_fail(1)) SWIG_fail;
33150 {
33151 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33152 if (SWIG_arg_fail(2)) SWIG_fail;
33153 }
33154 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33155 if (SWIG_arg_fail(3)) SWIG_fail;
33156 {
33157 PyThreadState* __tstate = wxPyBeginAllowThreads();
33158 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33159
33160 wxPyEndAllowThreads(__tstate);
33161 if (PyErr_Occurred()) SWIG_fail;
33162 }
33163 {
33164 resultobj = wxPyMake_wxObject(result, 0);
33165 }
33166 return resultobj;
33167 fail:
33168 return NULL;
33169 }
33170
33171
33172 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33173 PyObject *resultobj;
33174 wxMenu *arg1 = (wxMenu *) 0 ;
33175 size_t arg2 ;
33176 int arg3 ;
33177 wxString *arg4 = 0 ;
33178 wxString const &arg5_defvalue = wxPyEmptyString ;
33179 wxString *arg5 = (wxString *) &arg5_defvalue ;
33180 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33181 wxMenuItem *result;
33182 bool temp4 = false ;
33183 bool temp5 = false ;
33184 PyObject * obj0 = 0 ;
33185 PyObject * obj1 = 0 ;
33186 PyObject * obj2 = 0 ;
33187 PyObject * obj3 = 0 ;
33188 PyObject * obj4 = 0 ;
33189 PyObject * obj5 = 0 ;
33190 char *kwnames[] = {
33191 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33192 };
33193
33194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33196 if (SWIG_arg_fail(1)) SWIG_fail;
33197 {
33198 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33199 if (SWIG_arg_fail(2)) SWIG_fail;
33200 }
33201 {
33202 arg3 = (int)(SWIG_As_int(obj2));
33203 if (SWIG_arg_fail(3)) SWIG_fail;
33204 }
33205 {
33206 arg4 = wxString_in_helper(obj3);
33207 if (arg4 == NULL) SWIG_fail;
33208 temp4 = true;
33209 }
33210 if (obj4) {
33211 {
33212 arg5 = wxString_in_helper(obj4);
33213 if (arg5 == NULL) SWIG_fail;
33214 temp5 = true;
33215 }
33216 }
33217 if (obj5) {
33218 {
33219 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33220 if (SWIG_arg_fail(6)) SWIG_fail;
33221 }
33222 }
33223 {
33224 PyThreadState* __tstate = wxPyBeginAllowThreads();
33225 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33226
33227 wxPyEndAllowThreads(__tstate);
33228 if (PyErr_Occurred()) SWIG_fail;
33229 }
33230 {
33231 resultobj = wxPyMake_wxObject(result, 0);
33232 }
33233 {
33234 if (temp4)
33235 delete arg4;
33236 }
33237 {
33238 if (temp5)
33239 delete arg5;
33240 }
33241 return resultobj;
33242 fail:
33243 {
33244 if (temp4)
33245 delete arg4;
33246 }
33247 {
33248 if (temp5)
33249 delete arg5;
33250 }
33251 return NULL;
33252 }
33253
33254
33255 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33256 PyObject *resultobj;
33257 wxMenu *arg1 = (wxMenu *) 0 ;
33258 size_t arg2 ;
33259 wxMenuItem *result;
33260 PyObject * obj0 = 0 ;
33261 PyObject * obj1 = 0 ;
33262 char *kwnames[] = {
33263 (char *) "self",(char *) "pos", NULL
33264 };
33265
33266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33268 if (SWIG_arg_fail(1)) SWIG_fail;
33269 {
33270 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33271 if (SWIG_arg_fail(2)) SWIG_fail;
33272 }
33273 {
33274 PyThreadState* __tstate = wxPyBeginAllowThreads();
33275 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33276
33277 wxPyEndAllowThreads(__tstate);
33278 if (PyErr_Occurred()) SWIG_fail;
33279 }
33280 {
33281 resultobj = wxPyMake_wxObject(result, 0);
33282 }
33283 return resultobj;
33284 fail:
33285 return NULL;
33286 }
33287
33288
33289 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33290 PyObject *resultobj;
33291 wxMenu *arg1 = (wxMenu *) 0 ;
33292 size_t arg2 ;
33293 int arg3 ;
33294 wxString *arg4 = 0 ;
33295 wxString const &arg5_defvalue = wxPyEmptyString ;
33296 wxString *arg5 = (wxString *) &arg5_defvalue ;
33297 wxMenuItem *result;
33298 bool temp4 = false ;
33299 bool temp5 = false ;
33300 PyObject * obj0 = 0 ;
33301 PyObject * obj1 = 0 ;
33302 PyObject * obj2 = 0 ;
33303 PyObject * obj3 = 0 ;
33304 PyObject * obj4 = 0 ;
33305 char *kwnames[] = {
33306 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33307 };
33308
33309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33311 if (SWIG_arg_fail(1)) SWIG_fail;
33312 {
33313 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33314 if (SWIG_arg_fail(2)) SWIG_fail;
33315 }
33316 {
33317 arg3 = (int)(SWIG_As_int(obj2));
33318 if (SWIG_arg_fail(3)) SWIG_fail;
33319 }
33320 {
33321 arg4 = wxString_in_helper(obj3);
33322 if (arg4 == NULL) SWIG_fail;
33323 temp4 = true;
33324 }
33325 if (obj4) {
33326 {
33327 arg5 = wxString_in_helper(obj4);
33328 if (arg5 == NULL) SWIG_fail;
33329 temp5 = true;
33330 }
33331 }
33332 {
33333 PyThreadState* __tstate = wxPyBeginAllowThreads();
33334 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33335
33336 wxPyEndAllowThreads(__tstate);
33337 if (PyErr_Occurred()) SWIG_fail;
33338 }
33339 {
33340 resultobj = wxPyMake_wxObject(result, 0);
33341 }
33342 {
33343 if (temp4)
33344 delete arg4;
33345 }
33346 {
33347 if (temp5)
33348 delete arg5;
33349 }
33350 return resultobj;
33351 fail:
33352 {
33353 if (temp4)
33354 delete arg4;
33355 }
33356 {
33357 if (temp5)
33358 delete arg5;
33359 }
33360 return NULL;
33361 }
33362
33363
33364 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33365 PyObject *resultobj;
33366 wxMenu *arg1 = (wxMenu *) 0 ;
33367 size_t arg2 ;
33368 int arg3 ;
33369 wxString *arg4 = 0 ;
33370 wxString const &arg5_defvalue = wxPyEmptyString ;
33371 wxString *arg5 = (wxString *) &arg5_defvalue ;
33372 wxMenuItem *result;
33373 bool temp4 = false ;
33374 bool temp5 = false ;
33375 PyObject * obj0 = 0 ;
33376 PyObject * obj1 = 0 ;
33377 PyObject * obj2 = 0 ;
33378 PyObject * obj3 = 0 ;
33379 PyObject * obj4 = 0 ;
33380 char *kwnames[] = {
33381 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33382 };
33383
33384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33386 if (SWIG_arg_fail(1)) SWIG_fail;
33387 {
33388 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33389 if (SWIG_arg_fail(2)) SWIG_fail;
33390 }
33391 {
33392 arg3 = (int)(SWIG_As_int(obj2));
33393 if (SWIG_arg_fail(3)) SWIG_fail;
33394 }
33395 {
33396 arg4 = wxString_in_helper(obj3);
33397 if (arg4 == NULL) SWIG_fail;
33398 temp4 = true;
33399 }
33400 if (obj4) {
33401 {
33402 arg5 = wxString_in_helper(obj4);
33403 if (arg5 == NULL) SWIG_fail;
33404 temp5 = true;
33405 }
33406 }
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33410
33411 wxPyEndAllowThreads(__tstate);
33412 if (PyErr_Occurred()) SWIG_fail;
33413 }
33414 {
33415 resultobj = wxPyMake_wxObject(result, 0);
33416 }
33417 {
33418 if (temp4)
33419 delete arg4;
33420 }
33421 {
33422 if (temp5)
33423 delete arg5;
33424 }
33425 return resultobj;
33426 fail:
33427 {
33428 if (temp4)
33429 delete arg4;
33430 }
33431 {
33432 if (temp5)
33433 delete arg5;
33434 }
33435 return NULL;
33436 }
33437
33438
33439 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33440 PyObject *resultobj;
33441 wxMenu *arg1 = (wxMenu *) 0 ;
33442 size_t arg2 ;
33443 int arg3 ;
33444 wxString *arg4 = 0 ;
33445 wxMenu *arg5 = (wxMenu *) 0 ;
33446 wxString const &arg6_defvalue = wxPyEmptyString ;
33447 wxString *arg6 = (wxString *) &arg6_defvalue ;
33448 wxMenuItem *result;
33449 bool temp4 = false ;
33450 bool temp6 = false ;
33451 PyObject * obj0 = 0 ;
33452 PyObject * obj1 = 0 ;
33453 PyObject * obj2 = 0 ;
33454 PyObject * obj3 = 0 ;
33455 PyObject * obj4 = 0 ;
33456 PyObject * obj5 = 0 ;
33457 char *kwnames[] = {
33458 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33459 };
33460
33461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33463 if (SWIG_arg_fail(1)) SWIG_fail;
33464 {
33465 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33466 if (SWIG_arg_fail(2)) SWIG_fail;
33467 }
33468 {
33469 arg3 = (int)(SWIG_As_int(obj2));
33470 if (SWIG_arg_fail(3)) SWIG_fail;
33471 }
33472 {
33473 arg4 = wxString_in_helper(obj3);
33474 if (arg4 == NULL) SWIG_fail;
33475 temp4 = true;
33476 }
33477 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33478 if (SWIG_arg_fail(5)) SWIG_fail;
33479 if (obj5) {
33480 {
33481 arg6 = wxString_in_helper(obj5);
33482 if (arg6 == NULL) SWIG_fail;
33483 temp6 = true;
33484 }
33485 }
33486 {
33487 PyThreadState* __tstate = wxPyBeginAllowThreads();
33488 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33489
33490 wxPyEndAllowThreads(__tstate);
33491 if (PyErr_Occurred()) SWIG_fail;
33492 }
33493 {
33494 resultobj = wxPyMake_wxObject(result, 0);
33495 }
33496 {
33497 if (temp4)
33498 delete arg4;
33499 }
33500 {
33501 if (temp6)
33502 delete arg6;
33503 }
33504 return resultobj;
33505 fail:
33506 {
33507 if (temp4)
33508 delete arg4;
33509 }
33510 {
33511 if (temp6)
33512 delete arg6;
33513 }
33514 return NULL;
33515 }
33516
33517
33518 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33519 PyObject *resultobj;
33520 wxMenu *arg1 = (wxMenu *) 0 ;
33521 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33522 wxMenuItem *result;
33523 PyObject * obj0 = 0 ;
33524 PyObject * obj1 = 0 ;
33525 char *kwnames[] = {
33526 (char *) "self",(char *) "item", NULL
33527 };
33528
33529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33531 if (SWIG_arg_fail(1)) SWIG_fail;
33532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33533 if (SWIG_arg_fail(2)) SWIG_fail;
33534 {
33535 PyThreadState* __tstate = wxPyBeginAllowThreads();
33536 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33537
33538 wxPyEndAllowThreads(__tstate);
33539 if (PyErr_Occurred()) SWIG_fail;
33540 }
33541 {
33542 resultobj = wxPyMake_wxObject(result, 0);
33543 }
33544 return resultobj;
33545 fail:
33546 return NULL;
33547 }
33548
33549
33550 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33551 PyObject *resultobj;
33552 wxMenu *arg1 = (wxMenu *) 0 ;
33553 int arg2 ;
33554 wxString *arg3 = 0 ;
33555 wxString const &arg4_defvalue = wxPyEmptyString ;
33556 wxString *arg4 = (wxString *) &arg4_defvalue ;
33557 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33558 wxMenuItem *result;
33559 bool temp3 = false ;
33560 bool temp4 = false ;
33561 PyObject * obj0 = 0 ;
33562 PyObject * obj1 = 0 ;
33563 PyObject * obj2 = 0 ;
33564 PyObject * obj3 = 0 ;
33565 PyObject * obj4 = 0 ;
33566 char *kwnames[] = {
33567 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33568 };
33569
33570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33572 if (SWIG_arg_fail(1)) SWIG_fail;
33573 {
33574 arg2 = (int)(SWIG_As_int(obj1));
33575 if (SWIG_arg_fail(2)) SWIG_fail;
33576 }
33577 {
33578 arg3 = wxString_in_helper(obj2);
33579 if (arg3 == NULL) SWIG_fail;
33580 temp3 = true;
33581 }
33582 if (obj3) {
33583 {
33584 arg4 = wxString_in_helper(obj3);
33585 if (arg4 == NULL) SWIG_fail;
33586 temp4 = true;
33587 }
33588 }
33589 if (obj4) {
33590 {
33591 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33592 if (SWIG_arg_fail(5)) SWIG_fail;
33593 }
33594 }
33595 {
33596 PyThreadState* __tstate = wxPyBeginAllowThreads();
33597 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33598
33599 wxPyEndAllowThreads(__tstate);
33600 if (PyErr_Occurred()) SWIG_fail;
33601 }
33602 {
33603 resultobj = wxPyMake_wxObject(result, 0);
33604 }
33605 {
33606 if (temp3)
33607 delete arg3;
33608 }
33609 {
33610 if (temp4)
33611 delete arg4;
33612 }
33613 return resultobj;
33614 fail:
33615 {
33616 if (temp3)
33617 delete arg3;
33618 }
33619 {
33620 if (temp4)
33621 delete arg4;
33622 }
33623 return NULL;
33624 }
33625
33626
33627 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33628 PyObject *resultobj;
33629 wxMenu *arg1 = (wxMenu *) 0 ;
33630 wxMenuItem *result;
33631 PyObject * obj0 = 0 ;
33632 char *kwnames[] = {
33633 (char *) "self", NULL
33634 };
33635
33636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33638 if (SWIG_arg_fail(1)) SWIG_fail;
33639 {
33640 PyThreadState* __tstate = wxPyBeginAllowThreads();
33641 result = (wxMenuItem *)(arg1)->PrependSeparator();
33642
33643 wxPyEndAllowThreads(__tstate);
33644 if (PyErr_Occurred()) SWIG_fail;
33645 }
33646 {
33647 resultobj = wxPyMake_wxObject(result, 0);
33648 }
33649 return resultobj;
33650 fail:
33651 return NULL;
33652 }
33653
33654
33655 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33656 PyObject *resultobj;
33657 wxMenu *arg1 = (wxMenu *) 0 ;
33658 int arg2 ;
33659 wxString *arg3 = 0 ;
33660 wxString const &arg4_defvalue = wxPyEmptyString ;
33661 wxString *arg4 = (wxString *) &arg4_defvalue ;
33662 wxMenuItem *result;
33663 bool temp3 = false ;
33664 bool temp4 = false ;
33665 PyObject * obj0 = 0 ;
33666 PyObject * obj1 = 0 ;
33667 PyObject * obj2 = 0 ;
33668 PyObject * obj3 = 0 ;
33669 char *kwnames[] = {
33670 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33671 };
33672
33673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33675 if (SWIG_arg_fail(1)) SWIG_fail;
33676 {
33677 arg2 = (int)(SWIG_As_int(obj1));
33678 if (SWIG_arg_fail(2)) SWIG_fail;
33679 }
33680 {
33681 arg3 = wxString_in_helper(obj2);
33682 if (arg3 == NULL) SWIG_fail;
33683 temp3 = true;
33684 }
33685 if (obj3) {
33686 {
33687 arg4 = wxString_in_helper(obj3);
33688 if (arg4 == NULL) SWIG_fail;
33689 temp4 = true;
33690 }
33691 }
33692 {
33693 PyThreadState* __tstate = wxPyBeginAllowThreads();
33694 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33695
33696 wxPyEndAllowThreads(__tstate);
33697 if (PyErr_Occurred()) SWIG_fail;
33698 }
33699 {
33700 resultobj = wxPyMake_wxObject(result, 0);
33701 }
33702 {
33703 if (temp3)
33704 delete arg3;
33705 }
33706 {
33707 if (temp4)
33708 delete arg4;
33709 }
33710 return resultobj;
33711 fail:
33712 {
33713 if (temp3)
33714 delete arg3;
33715 }
33716 {
33717 if (temp4)
33718 delete arg4;
33719 }
33720 return NULL;
33721 }
33722
33723
33724 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33725 PyObject *resultobj;
33726 wxMenu *arg1 = (wxMenu *) 0 ;
33727 int arg2 ;
33728 wxString *arg3 = 0 ;
33729 wxString const &arg4_defvalue = wxPyEmptyString ;
33730 wxString *arg4 = (wxString *) &arg4_defvalue ;
33731 wxMenuItem *result;
33732 bool temp3 = false ;
33733 bool temp4 = false ;
33734 PyObject * obj0 = 0 ;
33735 PyObject * obj1 = 0 ;
33736 PyObject * obj2 = 0 ;
33737 PyObject * obj3 = 0 ;
33738 char *kwnames[] = {
33739 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33740 };
33741
33742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33744 if (SWIG_arg_fail(1)) SWIG_fail;
33745 {
33746 arg2 = (int)(SWIG_As_int(obj1));
33747 if (SWIG_arg_fail(2)) SWIG_fail;
33748 }
33749 {
33750 arg3 = wxString_in_helper(obj2);
33751 if (arg3 == NULL) SWIG_fail;
33752 temp3 = true;
33753 }
33754 if (obj3) {
33755 {
33756 arg4 = wxString_in_helper(obj3);
33757 if (arg4 == NULL) SWIG_fail;
33758 temp4 = true;
33759 }
33760 }
33761 {
33762 PyThreadState* __tstate = wxPyBeginAllowThreads();
33763 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33764
33765 wxPyEndAllowThreads(__tstate);
33766 if (PyErr_Occurred()) SWIG_fail;
33767 }
33768 {
33769 resultobj = wxPyMake_wxObject(result, 0);
33770 }
33771 {
33772 if (temp3)
33773 delete arg3;
33774 }
33775 {
33776 if (temp4)
33777 delete arg4;
33778 }
33779 return resultobj;
33780 fail:
33781 {
33782 if (temp3)
33783 delete arg3;
33784 }
33785 {
33786 if (temp4)
33787 delete arg4;
33788 }
33789 return NULL;
33790 }
33791
33792
33793 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33794 PyObject *resultobj;
33795 wxMenu *arg1 = (wxMenu *) 0 ;
33796 int arg2 ;
33797 wxString *arg3 = 0 ;
33798 wxMenu *arg4 = (wxMenu *) 0 ;
33799 wxString const &arg5_defvalue = wxPyEmptyString ;
33800 wxString *arg5 = (wxString *) &arg5_defvalue ;
33801 wxMenuItem *result;
33802 bool temp3 = false ;
33803 bool temp5 = false ;
33804 PyObject * obj0 = 0 ;
33805 PyObject * obj1 = 0 ;
33806 PyObject * obj2 = 0 ;
33807 PyObject * obj3 = 0 ;
33808 PyObject * obj4 = 0 ;
33809 char *kwnames[] = {
33810 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33811 };
33812
33813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33815 if (SWIG_arg_fail(1)) SWIG_fail;
33816 {
33817 arg2 = (int)(SWIG_As_int(obj1));
33818 if (SWIG_arg_fail(2)) SWIG_fail;
33819 }
33820 {
33821 arg3 = wxString_in_helper(obj2);
33822 if (arg3 == NULL) SWIG_fail;
33823 temp3 = true;
33824 }
33825 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33826 if (SWIG_arg_fail(4)) SWIG_fail;
33827 if (obj4) {
33828 {
33829 arg5 = wxString_in_helper(obj4);
33830 if (arg5 == NULL) SWIG_fail;
33831 temp5 = true;
33832 }
33833 }
33834 {
33835 PyThreadState* __tstate = wxPyBeginAllowThreads();
33836 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33837
33838 wxPyEndAllowThreads(__tstate);
33839 if (PyErr_Occurred()) SWIG_fail;
33840 }
33841 {
33842 resultobj = wxPyMake_wxObject(result, 0);
33843 }
33844 {
33845 if (temp3)
33846 delete arg3;
33847 }
33848 {
33849 if (temp5)
33850 delete arg5;
33851 }
33852 return resultobj;
33853 fail:
33854 {
33855 if (temp3)
33856 delete arg3;
33857 }
33858 {
33859 if (temp5)
33860 delete arg5;
33861 }
33862 return NULL;
33863 }
33864
33865
33866 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33867 PyObject *resultobj;
33868 wxMenu *arg1 = (wxMenu *) 0 ;
33869 int arg2 ;
33870 wxMenuItem *result;
33871 PyObject * obj0 = 0 ;
33872 PyObject * obj1 = 0 ;
33873 char *kwnames[] = {
33874 (char *) "self",(char *) "id", NULL
33875 };
33876
33877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33879 if (SWIG_arg_fail(1)) SWIG_fail;
33880 {
33881 arg2 = (int)(SWIG_As_int(obj1));
33882 if (SWIG_arg_fail(2)) SWIG_fail;
33883 }
33884 {
33885 PyThreadState* __tstate = wxPyBeginAllowThreads();
33886 result = (wxMenuItem *)(arg1)->Remove(arg2);
33887
33888 wxPyEndAllowThreads(__tstate);
33889 if (PyErr_Occurred()) SWIG_fail;
33890 }
33891 {
33892 resultobj = wxPyMake_wxObject(result, 0);
33893 }
33894 return resultobj;
33895 fail:
33896 return NULL;
33897 }
33898
33899
33900 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33901 PyObject *resultobj;
33902 wxMenu *arg1 = (wxMenu *) 0 ;
33903 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33904 wxMenuItem *result;
33905 PyObject * obj0 = 0 ;
33906 PyObject * obj1 = 0 ;
33907 char *kwnames[] = {
33908 (char *) "self",(char *) "item", NULL
33909 };
33910
33911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33913 if (SWIG_arg_fail(1)) SWIG_fail;
33914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33915 if (SWIG_arg_fail(2)) SWIG_fail;
33916 {
33917 PyThreadState* __tstate = wxPyBeginAllowThreads();
33918 result = (wxMenuItem *)(arg1)->Remove(arg2);
33919
33920 wxPyEndAllowThreads(__tstate);
33921 if (PyErr_Occurred()) SWIG_fail;
33922 }
33923 {
33924 resultobj = wxPyMake_wxObject(result, 0);
33925 }
33926 return resultobj;
33927 fail:
33928 return NULL;
33929 }
33930
33931
33932 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33933 PyObject *resultobj;
33934 wxMenu *arg1 = (wxMenu *) 0 ;
33935 int arg2 ;
33936 bool result;
33937 PyObject * obj0 = 0 ;
33938 PyObject * obj1 = 0 ;
33939 char *kwnames[] = {
33940 (char *) "self",(char *) "id", NULL
33941 };
33942
33943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33945 if (SWIG_arg_fail(1)) SWIG_fail;
33946 {
33947 arg2 = (int)(SWIG_As_int(obj1));
33948 if (SWIG_arg_fail(2)) SWIG_fail;
33949 }
33950 {
33951 PyThreadState* __tstate = wxPyBeginAllowThreads();
33952 result = (bool)(arg1)->Delete(arg2);
33953
33954 wxPyEndAllowThreads(__tstate);
33955 if (PyErr_Occurred()) SWIG_fail;
33956 }
33957 {
33958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33959 }
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33967 PyObject *resultobj;
33968 wxMenu *arg1 = (wxMenu *) 0 ;
33969 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33970 bool result;
33971 PyObject * obj0 = 0 ;
33972 PyObject * obj1 = 0 ;
33973 char *kwnames[] = {
33974 (char *) "self",(char *) "item", NULL
33975 };
33976
33977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33979 if (SWIG_arg_fail(1)) SWIG_fail;
33980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33981 if (SWIG_arg_fail(2)) SWIG_fail;
33982 {
33983 PyThreadState* __tstate = wxPyBeginAllowThreads();
33984 result = (bool)(arg1)->Delete(arg2);
33985
33986 wxPyEndAllowThreads(__tstate);
33987 if (PyErr_Occurred()) SWIG_fail;
33988 }
33989 {
33990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33991 }
33992 return resultobj;
33993 fail:
33994 return NULL;
33995 }
33996
33997
33998 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33999 PyObject *resultobj;
34000 wxMenu *arg1 = (wxMenu *) 0 ;
34001 PyObject * obj0 = 0 ;
34002 char *kwnames[] = {
34003 (char *) "self", NULL
34004 };
34005
34006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34008 if (SWIG_arg_fail(1)) SWIG_fail;
34009 {
34010 PyThreadState* __tstate = wxPyBeginAllowThreads();
34011 wxMenu_Destroy(arg1);
34012
34013 wxPyEndAllowThreads(__tstate);
34014 if (PyErr_Occurred()) SWIG_fail;
34015 }
34016 Py_INCREF(Py_None); resultobj = Py_None;
34017 return resultobj;
34018 fail:
34019 return NULL;
34020 }
34021
34022
34023 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34024 PyObject *resultobj;
34025 wxMenu *arg1 = (wxMenu *) 0 ;
34026 int arg2 ;
34027 bool result;
34028 PyObject * obj0 = 0 ;
34029 PyObject * obj1 = 0 ;
34030 char *kwnames[] = {
34031 (char *) "self",(char *) "id", NULL
34032 };
34033
34034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34036 if (SWIG_arg_fail(1)) SWIG_fail;
34037 {
34038 arg2 = (int)(SWIG_As_int(obj1));
34039 if (SWIG_arg_fail(2)) SWIG_fail;
34040 }
34041 {
34042 PyThreadState* __tstate = wxPyBeginAllowThreads();
34043 result = (bool)(arg1)->Destroy(arg2);
34044
34045 wxPyEndAllowThreads(__tstate);
34046 if (PyErr_Occurred()) SWIG_fail;
34047 }
34048 {
34049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34050 }
34051 return resultobj;
34052 fail:
34053 return NULL;
34054 }
34055
34056
34057 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34058 PyObject *resultobj;
34059 wxMenu *arg1 = (wxMenu *) 0 ;
34060 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34061 bool result;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 char *kwnames[] = {
34065 (char *) "self",(char *) "item", NULL
34066 };
34067
34068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34070 if (SWIG_arg_fail(1)) SWIG_fail;
34071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34072 if (SWIG_arg_fail(2)) SWIG_fail;
34073 {
34074 PyThreadState* __tstate = wxPyBeginAllowThreads();
34075 result = (bool)(arg1)->Destroy(arg2);
34076
34077 wxPyEndAllowThreads(__tstate);
34078 if (PyErr_Occurred()) SWIG_fail;
34079 }
34080 {
34081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34082 }
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj;
34091 wxMenu *arg1 = (wxMenu *) 0 ;
34092 size_t result;
34093 PyObject * obj0 = 0 ;
34094 char *kwnames[] = {
34095 (char *) "self", NULL
34096 };
34097
34098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34100 if (SWIG_arg_fail(1)) SWIG_fail;
34101 {
34102 PyThreadState* __tstate = wxPyBeginAllowThreads();
34103 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34104
34105 wxPyEndAllowThreads(__tstate);
34106 if (PyErr_Occurred()) SWIG_fail;
34107 }
34108 {
34109 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34110 }
34111 return resultobj;
34112 fail:
34113 return NULL;
34114 }
34115
34116
34117 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34118 PyObject *resultobj;
34119 wxMenu *arg1 = (wxMenu *) 0 ;
34120 PyObject *result;
34121 PyObject * obj0 = 0 ;
34122 char *kwnames[] = {
34123 (char *) "self", NULL
34124 };
34125
34126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34128 if (SWIG_arg_fail(1)) SWIG_fail;
34129 {
34130 PyThreadState* __tstate = wxPyBeginAllowThreads();
34131 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34132
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = result;
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34144 PyObject *resultobj;
34145 wxMenu *arg1 = (wxMenu *) 0 ;
34146 wxString *arg2 = 0 ;
34147 int result;
34148 bool temp2 = false ;
34149 PyObject * obj0 = 0 ;
34150 PyObject * obj1 = 0 ;
34151 char *kwnames[] = {
34152 (char *) "self",(char *) "item", NULL
34153 };
34154
34155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34157 if (SWIG_arg_fail(1)) SWIG_fail;
34158 {
34159 arg2 = wxString_in_helper(obj1);
34160 if (arg2 == NULL) SWIG_fail;
34161 temp2 = true;
34162 }
34163 {
34164 PyThreadState* __tstate = wxPyBeginAllowThreads();
34165 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34166
34167 wxPyEndAllowThreads(__tstate);
34168 if (PyErr_Occurred()) SWIG_fail;
34169 }
34170 {
34171 resultobj = SWIG_From_int((int)(result));
34172 }
34173 {
34174 if (temp2)
34175 delete arg2;
34176 }
34177 return resultobj;
34178 fail:
34179 {
34180 if (temp2)
34181 delete arg2;
34182 }
34183 return NULL;
34184 }
34185
34186
34187 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34188 PyObject *resultobj;
34189 wxMenu *arg1 = (wxMenu *) 0 ;
34190 int arg2 ;
34191 wxMenuItem *result;
34192 PyObject * obj0 = 0 ;
34193 PyObject * obj1 = 0 ;
34194 char *kwnames[] = {
34195 (char *) "self",(char *) "id", NULL
34196 };
34197
34198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34200 if (SWIG_arg_fail(1)) SWIG_fail;
34201 {
34202 arg2 = (int)(SWIG_As_int(obj1));
34203 if (SWIG_arg_fail(2)) SWIG_fail;
34204 }
34205 {
34206 PyThreadState* __tstate = wxPyBeginAllowThreads();
34207 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34208
34209 wxPyEndAllowThreads(__tstate);
34210 if (PyErr_Occurred()) SWIG_fail;
34211 }
34212 {
34213 resultobj = wxPyMake_wxObject(result, 0);
34214 }
34215 return resultobj;
34216 fail:
34217 return NULL;
34218 }
34219
34220
34221 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34222 PyObject *resultobj;
34223 wxMenu *arg1 = (wxMenu *) 0 ;
34224 size_t arg2 ;
34225 wxMenuItem *result;
34226 PyObject * obj0 = 0 ;
34227 PyObject * obj1 = 0 ;
34228 char *kwnames[] = {
34229 (char *) "self",(char *) "position", NULL
34230 };
34231
34232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34234 if (SWIG_arg_fail(1)) SWIG_fail;
34235 {
34236 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34237 if (SWIG_arg_fail(2)) SWIG_fail;
34238 }
34239 {
34240 PyThreadState* __tstate = wxPyBeginAllowThreads();
34241 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34242
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 {
34247 resultobj = wxPyMake_wxObject(result, 0);
34248 }
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34256 PyObject *resultobj;
34257 wxMenu *arg1 = (wxMenu *) 0 ;
34258 int arg2 ;
34259 bool arg3 ;
34260 PyObject * obj0 = 0 ;
34261 PyObject * obj1 = 0 ;
34262 PyObject * obj2 = 0 ;
34263 char *kwnames[] = {
34264 (char *) "self",(char *) "id",(char *) "enable", NULL
34265 };
34266
34267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34269 if (SWIG_arg_fail(1)) SWIG_fail;
34270 {
34271 arg2 = (int)(SWIG_As_int(obj1));
34272 if (SWIG_arg_fail(2)) SWIG_fail;
34273 }
34274 {
34275 arg3 = (bool)(SWIG_As_bool(obj2));
34276 if (SWIG_arg_fail(3)) SWIG_fail;
34277 }
34278 {
34279 PyThreadState* __tstate = wxPyBeginAllowThreads();
34280 (arg1)->Enable(arg2,arg3);
34281
34282 wxPyEndAllowThreads(__tstate);
34283 if (PyErr_Occurred()) SWIG_fail;
34284 }
34285 Py_INCREF(Py_None); resultobj = Py_None;
34286 return resultobj;
34287 fail:
34288 return NULL;
34289 }
34290
34291
34292 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34293 PyObject *resultobj;
34294 wxMenu *arg1 = (wxMenu *) 0 ;
34295 int arg2 ;
34296 bool result;
34297 PyObject * obj0 = 0 ;
34298 PyObject * obj1 = 0 ;
34299 char *kwnames[] = {
34300 (char *) "self",(char *) "id", NULL
34301 };
34302
34303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34305 if (SWIG_arg_fail(1)) SWIG_fail;
34306 {
34307 arg2 = (int)(SWIG_As_int(obj1));
34308 if (SWIG_arg_fail(2)) SWIG_fail;
34309 }
34310 {
34311 PyThreadState* __tstate = wxPyBeginAllowThreads();
34312 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34313
34314 wxPyEndAllowThreads(__tstate);
34315 if (PyErr_Occurred()) SWIG_fail;
34316 }
34317 {
34318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34319 }
34320 return resultobj;
34321 fail:
34322 return NULL;
34323 }
34324
34325
34326 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34327 PyObject *resultobj;
34328 wxMenu *arg1 = (wxMenu *) 0 ;
34329 int arg2 ;
34330 bool arg3 ;
34331 PyObject * obj0 = 0 ;
34332 PyObject * obj1 = 0 ;
34333 PyObject * obj2 = 0 ;
34334 char *kwnames[] = {
34335 (char *) "self",(char *) "id",(char *) "check", NULL
34336 };
34337
34338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34340 if (SWIG_arg_fail(1)) SWIG_fail;
34341 {
34342 arg2 = (int)(SWIG_As_int(obj1));
34343 if (SWIG_arg_fail(2)) SWIG_fail;
34344 }
34345 {
34346 arg3 = (bool)(SWIG_As_bool(obj2));
34347 if (SWIG_arg_fail(3)) SWIG_fail;
34348 }
34349 {
34350 PyThreadState* __tstate = wxPyBeginAllowThreads();
34351 (arg1)->Check(arg2,arg3);
34352
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 Py_INCREF(Py_None); resultobj = Py_None;
34357 return resultobj;
34358 fail:
34359 return NULL;
34360 }
34361
34362
34363 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34364 PyObject *resultobj;
34365 wxMenu *arg1 = (wxMenu *) 0 ;
34366 int arg2 ;
34367 bool result;
34368 PyObject * obj0 = 0 ;
34369 PyObject * obj1 = 0 ;
34370 char *kwnames[] = {
34371 (char *) "self",(char *) "id", NULL
34372 };
34373
34374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34376 if (SWIG_arg_fail(1)) SWIG_fail;
34377 {
34378 arg2 = (int)(SWIG_As_int(obj1));
34379 if (SWIG_arg_fail(2)) SWIG_fail;
34380 }
34381 {
34382 PyThreadState* __tstate = wxPyBeginAllowThreads();
34383 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34384
34385 wxPyEndAllowThreads(__tstate);
34386 if (PyErr_Occurred()) SWIG_fail;
34387 }
34388 {
34389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34390 }
34391 return resultobj;
34392 fail:
34393 return NULL;
34394 }
34395
34396
34397 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34398 PyObject *resultobj;
34399 wxMenu *arg1 = (wxMenu *) 0 ;
34400 int arg2 ;
34401 wxString *arg3 = 0 ;
34402 bool temp3 = false ;
34403 PyObject * obj0 = 0 ;
34404 PyObject * obj1 = 0 ;
34405 PyObject * obj2 = 0 ;
34406 char *kwnames[] = {
34407 (char *) "self",(char *) "id",(char *) "label", NULL
34408 };
34409
34410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34412 if (SWIG_arg_fail(1)) SWIG_fail;
34413 {
34414 arg2 = (int)(SWIG_As_int(obj1));
34415 if (SWIG_arg_fail(2)) SWIG_fail;
34416 }
34417 {
34418 arg3 = wxString_in_helper(obj2);
34419 if (arg3 == NULL) SWIG_fail;
34420 temp3 = true;
34421 }
34422 {
34423 PyThreadState* __tstate = wxPyBeginAllowThreads();
34424 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34425
34426 wxPyEndAllowThreads(__tstate);
34427 if (PyErr_Occurred()) SWIG_fail;
34428 }
34429 Py_INCREF(Py_None); resultobj = Py_None;
34430 {
34431 if (temp3)
34432 delete arg3;
34433 }
34434 return resultobj;
34435 fail:
34436 {
34437 if (temp3)
34438 delete arg3;
34439 }
34440 return NULL;
34441 }
34442
34443
34444 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34445 PyObject *resultobj;
34446 wxMenu *arg1 = (wxMenu *) 0 ;
34447 int arg2 ;
34448 wxString result;
34449 PyObject * obj0 = 0 ;
34450 PyObject * obj1 = 0 ;
34451 char *kwnames[] = {
34452 (char *) "self",(char *) "id", NULL
34453 };
34454
34455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34457 if (SWIG_arg_fail(1)) SWIG_fail;
34458 {
34459 arg2 = (int)(SWIG_As_int(obj1));
34460 if (SWIG_arg_fail(2)) SWIG_fail;
34461 }
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34465
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 {
34470 #if wxUSE_UNICODE
34471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34472 #else
34473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34474 #endif
34475 }
34476 return resultobj;
34477 fail:
34478 return NULL;
34479 }
34480
34481
34482 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34483 PyObject *resultobj;
34484 wxMenu *arg1 = (wxMenu *) 0 ;
34485 int arg2 ;
34486 wxString *arg3 = 0 ;
34487 bool temp3 = false ;
34488 PyObject * obj0 = 0 ;
34489 PyObject * obj1 = 0 ;
34490 PyObject * obj2 = 0 ;
34491 char *kwnames[] = {
34492 (char *) "self",(char *) "id",(char *) "helpString", NULL
34493 };
34494
34495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34497 if (SWIG_arg_fail(1)) SWIG_fail;
34498 {
34499 arg2 = (int)(SWIG_As_int(obj1));
34500 if (SWIG_arg_fail(2)) SWIG_fail;
34501 }
34502 {
34503 arg3 = wxString_in_helper(obj2);
34504 if (arg3 == NULL) SWIG_fail;
34505 temp3 = true;
34506 }
34507 {
34508 PyThreadState* __tstate = wxPyBeginAllowThreads();
34509 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34510
34511 wxPyEndAllowThreads(__tstate);
34512 if (PyErr_Occurred()) SWIG_fail;
34513 }
34514 Py_INCREF(Py_None); resultobj = Py_None;
34515 {
34516 if (temp3)
34517 delete arg3;
34518 }
34519 return resultobj;
34520 fail:
34521 {
34522 if (temp3)
34523 delete arg3;
34524 }
34525 return NULL;
34526 }
34527
34528
34529 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34530 PyObject *resultobj;
34531 wxMenu *arg1 = (wxMenu *) 0 ;
34532 int arg2 ;
34533 wxString result;
34534 PyObject * obj0 = 0 ;
34535 PyObject * obj1 = 0 ;
34536 char *kwnames[] = {
34537 (char *) "self",(char *) "id", NULL
34538 };
34539
34540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34542 if (SWIG_arg_fail(1)) SWIG_fail;
34543 {
34544 arg2 = (int)(SWIG_As_int(obj1));
34545 if (SWIG_arg_fail(2)) SWIG_fail;
34546 }
34547 {
34548 PyThreadState* __tstate = wxPyBeginAllowThreads();
34549 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34550
34551 wxPyEndAllowThreads(__tstate);
34552 if (PyErr_Occurred()) SWIG_fail;
34553 }
34554 {
34555 #if wxUSE_UNICODE
34556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34557 #else
34558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34559 #endif
34560 }
34561 return resultobj;
34562 fail:
34563 return NULL;
34564 }
34565
34566
34567 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34568 PyObject *resultobj;
34569 wxMenu *arg1 = (wxMenu *) 0 ;
34570 wxString *arg2 = 0 ;
34571 bool temp2 = false ;
34572 PyObject * obj0 = 0 ;
34573 PyObject * obj1 = 0 ;
34574 char *kwnames[] = {
34575 (char *) "self",(char *) "title", NULL
34576 };
34577
34578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34580 if (SWIG_arg_fail(1)) SWIG_fail;
34581 {
34582 arg2 = wxString_in_helper(obj1);
34583 if (arg2 == NULL) SWIG_fail;
34584 temp2 = true;
34585 }
34586 {
34587 PyThreadState* __tstate = wxPyBeginAllowThreads();
34588 (arg1)->SetTitle((wxString const &)*arg2);
34589
34590 wxPyEndAllowThreads(__tstate);
34591 if (PyErr_Occurred()) SWIG_fail;
34592 }
34593 Py_INCREF(Py_None); resultobj = Py_None;
34594 {
34595 if (temp2)
34596 delete arg2;
34597 }
34598 return resultobj;
34599 fail:
34600 {
34601 if (temp2)
34602 delete arg2;
34603 }
34604 return NULL;
34605 }
34606
34607
34608 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34609 PyObject *resultobj;
34610 wxMenu *arg1 = (wxMenu *) 0 ;
34611 wxString result;
34612 PyObject * obj0 = 0 ;
34613 char *kwnames[] = {
34614 (char *) "self", NULL
34615 };
34616
34617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34619 if (SWIG_arg_fail(1)) SWIG_fail;
34620 {
34621 PyThreadState* __tstate = wxPyBeginAllowThreads();
34622 result = ((wxMenu const *)arg1)->GetTitle();
34623
34624 wxPyEndAllowThreads(__tstate);
34625 if (PyErr_Occurred()) SWIG_fail;
34626 }
34627 {
34628 #if wxUSE_UNICODE
34629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34630 #else
34631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34632 #endif
34633 }
34634 return resultobj;
34635 fail:
34636 return NULL;
34637 }
34638
34639
34640 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34641 PyObject *resultobj;
34642 wxMenu *arg1 = (wxMenu *) 0 ;
34643 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34644 PyObject * obj0 = 0 ;
34645 PyObject * obj1 = 0 ;
34646 char *kwnames[] = {
34647 (char *) "self",(char *) "handler", NULL
34648 };
34649
34650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34652 if (SWIG_arg_fail(1)) SWIG_fail;
34653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34654 if (SWIG_arg_fail(2)) SWIG_fail;
34655 {
34656 PyThreadState* __tstate = wxPyBeginAllowThreads();
34657 (arg1)->SetEventHandler(arg2);
34658
34659 wxPyEndAllowThreads(__tstate);
34660 if (PyErr_Occurred()) SWIG_fail;
34661 }
34662 Py_INCREF(Py_None); resultobj = Py_None;
34663 return resultobj;
34664 fail:
34665 return NULL;
34666 }
34667
34668
34669 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34670 PyObject *resultobj;
34671 wxMenu *arg1 = (wxMenu *) 0 ;
34672 wxEvtHandler *result;
34673 PyObject * obj0 = 0 ;
34674 char *kwnames[] = {
34675 (char *) "self", NULL
34676 };
34677
34678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34680 if (SWIG_arg_fail(1)) SWIG_fail;
34681 {
34682 PyThreadState* __tstate = wxPyBeginAllowThreads();
34683 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34684
34685 wxPyEndAllowThreads(__tstate);
34686 if (PyErr_Occurred()) SWIG_fail;
34687 }
34688 {
34689 resultobj = wxPyMake_wxObject(result, 0);
34690 }
34691 return resultobj;
34692 fail:
34693 return NULL;
34694 }
34695
34696
34697 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34698 PyObject *resultobj;
34699 wxMenu *arg1 = (wxMenu *) 0 ;
34700 wxWindow *arg2 = (wxWindow *) 0 ;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 char *kwnames[] = {
34704 (char *) "self",(char *) "win", NULL
34705 };
34706
34707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34709 if (SWIG_arg_fail(1)) SWIG_fail;
34710 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34711 if (SWIG_arg_fail(2)) SWIG_fail;
34712 {
34713 PyThreadState* __tstate = wxPyBeginAllowThreads();
34714 (arg1)->SetInvokingWindow(arg2);
34715
34716 wxPyEndAllowThreads(__tstate);
34717 if (PyErr_Occurred()) SWIG_fail;
34718 }
34719 Py_INCREF(Py_None); resultobj = Py_None;
34720 return resultobj;
34721 fail:
34722 return NULL;
34723 }
34724
34725
34726 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34727 PyObject *resultobj;
34728 wxMenu *arg1 = (wxMenu *) 0 ;
34729 wxWindow *result;
34730 PyObject * obj0 = 0 ;
34731 char *kwnames[] = {
34732 (char *) "self", NULL
34733 };
34734
34735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34737 if (SWIG_arg_fail(1)) SWIG_fail;
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34741
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 {
34746 resultobj = wxPyMake_wxObject(result, 0);
34747 }
34748 return resultobj;
34749 fail:
34750 return NULL;
34751 }
34752
34753
34754 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34755 PyObject *resultobj;
34756 wxMenu *arg1 = (wxMenu *) 0 ;
34757 long result;
34758 PyObject * obj0 = 0 ;
34759 char *kwnames[] = {
34760 (char *) "self", NULL
34761 };
34762
34763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34765 if (SWIG_arg_fail(1)) SWIG_fail;
34766 {
34767 PyThreadState* __tstate = wxPyBeginAllowThreads();
34768 result = (long)((wxMenu const *)arg1)->GetStyle();
34769
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 {
34774 resultobj = SWIG_From_long((long)(result));
34775 }
34776 return resultobj;
34777 fail:
34778 return NULL;
34779 }
34780
34781
34782 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34783 PyObject *resultobj;
34784 wxMenu *arg1 = (wxMenu *) 0 ;
34785 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34786 PyObject * obj0 = 0 ;
34787 PyObject * obj1 = 0 ;
34788 char *kwnames[] = {
34789 (char *) "self",(char *) "source", NULL
34790 };
34791
34792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34794 if (SWIG_arg_fail(1)) SWIG_fail;
34795 if (obj1) {
34796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34797 if (SWIG_arg_fail(2)) SWIG_fail;
34798 }
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 (arg1)->UpdateUI(arg2);
34802
34803 wxPyEndAllowThreads(__tstate);
34804 if (PyErr_Occurred()) SWIG_fail;
34805 }
34806 Py_INCREF(Py_None); resultobj = Py_None;
34807 return resultobj;
34808 fail:
34809 return NULL;
34810 }
34811
34812
34813 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34814 PyObject *resultobj;
34815 wxMenu *arg1 = (wxMenu *) 0 ;
34816 wxMenuBar *result;
34817 PyObject * obj0 = 0 ;
34818 char *kwnames[] = {
34819 (char *) "self", NULL
34820 };
34821
34822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34824 if (SWIG_arg_fail(1)) SWIG_fail;
34825 {
34826 PyThreadState* __tstate = wxPyBeginAllowThreads();
34827 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34828
34829 wxPyEndAllowThreads(__tstate);
34830 if (PyErr_Occurred()) SWIG_fail;
34831 }
34832 {
34833 resultobj = wxPyMake_wxObject(result, 0);
34834 }
34835 return resultobj;
34836 fail:
34837 return NULL;
34838 }
34839
34840
34841 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34842 PyObject *resultobj;
34843 wxMenu *arg1 = (wxMenu *) 0 ;
34844 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34845 PyObject * obj0 = 0 ;
34846 PyObject * obj1 = 0 ;
34847 char *kwnames[] = {
34848 (char *) "self",(char *) "menubar", NULL
34849 };
34850
34851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34853 if (SWIG_arg_fail(1)) SWIG_fail;
34854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34855 if (SWIG_arg_fail(2)) SWIG_fail;
34856 {
34857 PyThreadState* __tstate = wxPyBeginAllowThreads();
34858 (arg1)->Attach(arg2);
34859
34860 wxPyEndAllowThreads(__tstate);
34861 if (PyErr_Occurred()) SWIG_fail;
34862 }
34863 Py_INCREF(Py_None); resultobj = Py_None;
34864 return resultobj;
34865 fail:
34866 return NULL;
34867 }
34868
34869
34870 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34871 PyObject *resultobj;
34872 wxMenu *arg1 = (wxMenu *) 0 ;
34873 PyObject * obj0 = 0 ;
34874 char *kwnames[] = {
34875 (char *) "self", NULL
34876 };
34877
34878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34880 if (SWIG_arg_fail(1)) SWIG_fail;
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 (arg1)->Detach();
34884
34885 wxPyEndAllowThreads(__tstate);
34886 if (PyErr_Occurred()) SWIG_fail;
34887 }
34888 Py_INCREF(Py_None); resultobj = Py_None;
34889 return resultobj;
34890 fail:
34891 return NULL;
34892 }
34893
34894
34895 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34896 PyObject *resultobj;
34897 wxMenu *arg1 = (wxMenu *) 0 ;
34898 bool result;
34899 PyObject * obj0 = 0 ;
34900 char *kwnames[] = {
34901 (char *) "self", NULL
34902 };
34903
34904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34906 if (SWIG_arg_fail(1)) SWIG_fail;
34907 {
34908 PyThreadState* __tstate = wxPyBeginAllowThreads();
34909 result = (bool)((wxMenu const *)arg1)->IsAttached();
34910
34911 wxPyEndAllowThreads(__tstate);
34912 if (PyErr_Occurred()) SWIG_fail;
34913 }
34914 {
34915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34916 }
34917 return resultobj;
34918 fail:
34919 return NULL;
34920 }
34921
34922
34923 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34924 PyObject *resultobj;
34925 wxMenu *arg1 = (wxMenu *) 0 ;
34926 wxMenu *arg2 = (wxMenu *) 0 ;
34927 PyObject * obj0 = 0 ;
34928 PyObject * obj1 = 0 ;
34929 char *kwnames[] = {
34930 (char *) "self",(char *) "parent", NULL
34931 };
34932
34933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34935 if (SWIG_arg_fail(1)) SWIG_fail;
34936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34937 if (SWIG_arg_fail(2)) SWIG_fail;
34938 {
34939 PyThreadState* __tstate = wxPyBeginAllowThreads();
34940 (arg1)->SetParent(arg2);
34941
34942 wxPyEndAllowThreads(__tstate);
34943 if (PyErr_Occurred()) SWIG_fail;
34944 }
34945 Py_INCREF(Py_None); resultobj = Py_None;
34946 return resultobj;
34947 fail:
34948 return NULL;
34949 }
34950
34951
34952 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34953 PyObject *resultobj;
34954 wxMenu *arg1 = (wxMenu *) 0 ;
34955 wxMenu *result;
34956 PyObject * obj0 = 0 ;
34957 char *kwnames[] = {
34958 (char *) "self", NULL
34959 };
34960
34961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34963 if (SWIG_arg_fail(1)) SWIG_fail;
34964 {
34965 PyThreadState* __tstate = wxPyBeginAllowThreads();
34966 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34967
34968 wxPyEndAllowThreads(__tstate);
34969 if (PyErr_Occurred()) SWIG_fail;
34970 }
34971 {
34972 resultobj = wxPyMake_wxObject(result, 0);
34973 }
34974 return resultobj;
34975 fail:
34976 return NULL;
34977 }
34978
34979
34980 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34981 PyObject *obj;
34982 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34983 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34984 Py_INCREF(obj);
34985 return Py_BuildValue((char *)"");
34986 }
34987 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34988 PyObject *resultobj;
34989 long arg1 = (long) 0 ;
34990 wxMenuBar *result;
34991 PyObject * obj0 = 0 ;
34992 char *kwnames[] = {
34993 (char *) "style", NULL
34994 };
34995
34996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34997 if (obj0) {
34998 {
34999 arg1 = (long)(SWIG_As_long(obj0));
35000 if (SWIG_arg_fail(1)) SWIG_fail;
35001 }
35002 }
35003 {
35004 if (!wxPyCheckForApp()) SWIG_fail;
35005 PyThreadState* __tstate = wxPyBeginAllowThreads();
35006 result = (wxMenuBar *)new wxMenuBar(arg1);
35007
35008 wxPyEndAllowThreads(__tstate);
35009 if (PyErr_Occurred()) SWIG_fail;
35010 }
35011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35012 return resultobj;
35013 fail:
35014 return NULL;
35015 }
35016
35017
35018 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35019 PyObject *resultobj;
35020 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35021 wxMenu *arg2 = (wxMenu *) 0 ;
35022 wxString *arg3 = 0 ;
35023 bool result;
35024 bool temp3 = false ;
35025 PyObject * obj0 = 0 ;
35026 PyObject * obj1 = 0 ;
35027 PyObject * obj2 = 0 ;
35028 char *kwnames[] = {
35029 (char *) "self",(char *) "menu",(char *) "title", NULL
35030 };
35031
35032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35036 if (SWIG_arg_fail(2)) SWIG_fail;
35037 {
35038 arg3 = wxString_in_helper(obj2);
35039 if (arg3 == NULL) SWIG_fail;
35040 temp3 = true;
35041 }
35042 {
35043 PyThreadState* __tstate = wxPyBeginAllowThreads();
35044 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35045
35046 wxPyEndAllowThreads(__tstate);
35047 if (PyErr_Occurred()) SWIG_fail;
35048 }
35049 {
35050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35051 }
35052 {
35053 if (temp3)
35054 delete arg3;
35055 }
35056 return resultobj;
35057 fail:
35058 {
35059 if (temp3)
35060 delete arg3;
35061 }
35062 return NULL;
35063 }
35064
35065
35066 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35067 PyObject *resultobj;
35068 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35069 size_t arg2 ;
35070 wxMenu *arg3 = (wxMenu *) 0 ;
35071 wxString *arg4 = 0 ;
35072 bool result;
35073 bool temp4 = false ;
35074 PyObject * obj0 = 0 ;
35075 PyObject * obj1 = 0 ;
35076 PyObject * obj2 = 0 ;
35077 PyObject * obj3 = 0 ;
35078 char *kwnames[] = {
35079 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35080 };
35081
35082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35084 if (SWIG_arg_fail(1)) SWIG_fail;
35085 {
35086 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35087 if (SWIG_arg_fail(2)) SWIG_fail;
35088 }
35089 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35090 if (SWIG_arg_fail(3)) SWIG_fail;
35091 {
35092 arg4 = wxString_in_helper(obj3);
35093 if (arg4 == NULL) SWIG_fail;
35094 temp4 = true;
35095 }
35096 {
35097 PyThreadState* __tstate = wxPyBeginAllowThreads();
35098 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35099
35100 wxPyEndAllowThreads(__tstate);
35101 if (PyErr_Occurred()) SWIG_fail;
35102 }
35103 {
35104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35105 }
35106 {
35107 if (temp4)
35108 delete arg4;
35109 }
35110 return resultobj;
35111 fail:
35112 {
35113 if (temp4)
35114 delete arg4;
35115 }
35116 return NULL;
35117 }
35118
35119
35120 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35121 PyObject *resultobj;
35122 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35123 size_t result;
35124 PyObject * obj0 = 0 ;
35125 char *kwnames[] = {
35126 (char *) "self", NULL
35127 };
35128
35129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35131 if (SWIG_arg_fail(1)) SWIG_fail;
35132 {
35133 PyThreadState* __tstate = wxPyBeginAllowThreads();
35134 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35135
35136 wxPyEndAllowThreads(__tstate);
35137 if (PyErr_Occurred()) SWIG_fail;
35138 }
35139 {
35140 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35141 }
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35149 PyObject *resultobj;
35150 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35151 size_t arg2 ;
35152 wxMenu *result;
35153 PyObject * obj0 = 0 ;
35154 PyObject * obj1 = 0 ;
35155 char *kwnames[] = {
35156 (char *) "self",(char *) "pos", NULL
35157 };
35158
35159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35161 if (SWIG_arg_fail(1)) SWIG_fail;
35162 {
35163 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35164 if (SWIG_arg_fail(2)) SWIG_fail;
35165 }
35166 {
35167 PyThreadState* __tstate = wxPyBeginAllowThreads();
35168 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35169
35170 wxPyEndAllowThreads(__tstate);
35171 if (PyErr_Occurred()) SWIG_fail;
35172 }
35173 {
35174 resultobj = wxPyMake_wxObject(result, 0);
35175 }
35176 return resultobj;
35177 fail:
35178 return NULL;
35179 }
35180
35181
35182 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35183 PyObject *resultobj;
35184 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35185 size_t arg2 ;
35186 wxMenu *arg3 = (wxMenu *) 0 ;
35187 wxString *arg4 = 0 ;
35188 wxMenu *result;
35189 bool temp4 = false ;
35190 PyObject * obj0 = 0 ;
35191 PyObject * obj1 = 0 ;
35192 PyObject * obj2 = 0 ;
35193 PyObject * obj3 = 0 ;
35194 char *kwnames[] = {
35195 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35196 };
35197
35198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35200 if (SWIG_arg_fail(1)) SWIG_fail;
35201 {
35202 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35203 if (SWIG_arg_fail(2)) SWIG_fail;
35204 }
35205 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35206 if (SWIG_arg_fail(3)) SWIG_fail;
35207 {
35208 arg4 = wxString_in_helper(obj3);
35209 if (arg4 == NULL) SWIG_fail;
35210 temp4 = true;
35211 }
35212 {
35213 PyThreadState* __tstate = wxPyBeginAllowThreads();
35214 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35215
35216 wxPyEndAllowThreads(__tstate);
35217 if (PyErr_Occurred()) SWIG_fail;
35218 }
35219 {
35220 resultobj = wxPyMake_wxObject(result, 0);
35221 }
35222 {
35223 if (temp4)
35224 delete arg4;
35225 }
35226 return resultobj;
35227 fail:
35228 {
35229 if (temp4)
35230 delete arg4;
35231 }
35232 return NULL;
35233 }
35234
35235
35236 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35237 PyObject *resultobj;
35238 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35239 size_t arg2 ;
35240 wxMenu *result;
35241 PyObject * obj0 = 0 ;
35242 PyObject * obj1 = 0 ;
35243 char *kwnames[] = {
35244 (char *) "self",(char *) "pos", NULL
35245 };
35246
35247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35249 if (SWIG_arg_fail(1)) SWIG_fail;
35250 {
35251 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35252 if (SWIG_arg_fail(2)) SWIG_fail;
35253 }
35254 {
35255 PyThreadState* __tstate = wxPyBeginAllowThreads();
35256 result = (wxMenu *)(arg1)->Remove(arg2);
35257
35258 wxPyEndAllowThreads(__tstate);
35259 if (PyErr_Occurred()) SWIG_fail;
35260 }
35261 {
35262 resultobj = wxPyMake_wxObject(result, 0);
35263 }
35264 return resultobj;
35265 fail:
35266 return NULL;
35267 }
35268
35269
35270 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35271 PyObject *resultobj;
35272 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35273 size_t arg2 ;
35274 bool arg3 ;
35275 PyObject * obj0 = 0 ;
35276 PyObject * obj1 = 0 ;
35277 PyObject * obj2 = 0 ;
35278 char *kwnames[] = {
35279 (char *) "self",(char *) "pos",(char *) "enable", NULL
35280 };
35281
35282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35284 if (SWIG_arg_fail(1)) SWIG_fail;
35285 {
35286 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35287 if (SWIG_arg_fail(2)) SWIG_fail;
35288 }
35289 {
35290 arg3 = (bool)(SWIG_As_bool(obj2));
35291 if (SWIG_arg_fail(3)) SWIG_fail;
35292 }
35293 {
35294 PyThreadState* __tstate = wxPyBeginAllowThreads();
35295 (arg1)->EnableTop(arg2,arg3);
35296
35297 wxPyEndAllowThreads(__tstate);
35298 if (PyErr_Occurred()) SWIG_fail;
35299 }
35300 Py_INCREF(Py_None); resultobj = Py_None;
35301 return resultobj;
35302 fail:
35303 return NULL;
35304 }
35305
35306
35307 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35308 PyObject *resultobj;
35309 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35310 size_t arg2 ;
35311 bool result;
35312 PyObject * obj0 = 0 ;
35313 PyObject * obj1 = 0 ;
35314 char *kwnames[] = {
35315 (char *) "self",(char *) "pos", NULL
35316 };
35317
35318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35320 if (SWIG_arg_fail(1)) SWIG_fail;
35321 {
35322 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35323 if (SWIG_arg_fail(2)) SWIG_fail;
35324 }
35325 {
35326 PyThreadState* __tstate = wxPyBeginAllowThreads();
35327 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35328
35329 wxPyEndAllowThreads(__tstate);
35330 if (PyErr_Occurred()) SWIG_fail;
35331 }
35332 {
35333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35334 }
35335 return resultobj;
35336 fail:
35337 return NULL;
35338 }
35339
35340
35341 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35342 PyObject *resultobj;
35343 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35344 size_t arg2 ;
35345 wxString *arg3 = 0 ;
35346 bool temp3 = false ;
35347 PyObject * obj0 = 0 ;
35348 PyObject * obj1 = 0 ;
35349 PyObject * obj2 = 0 ;
35350 char *kwnames[] = {
35351 (char *) "self",(char *) "pos",(char *) "label", NULL
35352 };
35353
35354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35356 if (SWIG_arg_fail(1)) SWIG_fail;
35357 {
35358 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35359 if (SWIG_arg_fail(2)) SWIG_fail;
35360 }
35361 {
35362 arg3 = wxString_in_helper(obj2);
35363 if (arg3 == NULL) SWIG_fail;
35364 temp3 = true;
35365 }
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35369
35370 wxPyEndAllowThreads(__tstate);
35371 if (PyErr_Occurred()) SWIG_fail;
35372 }
35373 Py_INCREF(Py_None); resultobj = Py_None;
35374 {
35375 if (temp3)
35376 delete arg3;
35377 }
35378 return resultobj;
35379 fail:
35380 {
35381 if (temp3)
35382 delete arg3;
35383 }
35384 return NULL;
35385 }
35386
35387
35388 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35389 PyObject *resultobj;
35390 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35391 size_t arg2 ;
35392 wxString result;
35393 PyObject * obj0 = 0 ;
35394 PyObject * obj1 = 0 ;
35395 char *kwnames[] = {
35396 (char *) "self",(char *) "pos", NULL
35397 };
35398
35399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35401 if (SWIG_arg_fail(1)) SWIG_fail;
35402 {
35403 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35404 if (SWIG_arg_fail(2)) SWIG_fail;
35405 }
35406 {
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35409
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 {
35414 #if wxUSE_UNICODE
35415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35416 #else
35417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35418 #endif
35419 }
35420 return resultobj;
35421 fail:
35422 return NULL;
35423 }
35424
35425
35426 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35427 PyObject *resultobj;
35428 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35429 wxString *arg2 = 0 ;
35430 wxString *arg3 = 0 ;
35431 int result;
35432 bool temp2 = false ;
35433 bool temp3 = false ;
35434 PyObject * obj0 = 0 ;
35435 PyObject * obj1 = 0 ;
35436 PyObject * obj2 = 0 ;
35437 char *kwnames[] = {
35438 (char *) "self",(char *) "menu",(char *) "item", NULL
35439 };
35440
35441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35443 if (SWIG_arg_fail(1)) SWIG_fail;
35444 {
35445 arg2 = wxString_in_helper(obj1);
35446 if (arg2 == NULL) SWIG_fail;
35447 temp2 = true;
35448 }
35449 {
35450 arg3 = wxString_in_helper(obj2);
35451 if (arg3 == NULL) SWIG_fail;
35452 temp3 = true;
35453 }
35454 {
35455 PyThreadState* __tstate = wxPyBeginAllowThreads();
35456 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35457
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 {
35462 resultobj = SWIG_From_int((int)(result));
35463 }
35464 {
35465 if (temp2)
35466 delete arg2;
35467 }
35468 {
35469 if (temp3)
35470 delete arg3;
35471 }
35472 return resultobj;
35473 fail:
35474 {
35475 if (temp2)
35476 delete arg2;
35477 }
35478 {
35479 if (temp3)
35480 delete arg3;
35481 }
35482 return NULL;
35483 }
35484
35485
35486 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35487 PyObject *resultobj;
35488 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35489 int arg2 ;
35490 wxMenuItem *result;
35491 PyObject * obj0 = 0 ;
35492 PyObject * obj1 = 0 ;
35493 char *kwnames[] = {
35494 (char *) "self",(char *) "id", NULL
35495 };
35496
35497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35499 if (SWIG_arg_fail(1)) SWIG_fail;
35500 {
35501 arg2 = (int)(SWIG_As_int(obj1));
35502 if (SWIG_arg_fail(2)) SWIG_fail;
35503 }
35504 {
35505 PyThreadState* __tstate = wxPyBeginAllowThreads();
35506 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35507
35508 wxPyEndAllowThreads(__tstate);
35509 if (PyErr_Occurred()) SWIG_fail;
35510 }
35511 {
35512 resultobj = wxPyMake_wxObject(result, 0);
35513 }
35514 return resultobj;
35515 fail:
35516 return NULL;
35517 }
35518
35519
35520 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35521 PyObject *resultobj;
35522 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35523 wxString *arg2 = 0 ;
35524 int result;
35525 bool temp2 = false ;
35526 PyObject * obj0 = 0 ;
35527 PyObject * obj1 = 0 ;
35528 char *kwnames[] = {
35529 (char *) "self",(char *) "title", NULL
35530 };
35531
35532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35534 if (SWIG_arg_fail(1)) SWIG_fail;
35535 {
35536 arg2 = wxString_in_helper(obj1);
35537 if (arg2 == NULL) SWIG_fail;
35538 temp2 = true;
35539 }
35540 {
35541 PyThreadState* __tstate = wxPyBeginAllowThreads();
35542 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
35543
35544 wxPyEndAllowThreads(__tstate);
35545 if (PyErr_Occurred()) SWIG_fail;
35546 }
35547 {
35548 resultobj = SWIG_From_int((int)(result));
35549 }
35550 {
35551 if (temp2)
35552 delete arg2;
35553 }
35554 return resultobj;
35555 fail:
35556 {
35557 if (temp2)
35558 delete arg2;
35559 }
35560 return NULL;
35561 }
35562
35563
35564 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35565 PyObject *resultobj;
35566 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35567 int arg2 ;
35568 bool arg3 ;
35569 PyObject * obj0 = 0 ;
35570 PyObject * obj1 = 0 ;
35571 PyObject * obj2 = 0 ;
35572 char *kwnames[] = {
35573 (char *) "self",(char *) "id",(char *) "enable", NULL
35574 };
35575
35576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35578 if (SWIG_arg_fail(1)) SWIG_fail;
35579 {
35580 arg2 = (int)(SWIG_As_int(obj1));
35581 if (SWIG_arg_fail(2)) SWIG_fail;
35582 }
35583 {
35584 arg3 = (bool)(SWIG_As_bool(obj2));
35585 if (SWIG_arg_fail(3)) SWIG_fail;
35586 }
35587 {
35588 PyThreadState* __tstate = wxPyBeginAllowThreads();
35589 (arg1)->Enable(arg2,arg3);
35590
35591 wxPyEndAllowThreads(__tstate);
35592 if (PyErr_Occurred()) SWIG_fail;
35593 }
35594 Py_INCREF(Py_None); resultobj = Py_None;
35595 return resultobj;
35596 fail:
35597 return NULL;
35598 }
35599
35600
35601 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35602 PyObject *resultobj;
35603 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35604 int arg2 ;
35605 bool arg3 ;
35606 PyObject * obj0 = 0 ;
35607 PyObject * obj1 = 0 ;
35608 PyObject * obj2 = 0 ;
35609 char *kwnames[] = {
35610 (char *) "self",(char *) "id",(char *) "check", NULL
35611 };
35612
35613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35615 if (SWIG_arg_fail(1)) SWIG_fail;
35616 {
35617 arg2 = (int)(SWIG_As_int(obj1));
35618 if (SWIG_arg_fail(2)) SWIG_fail;
35619 }
35620 {
35621 arg3 = (bool)(SWIG_As_bool(obj2));
35622 if (SWIG_arg_fail(3)) SWIG_fail;
35623 }
35624 {
35625 PyThreadState* __tstate = wxPyBeginAllowThreads();
35626 (arg1)->Check(arg2,arg3);
35627
35628 wxPyEndAllowThreads(__tstate);
35629 if (PyErr_Occurred()) SWIG_fail;
35630 }
35631 Py_INCREF(Py_None); resultobj = Py_None;
35632 return resultobj;
35633 fail:
35634 return NULL;
35635 }
35636
35637
35638 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35639 PyObject *resultobj;
35640 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35641 int arg2 ;
35642 bool result;
35643 PyObject * obj0 = 0 ;
35644 PyObject * obj1 = 0 ;
35645 char *kwnames[] = {
35646 (char *) "self",(char *) "id", NULL
35647 };
35648
35649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35651 if (SWIG_arg_fail(1)) SWIG_fail;
35652 {
35653 arg2 = (int)(SWIG_As_int(obj1));
35654 if (SWIG_arg_fail(2)) SWIG_fail;
35655 }
35656 {
35657 PyThreadState* __tstate = wxPyBeginAllowThreads();
35658 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35659
35660 wxPyEndAllowThreads(__tstate);
35661 if (PyErr_Occurred()) SWIG_fail;
35662 }
35663 {
35664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35665 }
35666 return resultobj;
35667 fail:
35668 return NULL;
35669 }
35670
35671
35672 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35673 PyObject *resultobj;
35674 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35675 int arg2 ;
35676 bool result;
35677 PyObject * obj0 = 0 ;
35678 PyObject * obj1 = 0 ;
35679 char *kwnames[] = {
35680 (char *) "self",(char *) "id", NULL
35681 };
35682
35683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35685 if (SWIG_arg_fail(1)) SWIG_fail;
35686 {
35687 arg2 = (int)(SWIG_As_int(obj1));
35688 if (SWIG_arg_fail(2)) SWIG_fail;
35689 }
35690 {
35691 PyThreadState* __tstate = wxPyBeginAllowThreads();
35692 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35693
35694 wxPyEndAllowThreads(__tstate);
35695 if (PyErr_Occurred()) SWIG_fail;
35696 }
35697 {
35698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35699 }
35700 return resultobj;
35701 fail:
35702 return NULL;
35703 }
35704
35705
35706 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35707 PyObject *resultobj;
35708 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35709 int arg2 ;
35710 wxString *arg3 = 0 ;
35711 bool temp3 = false ;
35712 PyObject * obj0 = 0 ;
35713 PyObject * obj1 = 0 ;
35714 PyObject * obj2 = 0 ;
35715 char *kwnames[] = {
35716 (char *) "self",(char *) "id",(char *) "label", NULL
35717 };
35718
35719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35721 if (SWIG_arg_fail(1)) SWIG_fail;
35722 {
35723 arg2 = (int)(SWIG_As_int(obj1));
35724 if (SWIG_arg_fail(2)) SWIG_fail;
35725 }
35726 {
35727 arg3 = wxString_in_helper(obj2);
35728 if (arg3 == NULL) SWIG_fail;
35729 temp3 = true;
35730 }
35731 {
35732 PyThreadState* __tstate = wxPyBeginAllowThreads();
35733 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35734
35735 wxPyEndAllowThreads(__tstate);
35736 if (PyErr_Occurred()) SWIG_fail;
35737 }
35738 Py_INCREF(Py_None); resultobj = Py_None;
35739 {
35740 if (temp3)
35741 delete arg3;
35742 }
35743 return resultobj;
35744 fail:
35745 {
35746 if (temp3)
35747 delete arg3;
35748 }
35749 return NULL;
35750 }
35751
35752
35753 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35754 PyObject *resultobj;
35755 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35756 int arg2 ;
35757 wxString result;
35758 PyObject * obj0 = 0 ;
35759 PyObject * obj1 = 0 ;
35760 char *kwnames[] = {
35761 (char *) "self",(char *) "id", NULL
35762 };
35763
35764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35766 if (SWIG_arg_fail(1)) SWIG_fail;
35767 {
35768 arg2 = (int)(SWIG_As_int(obj1));
35769 if (SWIG_arg_fail(2)) SWIG_fail;
35770 }
35771 {
35772 PyThreadState* __tstate = wxPyBeginAllowThreads();
35773 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35774
35775 wxPyEndAllowThreads(__tstate);
35776 if (PyErr_Occurred()) SWIG_fail;
35777 }
35778 {
35779 #if wxUSE_UNICODE
35780 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35781 #else
35782 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35783 #endif
35784 }
35785 return resultobj;
35786 fail:
35787 return NULL;
35788 }
35789
35790
35791 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35792 PyObject *resultobj;
35793 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35794 int arg2 ;
35795 wxString *arg3 = 0 ;
35796 bool temp3 = false ;
35797 PyObject * obj0 = 0 ;
35798 PyObject * obj1 = 0 ;
35799 PyObject * obj2 = 0 ;
35800 char *kwnames[] = {
35801 (char *) "self",(char *) "id",(char *) "helpString", NULL
35802 };
35803
35804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35806 if (SWIG_arg_fail(1)) SWIG_fail;
35807 {
35808 arg2 = (int)(SWIG_As_int(obj1));
35809 if (SWIG_arg_fail(2)) SWIG_fail;
35810 }
35811 {
35812 arg3 = wxString_in_helper(obj2);
35813 if (arg3 == NULL) SWIG_fail;
35814 temp3 = true;
35815 }
35816 {
35817 PyThreadState* __tstate = wxPyBeginAllowThreads();
35818 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35819
35820 wxPyEndAllowThreads(__tstate);
35821 if (PyErr_Occurred()) SWIG_fail;
35822 }
35823 Py_INCREF(Py_None); resultobj = Py_None;
35824 {
35825 if (temp3)
35826 delete arg3;
35827 }
35828 return resultobj;
35829 fail:
35830 {
35831 if (temp3)
35832 delete arg3;
35833 }
35834 return NULL;
35835 }
35836
35837
35838 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35839 PyObject *resultobj;
35840 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35841 int arg2 ;
35842 wxString result;
35843 PyObject * obj0 = 0 ;
35844 PyObject * obj1 = 0 ;
35845 char *kwnames[] = {
35846 (char *) "self",(char *) "id", NULL
35847 };
35848
35849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35851 if (SWIG_arg_fail(1)) SWIG_fail;
35852 {
35853 arg2 = (int)(SWIG_As_int(obj1));
35854 if (SWIG_arg_fail(2)) SWIG_fail;
35855 }
35856 {
35857 PyThreadState* __tstate = wxPyBeginAllowThreads();
35858 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35859
35860 wxPyEndAllowThreads(__tstate);
35861 if (PyErr_Occurred()) SWIG_fail;
35862 }
35863 {
35864 #if wxUSE_UNICODE
35865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35866 #else
35867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35868 #endif
35869 }
35870 return resultobj;
35871 fail:
35872 return NULL;
35873 }
35874
35875
35876 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35877 PyObject *resultobj;
35878 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35879 wxFrame *result;
35880 PyObject * obj0 = 0 ;
35881 char *kwnames[] = {
35882 (char *) "self", NULL
35883 };
35884
35885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35887 if (SWIG_arg_fail(1)) SWIG_fail;
35888 {
35889 PyThreadState* __tstate = wxPyBeginAllowThreads();
35890 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35891
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 {
35896 resultobj = wxPyMake_wxObject(result, 0);
35897 }
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35905 PyObject *resultobj;
35906 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35907 bool result;
35908 PyObject * obj0 = 0 ;
35909 char *kwnames[] = {
35910 (char *) "self", NULL
35911 };
35912
35913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35915 if (SWIG_arg_fail(1)) SWIG_fail;
35916 {
35917 PyThreadState* __tstate = wxPyBeginAllowThreads();
35918 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35919
35920 wxPyEndAllowThreads(__tstate);
35921 if (PyErr_Occurred()) SWIG_fail;
35922 }
35923 {
35924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35925 }
35926 return resultobj;
35927 fail:
35928 return NULL;
35929 }
35930
35931
35932 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35933 PyObject *resultobj;
35934 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35935 wxFrame *arg2 = (wxFrame *) 0 ;
35936 PyObject * obj0 = 0 ;
35937 PyObject * obj1 = 0 ;
35938 char *kwnames[] = {
35939 (char *) "self",(char *) "frame", NULL
35940 };
35941
35942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35944 if (SWIG_arg_fail(1)) SWIG_fail;
35945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35946 if (SWIG_arg_fail(2)) SWIG_fail;
35947 {
35948 PyThreadState* __tstate = wxPyBeginAllowThreads();
35949 (arg1)->Attach(arg2);
35950
35951 wxPyEndAllowThreads(__tstate);
35952 if (PyErr_Occurred()) SWIG_fail;
35953 }
35954 Py_INCREF(Py_None); resultobj = Py_None;
35955 return resultobj;
35956 fail:
35957 return NULL;
35958 }
35959
35960
35961 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35962 PyObject *resultobj;
35963 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35964 PyObject * obj0 = 0 ;
35965 char *kwnames[] = {
35966 (char *) "self", NULL
35967 };
35968
35969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35971 if (SWIG_arg_fail(1)) SWIG_fail;
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 (arg1)->Detach();
35975
35976 wxPyEndAllowThreads(__tstate);
35977 if (PyErr_Occurred()) SWIG_fail;
35978 }
35979 Py_INCREF(Py_None); resultobj = Py_None;
35980 return resultobj;
35981 fail:
35982 return NULL;
35983 }
35984
35985
35986 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35987 PyObject *obj;
35988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35989 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35990 Py_INCREF(obj);
35991 return Py_BuildValue((char *)"");
35992 }
35993 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35994 PyObject *resultobj;
35995 wxMenu *arg1 = (wxMenu *) NULL ;
35996 int arg2 = (int) wxID_ANY ;
35997 wxString const &arg3_defvalue = wxPyEmptyString ;
35998 wxString *arg3 = (wxString *) &arg3_defvalue ;
35999 wxString const &arg4_defvalue = wxPyEmptyString ;
36000 wxString *arg4 = (wxString *) &arg4_defvalue ;
36001 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36002 wxMenu *arg6 = (wxMenu *) NULL ;
36003 wxMenuItem *result;
36004 bool temp3 = false ;
36005 bool temp4 = false ;
36006 PyObject * obj0 = 0 ;
36007 PyObject * obj1 = 0 ;
36008 PyObject * obj2 = 0 ;
36009 PyObject * obj3 = 0 ;
36010 PyObject * obj4 = 0 ;
36011 PyObject * obj5 = 0 ;
36012 char *kwnames[] = {
36013 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36014 };
36015
36016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36017 if (obj0) {
36018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36019 if (SWIG_arg_fail(1)) SWIG_fail;
36020 }
36021 if (obj1) {
36022 {
36023 arg2 = (int)(SWIG_As_int(obj1));
36024 if (SWIG_arg_fail(2)) SWIG_fail;
36025 }
36026 }
36027 if (obj2) {
36028 {
36029 arg3 = wxString_in_helper(obj2);
36030 if (arg3 == NULL) SWIG_fail;
36031 temp3 = true;
36032 }
36033 }
36034 if (obj3) {
36035 {
36036 arg4 = wxString_in_helper(obj3);
36037 if (arg4 == NULL) SWIG_fail;
36038 temp4 = true;
36039 }
36040 }
36041 if (obj4) {
36042 {
36043 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36044 if (SWIG_arg_fail(5)) SWIG_fail;
36045 }
36046 }
36047 if (obj5) {
36048 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36049 if (SWIG_arg_fail(6)) SWIG_fail;
36050 }
36051 {
36052 PyThreadState* __tstate = wxPyBeginAllowThreads();
36053 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36054
36055 wxPyEndAllowThreads(__tstate);
36056 if (PyErr_Occurred()) SWIG_fail;
36057 }
36058 {
36059 resultobj = wxPyMake_wxObject(result, 1);
36060 }
36061 {
36062 if (temp3)
36063 delete arg3;
36064 }
36065 {
36066 if (temp4)
36067 delete arg4;
36068 }
36069 return resultobj;
36070 fail:
36071 {
36072 if (temp3)
36073 delete arg3;
36074 }
36075 {
36076 if (temp4)
36077 delete arg4;
36078 }
36079 return NULL;
36080 }
36081
36082
36083 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36084 PyObject *resultobj;
36085 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36086 wxMenu *result;
36087 PyObject * obj0 = 0 ;
36088 char *kwnames[] = {
36089 (char *) "self", NULL
36090 };
36091
36092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36094 if (SWIG_arg_fail(1)) SWIG_fail;
36095 {
36096 PyThreadState* __tstate = wxPyBeginAllowThreads();
36097 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36098
36099 wxPyEndAllowThreads(__tstate);
36100 if (PyErr_Occurred()) SWIG_fail;
36101 }
36102 {
36103 resultobj = wxPyMake_wxObject(result, 0);
36104 }
36105 return resultobj;
36106 fail:
36107 return NULL;
36108 }
36109
36110
36111 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36112 PyObject *resultobj;
36113 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36114 wxMenu *arg2 = (wxMenu *) 0 ;
36115 PyObject * obj0 = 0 ;
36116 PyObject * obj1 = 0 ;
36117 char *kwnames[] = {
36118 (char *) "self",(char *) "menu", NULL
36119 };
36120
36121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36123 if (SWIG_arg_fail(1)) SWIG_fail;
36124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36125 if (SWIG_arg_fail(2)) SWIG_fail;
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 (arg1)->SetMenu(arg2);
36129
36130 wxPyEndAllowThreads(__tstate);
36131 if (PyErr_Occurred()) SWIG_fail;
36132 }
36133 Py_INCREF(Py_None); resultobj = Py_None;
36134 return resultobj;
36135 fail:
36136 return NULL;
36137 }
36138
36139
36140 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36141 PyObject *resultobj;
36142 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36143 int arg2 ;
36144 PyObject * obj0 = 0 ;
36145 PyObject * obj1 = 0 ;
36146 char *kwnames[] = {
36147 (char *) "self",(char *) "id", NULL
36148 };
36149
36150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
36155 if (SWIG_arg_fail(2)) SWIG_fail;
36156 }
36157 {
36158 PyThreadState* __tstate = wxPyBeginAllowThreads();
36159 (arg1)->SetId(arg2);
36160
36161 wxPyEndAllowThreads(__tstate);
36162 if (PyErr_Occurred()) SWIG_fail;
36163 }
36164 Py_INCREF(Py_None); resultobj = Py_None;
36165 return resultobj;
36166 fail:
36167 return NULL;
36168 }
36169
36170
36171 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36172 PyObject *resultobj;
36173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36174 int result;
36175 PyObject * obj0 = 0 ;
36176 char *kwnames[] = {
36177 (char *) "self", NULL
36178 };
36179
36180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36182 if (SWIG_arg_fail(1)) SWIG_fail;
36183 {
36184 PyThreadState* __tstate = wxPyBeginAllowThreads();
36185 result = (int)((wxMenuItem const *)arg1)->GetId();
36186
36187 wxPyEndAllowThreads(__tstate);
36188 if (PyErr_Occurred()) SWIG_fail;
36189 }
36190 {
36191 resultobj = SWIG_From_int((int)(result));
36192 }
36193 return resultobj;
36194 fail:
36195 return NULL;
36196 }
36197
36198
36199 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36200 PyObject *resultobj;
36201 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36202 bool result;
36203 PyObject * obj0 = 0 ;
36204 char *kwnames[] = {
36205 (char *) "self", NULL
36206 };
36207
36208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36210 if (SWIG_arg_fail(1)) SWIG_fail;
36211 {
36212 PyThreadState* __tstate = wxPyBeginAllowThreads();
36213 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36214
36215 wxPyEndAllowThreads(__tstate);
36216 if (PyErr_Occurred()) SWIG_fail;
36217 }
36218 {
36219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36220 }
36221 return resultobj;
36222 fail:
36223 return NULL;
36224 }
36225
36226
36227 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36228 PyObject *resultobj;
36229 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36230 wxString *arg2 = 0 ;
36231 bool temp2 = false ;
36232 PyObject * obj0 = 0 ;
36233 PyObject * obj1 = 0 ;
36234 char *kwnames[] = {
36235 (char *) "self",(char *) "str", NULL
36236 };
36237
36238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36240 if (SWIG_arg_fail(1)) SWIG_fail;
36241 {
36242 arg2 = wxString_in_helper(obj1);
36243 if (arg2 == NULL) SWIG_fail;
36244 temp2 = true;
36245 }
36246 {
36247 PyThreadState* __tstate = wxPyBeginAllowThreads();
36248 (arg1)->SetText((wxString const &)*arg2);
36249
36250 wxPyEndAllowThreads(__tstate);
36251 if (PyErr_Occurred()) SWIG_fail;
36252 }
36253 Py_INCREF(Py_None); resultobj = Py_None;
36254 {
36255 if (temp2)
36256 delete arg2;
36257 }
36258 return resultobj;
36259 fail:
36260 {
36261 if (temp2)
36262 delete arg2;
36263 }
36264 return NULL;
36265 }
36266
36267
36268 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36269 PyObject *resultobj;
36270 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36271 wxString result;
36272 PyObject * obj0 = 0 ;
36273 char *kwnames[] = {
36274 (char *) "self", NULL
36275 };
36276
36277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36279 if (SWIG_arg_fail(1)) SWIG_fail;
36280 {
36281 PyThreadState* __tstate = wxPyBeginAllowThreads();
36282 result = ((wxMenuItem const *)arg1)->GetLabel();
36283
36284 wxPyEndAllowThreads(__tstate);
36285 if (PyErr_Occurred()) SWIG_fail;
36286 }
36287 {
36288 #if wxUSE_UNICODE
36289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36290 #else
36291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36292 #endif
36293 }
36294 return resultobj;
36295 fail:
36296 return NULL;
36297 }
36298
36299
36300 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36301 PyObject *resultobj;
36302 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36303 wxString *result;
36304 PyObject * obj0 = 0 ;
36305 char *kwnames[] = {
36306 (char *) "self", NULL
36307 };
36308
36309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36311 if (SWIG_arg_fail(1)) SWIG_fail;
36312 {
36313 PyThreadState* __tstate = wxPyBeginAllowThreads();
36314 {
36315 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36316 result = (wxString *) &_result_ref;
36317 }
36318
36319 wxPyEndAllowThreads(__tstate);
36320 if (PyErr_Occurred()) SWIG_fail;
36321 }
36322 {
36323 #if wxUSE_UNICODE
36324 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36325 #else
36326 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36327 #endif
36328 }
36329 return resultobj;
36330 fail:
36331 return NULL;
36332 }
36333
36334
36335 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36336 PyObject *resultobj;
36337 wxString *arg1 = 0 ;
36338 wxString result;
36339 bool temp1 = false ;
36340 PyObject * obj0 = 0 ;
36341 char *kwnames[] = {
36342 (char *) "text", NULL
36343 };
36344
36345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36346 {
36347 arg1 = wxString_in_helper(obj0);
36348 if (arg1 == NULL) SWIG_fail;
36349 temp1 = true;
36350 }
36351 {
36352 PyThreadState* __tstate = wxPyBeginAllowThreads();
36353 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36354
36355 wxPyEndAllowThreads(__tstate);
36356 if (PyErr_Occurred()) SWIG_fail;
36357 }
36358 {
36359 #if wxUSE_UNICODE
36360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36361 #else
36362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36363 #endif
36364 }
36365 {
36366 if (temp1)
36367 delete arg1;
36368 }
36369 return resultobj;
36370 fail:
36371 {
36372 if (temp1)
36373 delete arg1;
36374 }
36375 return NULL;
36376 }
36377
36378
36379 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36380 PyObject *resultobj;
36381 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36382 wxItemKind result;
36383 PyObject * obj0 = 0 ;
36384 char *kwnames[] = {
36385 (char *) "self", NULL
36386 };
36387
36388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36390 if (SWIG_arg_fail(1)) SWIG_fail;
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36394
36395 wxPyEndAllowThreads(__tstate);
36396 if (PyErr_Occurred()) SWIG_fail;
36397 }
36398 resultobj = SWIG_From_int((result));
36399 return resultobj;
36400 fail:
36401 return NULL;
36402 }
36403
36404
36405 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36406 PyObject *resultobj;
36407 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36408 wxItemKind arg2 ;
36409 PyObject * obj0 = 0 ;
36410 PyObject * obj1 = 0 ;
36411 char *kwnames[] = {
36412 (char *) "self",(char *) "kind", NULL
36413 };
36414
36415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36417 if (SWIG_arg_fail(1)) SWIG_fail;
36418 {
36419 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36420 if (SWIG_arg_fail(2)) SWIG_fail;
36421 }
36422 {
36423 PyThreadState* __tstate = wxPyBeginAllowThreads();
36424 (arg1)->SetKind((wxItemKind )arg2);
36425
36426 wxPyEndAllowThreads(__tstate);
36427 if (PyErr_Occurred()) SWIG_fail;
36428 }
36429 Py_INCREF(Py_None); resultobj = Py_None;
36430 return resultobj;
36431 fail:
36432 return NULL;
36433 }
36434
36435
36436 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36437 PyObject *resultobj;
36438 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36439 bool arg2 ;
36440 PyObject * obj0 = 0 ;
36441 PyObject * obj1 = 0 ;
36442 char *kwnames[] = {
36443 (char *) "self",(char *) "checkable", NULL
36444 };
36445
36446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36448 if (SWIG_arg_fail(1)) SWIG_fail;
36449 {
36450 arg2 = (bool)(SWIG_As_bool(obj1));
36451 if (SWIG_arg_fail(2)) SWIG_fail;
36452 }
36453 {
36454 PyThreadState* __tstate = wxPyBeginAllowThreads();
36455 (arg1)->SetCheckable(arg2);
36456
36457 wxPyEndAllowThreads(__tstate);
36458 if (PyErr_Occurred()) SWIG_fail;
36459 }
36460 Py_INCREF(Py_None); resultobj = Py_None;
36461 return resultobj;
36462 fail:
36463 return NULL;
36464 }
36465
36466
36467 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36468 PyObject *resultobj;
36469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36470 bool result;
36471 PyObject * obj0 = 0 ;
36472 char *kwnames[] = {
36473 (char *) "self", NULL
36474 };
36475
36476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36478 if (SWIG_arg_fail(1)) SWIG_fail;
36479 {
36480 PyThreadState* __tstate = wxPyBeginAllowThreads();
36481 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36482
36483 wxPyEndAllowThreads(__tstate);
36484 if (PyErr_Occurred()) SWIG_fail;
36485 }
36486 {
36487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36488 }
36489 return resultobj;
36490 fail:
36491 return NULL;
36492 }
36493
36494
36495 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36496 PyObject *resultobj;
36497 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36498 bool result;
36499 PyObject * obj0 = 0 ;
36500 char *kwnames[] = {
36501 (char *) "self", NULL
36502 };
36503
36504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36506 if (SWIG_arg_fail(1)) SWIG_fail;
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36510
36511 wxPyEndAllowThreads(__tstate);
36512 if (PyErr_Occurred()) SWIG_fail;
36513 }
36514 {
36515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36516 }
36517 return resultobj;
36518 fail:
36519 return NULL;
36520 }
36521
36522
36523 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36524 PyObject *resultobj;
36525 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36526 wxMenu *arg2 = (wxMenu *) 0 ;
36527 PyObject * obj0 = 0 ;
36528 PyObject * obj1 = 0 ;
36529 char *kwnames[] = {
36530 (char *) "self",(char *) "menu", NULL
36531 };
36532
36533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36535 if (SWIG_arg_fail(1)) SWIG_fail;
36536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36537 if (SWIG_arg_fail(2)) SWIG_fail;
36538 {
36539 PyThreadState* __tstate = wxPyBeginAllowThreads();
36540 (arg1)->SetSubMenu(arg2);
36541
36542 wxPyEndAllowThreads(__tstate);
36543 if (PyErr_Occurred()) SWIG_fail;
36544 }
36545 Py_INCREF(Py_None); resultobj = Py_None;
36546 return resultobj;
36547 fail:
36548 return NULL;
36549 }
36550
36551
36552 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36553 PyObject *resultobj;
36554 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36555 wxMenu *result;
36556 PyObject * obj0 = 0 ;
36557 char *kwnames[] = {
36558 (char *) "self", NULL
36559 };
36560
36561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36563 if (SWIG_arg_fail(1)) SWIG_fail;
36564 {
36565 PyThreadState* __tstate = wxPyBeginAllowThreads();
36566 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36567
36568 wxPyEndAllowThreads(__tstate);
36569 if (PyErr_Occurred()) SWIG_fail;
36570 }
36571 {
36572 resultobj = wxPyMake_wxObject(result, 0);
36573 }
36574 return resultobj;
36575 fail:
36576 return NULL;
36577 }
36578
36579
36580 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36581 PyObject *resultobj;
36582 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36583 bool arg2 = (bool) true ;
36584 PyObject * obj0 = 0 ;
36585 PyObject * obj1 = 0 ;
36586 char *kwnames[] = {
36587 (char *) "self",(char *) "enable", NULL
36588 };
36589
36590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36592 if (SWIG_arg_fail(1)) SWIG_fail;
36593 if (obj1) {
36594 {
36595 arg2 = (bool)(SWIG_As_bool(obj1));
36596 if (SWIG_arg_fail(2)) SWIG_fail;
36597 }
36598 }
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 (arg1)->Enable(arg2);
36602
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 Py_INCREF(Py_None); resultobj = Py_None;
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36614 PyObject *resultobj;
36615 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36616 bool result;
36617 PyObject * obj0 = 0 ;
36618 char *kwnames[] = {
36619 (char *) "self", NULL
36620 };
36621
36622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36624 if (SWIG_arg_fail(1)) SWIG_fail;
36625 {
36626 PyThreadState* __tstate = wxPyBeginAllowThreads();
36627 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36628
36629 wxPyEndAllowThreads(__tstate);
36630 if (PyErr_Occurred()) SWIG_fail;
36631 }
36632 {
36633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36634 }
36635 return resultobj;
36636 fail:
36637 return NULL;
36638 }
36639
36640
36641 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36642 PyObject *resultobj;
36643 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36644 bool arg2 = (bool) true ;
36645 PyObject * obj0 = 0 ;
36646 PyObject * obj1 = 0 ;
36647 char *kwnames[] = {
36648 (char *) "self",(char *) "check", NULL
36649 };
36650
36651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36653 if (SWIG_arg_fail(1)) SWIG_fail;
36654 if (obj1) {
36655 {
36656 arg2 = (bool)(SWIG_As_bool(obj1));
36657 if (SWIG_arg_fail(2)) SWIG_fail;
36658 }
36659 }
36660 {
36661 PyThreadState* __tstate = wxPyBeginAllowThreads();
36662 (arg1)->Check(arg2);
36663
36664 wxPyEndAllowThreads(__tstate);
36665 if (PyErr_Occurred()) SWIG_fail;
36666 }
36667 Py_INCREF(Py_None); resultobj = Py_None;
36668 return resultobj;
36669 fail:
36670 return NULL;
36671 }
36672
36673
36674 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36675 PyObject *resultobj;
36676 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36677 bool result;
36678 PyObject * obj0 = 0 ;
36679 char *kwnames[] = {
36680 (char *) "self", NULL
36681 };
36682
36683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36685 if (SWIG_arg_fail(1)) SWIG_fail;
36686 {
36687 PyThreadState* __tstate = wxPyBeginAllowThreads();
36688 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36689
36690 wxPyEndAllowThreads(__tstate);
36691 if (PyErr_Occurred()) SWIG_fail;
36692 }
36693 {
36694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36695 }
36696 return resultobj;
36697 fail:
36698 return NULL;
36699 }
36700
36701
36702 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36703 PyObject *resultobj;
36704 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36705 PyObject * obj0 = 0 ;
36706 char *kwnames[] = {
36707 (char *) "self", NULL
36708 };
36709
36710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36712 if (SWIG_arg_fail(1)) SWIG_fail;
36713 {
36714 PyThreadState* __tstate = wxPyBeginAllowThreads();
36715 (arg1)->Toggle();
36716
36717 wxPyEndAllowThreads(__tstate);
36718 if (PyErr_Occurred()) SWIG_fail;
36719 }
36720 Py_INCREF(Py_None); resultobj = Py_None;
36721 return resultobj;
36722 fail:
36723 return NULL;
36724 }
36725
36726
36727 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36728 PyObject *resultobj;
36729 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36730 wxString *arg2 = 0 ;
36731 bool temp2 = false ;
36732 PyObject * obj0 = 0 ;
36733 PyObject * obj1 = 0 ;
36734 char *kwnames[] = {
36735 (char *) "self",(char *) "str", NULL
36736 };
36737
36738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36740 if (SWIG_arg_fail(1)) SWIG_fail;
36741 {
36742 arg2 = wxString_in_helper(obj1);
36743 if (arg2 == NULL) SWIG_fail;
36744 temp2 = true;
36745 }
36746 {
36747 PyThreadState* __tstate = wxPyBeginAllowThreads();
36748 (arg1)->SetHelp((wxString const &)*arg2);
36749
36750 wxPyEndAllowThreads(__tstate);
36751 if (PyErr_Occurred()) SWIG_fail;
36752 }
36753 Py_INCREF(Py_None); resultobj = Py_None;
36754 {
36755 if (temp2)
36756 delete arg2;
36757 }
36758 return resultobj;
36759 fail:
36760 {
36761 if (temp2)
36762 delete arg2;
36763 }
36764 return NULL;
36765 }
36766
36767
36768 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36769 PyObject *resultobj;
36770 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36771 wxString *result;
36772 PyObject * obj0 = 0 ;
36773 char *kwnames[] = {
36774 (char *) "self", NULL
36775 };
36776
36777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36779 if (SWIG_arg_fail(1)) SWIG_fail;
36780 {
36781 PyThreadState* __tstate = wxPyBeginAllowThreads();
36782 {
36783 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36784 result = (wxString *) &_result_ref;
36785 }
36786
36787 wxPyEndAllowThreads(__tstate);
36788 if (PyErr_Occurred()) SWIG_fail;
36789 }
36790 {
36791 #if wxUSE_UNICODE
36792 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36793 #else
36794 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36795 #endif
36796 }
36797 return resultobj;
36798 fail:
36799 return NULL;
36800 }
36801
36802
36803 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36804 PyObject *resultobj;
36805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36806 wxAcceleratorEntry *result;
36807 PyObject * obj0 = 0 ;
36808 char *kwnames[] = {
36809 (char *) "self", NULL
36810 };
36811
36812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36814 if (SWIG_arg_fail(1)) SWIG_fail;
36815 {
36816 PyThreadState* __tstate = wxPyBeginAllowThreads();
36817 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36818
36819 wxPyEndAllowThreads(__tstate);
36820 if (PyErr_Occurred()) SWIG_fail;
36821 }
36822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36823 return resultobj;
36824 fail:
36825 return NULL;
36826 }
36827
36828
36829 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36830 PyObject *resultobj;
36831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36832 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36833 PyObject * obj0 = 0 ;
36834 PyObject * obj1 = 0 ;
36835 char *kwnames[] = {
36836 (char *) "self",(char *) "accel", NULL
36837 };
36838
36839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36841 if (SWIG_arg_fail(1)) SWIG_fail;
36842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36843 if (SWIG_arg_fail(2)) SWIG_fail;
36844 {
36845 PyThreadState* __tstate = wxPyBeginAllowThreads();
36846 (arg1)->SetAccel(arg2);
36847
36848 wxPyEndAllowThreads(__tstate);
36849 if (PyErr_Occurred()) SWIG_fail;
36850 }
36851 Py_INCREF(Py_None); resultobj = Py_None;
36852 return resultobj;
36853 fail:
36854 return NULL;
36855 }
36856
36857
36858 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36859 PyObject *resultobj;
36860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36861 wxFont *arg2 = 0 ;
36862 PyObject * obj0 = 0 ;
36863 PyObject * obj1 = 0 ;
36864 char *kwnames[] = {
36865 (char *) "self",(char *) "font", NULL
36866 };
36867
36868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36870 if (SWIG_arg_fail(1)) SWIG_fail;
36871 {
36872 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36873 if (SWIG_arg_fail(2)) SWIG_fail;
36874 if (arg2 == NULL) {
36875 SWIG_null_ref("wxFont");
36876 }
36877 if (SWIG_arg_fail(2)) SWIG_fail;
36878 }
36879 {
36880 PyThreadState* __tstate = wxPyBeginAllowThreads();
36881 (arg1)->SetFont((wxFont const &)*arg2);
36882
36883 wxPyEndAllowThreads(__tstate);
36884 if (PyErr_Occurred()) SWIG_fail;
36885 }
36886 Py_INCREF(Py_None); resultobj = Py_None;
36887 return resultobj;
36888 fail:
36889 return NULL;
36890 }
36891
36892
36893 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36894 PyObject *resultobj;
36895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36896 wxFont result;
36897 PyObject * obj0 = 0 ;
36898 char *kwnames[] = {
36899 (char *) "self", NULL
36900 };
36901
36902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36904 if (SWIG_arg_fail(1)) SWIG_fail;
36905 {
36906 PyThreadState* __tstate = wxPyBeginAllowThreads();
36907 result = (arg1)->GetFont();
36908
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 {
36913 wxFont * resultptr;
36914 resultptr = new wxFont((wxFont &)(result));
36915 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36916 }
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36924 PyObject *resultobj;
36925 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36926 wxColour *arg2 = 0 ;
36927 wxColour temp2 ;
36928 PyObject * obj0 = 0 ;
36929 PyObject * obj1 = 0 ;
36930 char *kwnames[] = {
36931 (char *) "self",(char *) "colText", NULL
36932 };
36933
36934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36936 if (SWIG_arg_fail(1)) SWIG_fail;
36937 {
36938 arg2 = &temp2;
36939 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36940 }
36941 {
36942 PyThreadState* __tstate = wxPyBeginAllowThreads();
36943 (arg1)->SetTextColour((wxColour const &)*arg2);
36944
36945 wxPyEndAllowThreads(__tstate);
36946 if (PyErr_Occurred()) SWIG_fail;
36947 }
36948 Py_INCREF(Py_None); resultobj = Py_None;
36949 return resultobj;
36950 fail:
36951 return NULL;
36952 }
36953
36954
36955 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36956 PyObject *resultobj;
36957 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36958 wxColour result;
36959 PyObject * obj0 = 0 ;
36960 char *kwnames[] = {
36961 (char *) "self", NULL
36962 };
36963
36964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36966 if (SWIG_arg_fail(1)) SWIG_fail;
36967 {
36968 PyThreadState* __tstate = wxPyBeginAllowThreads();
36969 result = (arg1)->GetTextColour();
36970
36971 wxPyEndAllowThreads(__tstate);
36972 if (PyErr_Occurred()) SWIG_fail;
36973 }
36974 {
36975 wxColour * resultptr;
36976 resultptr = new wxColour((wxColour &)(result));
36977 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36978 }
36979 return resultobj;
36980 fail:
36981 return NULL;
36982 }
36983
36984
36985 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36986 PyObject *resultobj;
36987 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36988 wxColour *arg2 = 0 ;
36989 wxColour temp2 ;
36990 PyObject * obj0 = 0 ;
36991 PyObject * obj1 = 0 ;
36992 char *kwnames[] = {
36993 (char *) "self",(char *) "colBack", NULL
36994 };
36995
36996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36998 if (SWIG_arg_fail(1)) SWIG_fail;
36999 {
37000 arg2 = &temp2;
37001 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37002 }
37003 {
37004 PyThreadState* __tstate = wxPyBeginAllowThreads();
37005 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
37006
37007 wxPyEndAllowThreads(__tstate);
37008 if (PyErr_Occurred()) SWIG_fail;
37009 }
37010 Py_INCREF(Py_None); resultobj = Py_None;
37011 return resultobj;
37012 fail:
37013 return NULL;
37014 }
37015
37016
37017 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37018 PyObject *resultobj;
37019 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37020 wxColour result;
37021 PyObject * obj0 = 0 ;
37022 char *kwnames[] = {
37023 (char *) "self", NULL
37024 };
37025
37026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37028 if (SWIG_arg_fail(1)) SWIG_fail;
37029 {
37030 PyThreadState* __tstate = wxPyBeginAllowThreads();
37031 result = (arg1)->GetBackgroundColour();
37032
37033 wxPyEndAllowThreads(__tstate);
37034 if (PyErr_Occurred()) SWIG_fail;
37035 }
37036 {
37037 wxColour * resultptr;
37038 resultptr = new wxColour((wxColour &)(result));
37039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37040 }
37041 return resultobj;
37042 fail:
37043 return NULL;
37044 }
37045
37046
37047 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37048 PyObject *resultobj;
37049 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37050 wxBitmap *arg2 = 0 ;
37051 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37052 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37053 PyObject * obj0 = 0 ;
37054 PyObject * obj1 = 0 ;
37055 PyObject * obj2 = 0 ;
37056 char *kwnames[] = {
37057 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37058 };
37059
37060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37062 if (SWIG_arg_fail(1)) SWIG_fail;
37063 {
37064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37065 if (SWIG_arg_fail(2)) SWIG_fail;
37066 if (arg2 == NULL) {
37067 SWIG_null_ref("wxBitmap");
37068 }
37069 if (SWIG_arg_fail(2)) SWIG_fail;
37070 }
37071 if (obj2) {
37072 {
37073 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37074 if (SWIG_arg_fail(3)) SWIG_fail;
37075 if (arg3 == NULL) {
37076 SWIG_null_ref("wxBitmap");
37077 }
37078 if (SWIG_arg_fail(3)) SWIG_fail;
37079 }
37080 }
37081 {
37082 PyThreadState* __tstate = wxPyBeginAllowThreads();
37083 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37084
37085 wxPyEndAllowThreads(__tstate);
37086 if (PyErr_Occurred()) SWIG_fail;
37087 }
37088 Py_INCREF(Py_None); resultobj = Py_None;
37089 return resultobj;
37090 fail:
37091 return NULL;
37092 }
37093
37094
37095 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37096 PyObject *resultobj;
37097 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37098 wxBitmap *arg2 = 0 ;
37099 PyObject * obj0 = 0 ;
37100 PyObject * obj1 = 0 ;
37101 char *kwnames[] = {
37102 (char *) "self",(char *) "bmpDisabled", NULL
37103 };
37104
37105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37107 if (SWIG_arg_fail(1)) SWIG_fail;
37108 {
37109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37110 if (SWIG_arg_fail(2)) SWIG_fail;
37111 if (arg2 == NULL) {
37112 SWIG_null_ref("wxBitmap");
37113 }
37114 if (SWIG_arg_fail(2)) SWIG_fail;
37115 }
37116 {
37117 PyThreadState* __tstate = wxPyBeginAllowThreads();
37118 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
37119
37120 wxPyEndAllowThreads(__tstate);
37121 if (PyErr_Occurred()) SWIG_fail;
37122 }
37123 Py_INCREF(Py_None); resultobj = Py_None;
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj;
37132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37133 wxBitmap *result;
37134 PyObject * obj0 = 0 ;
37135 char *kwnames[] = {
37136 (char *) "self", NULL
37137 };
37138
37139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37141 if (SWIG_arg_fail(1)) SWIG_fail;
37142 {
37143 PyThreadState* __tstate = wxPyBeginAllowThreads();
37144 {
37145 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
37146 result = (wxBitmap *) &_result_ref;
37147 }
37148
37149 wxPyEndAllowThreads(__tstate);
37150 if (PyErr_Occurred()) SWIG_fail;
37151 }
37152 {
37153 wxBitmap* resultptr = new wxBitmap(*result);
37154 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37155 }
37156 return resultobj;
37157 fail:
37158 return NULL;
37159 }
37160
37161
37162 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37163 PyObject *resultobj;
37164 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37165 int arg2 ;
37166 PyObject * obj0 = 0 ;
37167 PyObject * obj1 = 0 ;
37168 char *kwnames[] = {
37169 (char *) "self",(char *) "nWidth", NULL
37170 };
37171
37172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37174 if (SWIG_arg_fail(1)) SWIG_fail;
37175 {
37176 arg2 = (int)(SWIG_As_int(obj1));
37177 if (SWIG_arg_fail(2)) SWIG_fail;
37178 }
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 (arg1)->SetMarginWidth(arg2);
37182
37183 wxPyEndAllowThreads(__tstate);
37184 if (PyErr_Occurred()) SWIG_fail;
37185 }
37186 Py_INCREF(Py_None); resultobj = Py_None;
37187 return resultobj;
37188 fail:
37189 return NULL;
37190 }
37191
37192
37193 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37194 PyObject *resultobj;
37195 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37196 int result;
37197 PyObject * obj0 = 0 ;
37198 char *kwnames[] = {
37199 (char *) "self", NULL
37200 };
37201
37202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37204 if (SWIG_arg_fail(1)) SWIG_fail;
37205 {
37206 PyThreadState* __tstate = wxPyBeginAllowThreads();
37207 result = (int)(arg1)->GetMarginWidth();
37208
37209 wxPyEndAllowThreads(__tstate);
37210 if (PyErr_Occurred()) SWIG_fail;
37211 }
37212 {
37213 resultobj = SWIG_From_int((int)(result));
37214 }
37215 return resultobj;
37216 fail:
37217 return NULL;
37218 }
37219
37220
37221 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37222 PyObject *resultobj;
37223 int result;
37224 char *kwnames[] = {
37225 NULL
37226 };
37227
37228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37229 {
37230 PyThreadState* __tstate = wxPyBeginAllowThreads();
37231 result = (int)wxMenuItem::GetDefaultMarginWidth();
37232
37233 wxPyEndAllowThreads(__tstate);
37234 if (PyErr_Occurred()) SWIG_fail;
37235 }
37236 {
37237 resultobj = SWIG_From_int((int)(result));
37238 }
37239 return resultobj;
37240 fail:
37241 return NULL;
37242 }
37243
37244
37245 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37246 PyObject *resultobj;
37247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37248 bool result;
37249 PyObject * obj0 = 0 ;
37250 char *kwnames[] = {
37251 (char *) "self", NULL
37252 };
37253
37254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37256 if (SWIG_arg_fail(1)) SWIG_fail;
37257 {
37258 PyThreadState* __tstate = wxPyBeginAllowThreads();
37259 result = (bool)(arg1)->IsOwnerDrawn();
37260
37261 wxPyEndAllowThreads(__tstate);
37262 if (PyErr_Occurred()) SWIG_fail;
37263 }
37264 {
37265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37266 }
37267 return resultobj;
37268 fail:
37269 return NULL;
37270 }
37271
37272
37273 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37274 PyObject *resultobj;
37275 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37276 bool arg2 = (bool) true ;
37277 PyObject * obj0 = 0 ;
37278 PyObject * obj1 = 0 ;
37279 char *kwnames[] = {
37280 (char *) "self",(char *) "ownerDrawn", NULL
37281 };
37282
37283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37285 if (SWIG_arg_fail(1)) SWIG_fail;
37286 if (obj1) {
37287 {
37288 arg2 = (bool)(SWIG_As_bool(obj1));
37289 if (SWIG_arg_fail(2)) SWIG_fail;
37290 }
37291 }
37292 {
37293 PyThreadState* __tstate = wxPyBeginAllowThreads();
37294 (arg1)->SetOwnerDrawn(arg2);
37295
37296 wxPyEndAllowThreads(__tstate);
37297 if (PyErr_Occurred()) SWIG_fail;
37298 }
37299 Py_INCREF(Py_None); resultobj = Py_None;
37300 return resultobj;
37301 fail:
37302 return NULL;
37303 }
37304
37305
37306 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37307 PyObject *resultobj;
37308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37309 PyObject * obj0 = 0 ;
37310 char *kwnames[] = {
37311 (char *) "self", NULL
37312 };
37313
37314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37316 if (SWIG_arg_fail(1)) SWIG_fail;
37317 {
37318 PyThreadState* __tstate = wxPyBeginAllowThreads();
37319 (arg1)->ResetOwnerDrawn();
37320
37321 wxPyEndAllowThreads(__tstate);
37322 if (PyErr_Occurred()) SWIG_fail;
37323 }
37324 Py_INCREF(Py_None); resultobj = Py_None;
37325 return resultobj;
37326 fail:
37327 return NULL;
37328 }
37329
37330
37331 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37332 PyObject *resultobj;
37333 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37334 wxBitmap *arg2 = 0 ;
37335 PyObject * obj0 = 0 ;
37336 PyObject * obj1 = 0 ;
37337 char *kwnames[] = {
37338 (char *) "self",(char *) "bitmap", NULL
37339 };
37340
37341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37343 if (SWIG_arg_fail(1)) SWIG_fail;
37344 {
37345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37346 if (SWIG_arg_fail(2)) SWIG_fail;
37347 if (arg2 == NULL) {
37348 SWIG_null_ref("wxBitmap");
37349 }
37350 if (SWIG_arg_fail(2)) SWIG_fail;
37351 }
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37355
37356 wxPyEndAllowThreads(__tstate);
37357 if (PyErr_Occurred()) SWIG_fail;
37358 }
37359 Py_INCREF(Py_None); resultobj = Py_None;
37360 return resultobj;
37361 fail:
37362 return NULL;
37363 }
37364
37365
37366 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37367 PyObject *resultobj;
37368 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37369 wxBitmap *result;
37370 PyObject * obj0 = 0 ;
37371 char *kwnames[] = {
37372 (char *) "self", NULL
37373 };
37374
37375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37377 if (SWIG_arg_fail(1)) SWIG_fail;
37378 {
37379 PyThreadState* __tstate = wxPyBeginAllowThreads();
37380 {
37381 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37382 result = (wxBitmap *) &_result_ref;
37383 }
37384
37385 wxPyEndAllowThreads(__tstate);
37386 if (PyErr_Occurred()) SWIG_fail;
37387 }
37388 {
37389 wxBitmap* resultptr = new wxBitmap(*result);
37390 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37391 }
37392 return resultobj;
37393 fail:
37394 return NULL;
37395 }
37396
37397
37398 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37399 PyObject *obj;
37400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37401 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37402 Py_INCREF(obj);
37403 return Py_BuildValue((char *)"");
37404 }
37405 static int _wrap_ControlNameStr_set(PyObject *) {
37406 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37407 return 1;
37408 }
37409
37410
37411 static PyObject *_wrap_ControlNameStr_get(void) {
37412 PyObject *pyobj;
37413
37414 {
37415 #if wxUSE_UNICODE
37416 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37417 #else
37418 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37419 #endif
37420 }
37421 return pyobj;
37422 }
37423
37424
37425 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37426 PyObject *resultobj;
37427 wxWindow *arg1 = (wxWindow *) 0 ;
37428 int arg2 = (int) -1 ;
37429 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37430 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37431 wxSize const &arg4_defvalue = wxDefaultSize ;
37432 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37433 long arg5 = (long) 0 ;
37434 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37435 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37436 wxString const &arg7_defvalue = wxPyControlNameStr ;
37437 wxString *arg7 = (wxString *) &arg7_defvalue ;
37438 wxControl *result;
37439 wxPoint temp3 ;
37440 wxSize temp4 ;
37441 bool temp7 = false ;
37442 PyObject * obj0 = 0 ;
37443 PyObject * obj1 = 0 ;
37444 PyObject * obj2 = 0 ;
37445 PyObject * obj3 = 0 ;
37446 PyObject * obj4 = 0 ;
37447 PyObject * obj5 = 0 ;
37448 PyObject * obj6 = 0 ;
37449 char *kwnames[] = {
37450 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37451 };
37452
37453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37455 if (SWIG_arg_fail(1)) SWIG_fail;
37456 if (obj1) {
37457 {
37458 arg2 = (int)(SWIG_As_int(obj1));
37459 if (SWIG_arg_fail(2)) SWIG_fail;
37460 }
37461 }
37462 if (obj2) {
37463 {
37464 arg3 = &temp3;
37465 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37466 }
37467 }
37468 if (obj3) {
37469 {
37470 arg4 = &temp4;
37471 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37472 }
37473 }
37474 if (obj4) {
37475 {
37476 arg5 = (long)(SWIG_As_long(obj4));
37477 if (SWIG_arg_fail(5)) SWIG_fail;
37478 }
37479 }
37480 if (obj5) {
37481 {
37482 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37483 if (SWIG_arg_fail(6)) SWIG_fail;
37484 if (arg6 == NULL) {
37485 SWIG_null_ref("wxValidator");
37486 }
37487 if (SWIG_arg_fail(6)) SWIG_fail;
37488 }
37489 }
37490 if (obj6) {
37491 {
37492 arg7 = wxString_in_helper(obj6);
37493 if (arg7 == NULL) SWIG_fail;
37494 temp7 = true;
37495 }
37496 }
37497 {
37498 if (!wxPyCheckForApp()) SWIG_fail;
37499 PyThreadState* __tstate = wxPyBeginAllowThreads();
37500 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37501
37502 wxPyEndAllowThreads(__tstate);
37503 if (PyErr_Occurred()) SWIG_fail;
37504 }
37505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37506 {
37507 if (temp7)
37508 delete arg7;
37509 }
37510 return resultobj;
37511 fail:
37512 {
37513 if (temp7)
37514 delete arg7;
37515 }
37516 return NULL;
37517 }
37518
37519
37520 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37521 PyObject *resultobj;
37522 wxControl *result;
37523 char *kwnames[] = {
37524 NULL
37525 };
37526
37527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37528 {
37529 if (!wxPyCheckForApp()) SWIG_fail;
37530 PyThreadState* __tstate = wxPyBeginAllowThreads();
37531 result = (wxControl *)new wxControl();
37532
37533 wxPyEndAllowThreads(__tstate);
37534 if (PyErr_Occurred()) SWIG_fail;
37535 }
37536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37537 return resultobj;
37538 fail:
37539 return NULL;
37540 }
37541
37542
37543 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37544 PyObject *resultobj;
37545 wxControl *arg1 = (wxControl *) 0 ;
37546 wxWindow *arg2 = (wxWindow *) 0 ;
37547 int arg3 = (int) -1 ;
37548 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37549 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37550 wxSize const &arg5_defvalue = wxDefaultSize ;
37551 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37552 long arg6 = (long) 0 ;
37553 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37554 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37555 wxString const &arg8_defvalue = wxPyControlNameStr ;
37556 wxString *arg8 = (wxString *) &arg8_defvalue ;
37557 bool result;
37558 wxPoint temp4 ;
37559 wxSize temp5 ;
37560 bool temp8 = false ;
37561 PyObject * obj0 = 0 ;
37562 PyObject * obj1 = 0 ;
37563 PyObject * obj2 = 0 ;
37564 PyObject * obj3 = 0 ;
37565 PyObject * obj4 = 0 ;
37566 PyObject * obj5 = 0 ;
37567 PyObject * obj6 = 0 ;
37568 PyObject * obj7 = 0 ;
37569 char *kwnames[] = {
37570 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37571 };
37572
37573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37575 if (SWIG_arg_fail(1)) SWIG_fail;
37576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37577 if (SWIG_arg_fail(2)) SWIG_fail;
37578 if (obj2) {
37579 {
37580 arg3 = (int)(SWIG_As_int(obj2));
37581 if (SWIG_arg_fail(3)) SWIG_fail;
37582 }
37583 }
37584 if (obj3) {
37585 {
37586 arg4 = &temp4;
37587 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37588 }
37589 }
37590 if (obj4) {
37591 {
37592 arg5 = &temp5;
37593 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37594 }
37595 }
37596 if (obj5) {
37597 {
37598 arg6 = (long)(SWIG_As_long(obj5));
37599 if (SWIG_arg_fail(6)) SWIG_fail;
37600 }
37601 }
37602 if (obj6) {
37603 {
37604 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37605 if (SWIG_arg_fail(7)) SWIG_fail;
37606 if (arg7 == NULL) {
37607 SWIG_null_ref("wxValidator");
37608 }
37609 if (SWIG_arg_fail(7)) SWIG_fail;
37610 }
37611 }
37612 if (obj7) {
37613 {
37614 arg8 = wxString_in_helper(obj7);
37615 if (arg8 == NULL) SWIG_fail;
37616 temp8 = true;
37617 }
37618 }
37619 {
37620 PyThreadState* __tstate = wxPyBeginAllowThreads();
37621 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37622
37623 wxPyEndAllowThreads(__tstate);
37624 if (PyErr_Occurred()) SWIG_fail;
37625 }
37626 {
37627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37628 }
37629 {
37630 if (temp8)
37631 delete arg8;
37632 }
37633 return resultobj;
37634 fail:
37635 {
37636 if (temp8)
37637 delete arg8;
37638 }
37639 return NULL;
37640 }
37641
37642
37643 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37644 PyObject *resultobj;
37645 wxControl *arg1 = (wxControl *) 0 ;
37646 wxCommandEvent *arg2 = 0 ;
37647 PyObject * obj0 = 0 ;
37648 PyObject * obj1 = 0 ;
37649 char *kwnames[] = {
37650 (char *) "self",(char *) "event", NULL
37651 };
37652
37653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37655 if (SWIG_arg_fail(1)) SWIG_fail;
37656 {
37657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37658 if (SWIG_arg_fail(2)) SWIG_fail;
37659 if (arg2 == NULL) {
37660 SWIG_null_ref("wxCommandEvent");
37661 }
37662 if (SWIG_arg_fail(2)) SWIG_fail;
37663 }
37664 {
37665 PyThreadState* __tstate = wxPyBeginAllowThreads();
37666 (arg1)->Command(*arg2);
37667
37668 wxPyEndAllowThreads(__tstate);
37669 if (PyErr_Occurred()) SWIG_fail;
37670 }
37671 Py_INCREF(Py_None); resultobj = Py_None;
37672 return resultobj;
37673 fail:
37674 return NULL;
37675 }
37676
37677
37678 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37679 PyObject *resultobj;
37680 wxControl *arg1 = (wxControl *) 0 ;
37681 wxString result;
37682 PyObject * obj0 = 0 ;
37683 char *kwnames[] = {
37684 (char *) "self", NULL
37685 };
37686
37687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37689 if (SWIG_arg_fail(1)) SWIG_fail;
37690 {
37691 PyThreadState* __tstate = wxPyBeginAllowThreads();
37692 result = (arg1)->GetLabel();
37693
37694 wxPyEndAllowThreads(__tstate);
37695 if (PyErr_Occurred()) SWIG_fail;
37696 }
37697 {
37698 #if wxUSE_UNICODE
37699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37700 #else
37701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37702 #endif
37703 }
37704 return resultobj;
37705 fail:
37706 return NULL;
37707 }
37708
37709
37710 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37711 PyObject *resultobj;
37712 wxControl *arg1 = (wxControl *) 0 ;
37713 wxString *arg2 = 0 ;
37714 bool temp2 = false ;
37715 PyObject * obj0 = 0 ;
37716 PyObject * obj1 = 0 ;
37717 char *kwnames[] = {
37718 (char *) "self",(char *) "label", NULL
37719 };
37720
37721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37723 if (SWIG_arg_fail(1)) SWIG_fail;
37724 {
37725 arg2 = wxString_in_helper(obj1);
37726 if (arg2 == NULL) SWIG_fail;
37727 temp2 = true;
37728 }
37729 {
37730 PyThreadState* __tstate = wxPyBeginAllowThreads();
37731 (arg1)->SetLabel((wxString const &)*arg2);
37732
37733 wxPyEndAllowThreads(__tstate);
37734 if (PyErr_Occurred()) SWIG_fail;
37735 }
37736 Py_INCREF(Py_None); resultobj = Py_None;
37737 {
37738 if (temp2)
37739 delete arg2;
37740 }
37741 return resultobj;
37742 fail:
37743 {
37744 if (temp2)
37745 delete arg2;
37746 }
37747 return NULL;
37748 }
37749
37750
37751 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37752 PyObject *resultobj;
37753 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37754 wxVisualAttributes result;
37755 PyObject * obj0 = 0 ;
37756 char *kwnames[] = {
37757 (char *) "variant", NULL
37758 };
37759
37760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37761 if (obj0) {
37762 {
37763 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37764 if (SWIG_arg_fail(1)) SWIG_fail;
37765 }
37766 }
37767 {
37768 if (!wxPyCheckForApp()) SWIG_fail;
37769 PyThreadState* __tstate = wxPyBeginAllowThreads();
37770 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37771
37772 wxPyEndAllowThreads(__tstate);
37773 if (PyErr_Occurred()) SWIG_fail;
37774 }
37775 {
37776 wxVisualAttributes * resultptr;
37777 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37778 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37779 }
37780 return resultobj;
37781 fail:
37782 return NULL;
37783 }
37784
37785
37786 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37787 PyObject *obj;
37788 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37789 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37790 Py_INCREF(obj);
37791 return Py_BuildValue((char *)"");
37792 }
37793 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37794 PyObject *resultobj;
37795 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37796 wxString *arg2 = 0 ;
37797 PyObject *arg3 = (PyObject *) NULL ;
37798 int result;
37799 bool temp2 = false ;
37800 PyObject * obj0 = 0 ;
37801 PyObject * obj1 = 0 ;
37802 PyObject * obj2 = 0 ;
37803 char *kwnames[] = {
37804 (char *) "self",(char *) "item",(char *) "clientData", NULL
37805 };
37806
37807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37809 if (SWIG_arg_fail(1)) SWIG_fail;
37810 {
37811 arg2 = wxString_in_helper(obj1);
37812 if (arg2 == NULL) SWIG_fail;
37813 temp2 = true;
37814 }
37815 if (obj2) {
37816 arg3 = obj2;
37817 }
37818 {
37819 PyThreadState* __tstate = wxPyBeginAllowThreads();
37820 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37821
37822 wxPyEndAllowThreads(__tstate);
37823 if (PyErr_Occurred()) SWIG_fail;
37824 }
37825 {
37826 resultobj = SWIG_From_int((int)(result));
37827 }
37828 {
37829 if (temp2)
37830 delete arg2;
37831 }
37832 return resultobj;
37833 fail:
37834 {
37835 if (temp2)
37836 delete arg2;
37837 }
37838 return NULL;
37839 }
37840
37841
37842 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37843 PyObject *resultobj;
37844 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37845 wxArrayString *arg2 = 0 ;
37846 bool temp2 = false ;
37847 PyObject * obj0 = 0 ;
37848 PyObject * obj1 = 0 ;
37849 char *kwnames[] = {
37850 (char *) "self",(char *) "strings", NULL
37851 };
37852
37853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37855 if (SWIG_arg_fail(1)) SWIG_fail;
37856 {
37857 if (! PySequence_Check(obj1)) {
37858 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37859 SWIG_fail;
37860 }
37861 arg2 = new wxArrayString;
37862 temp2 = true;
37863 int i, len=PySequence_Length(obj1);
37864 for (i=0; i<len; i++) {
37865 PyObject* item = PySequence_GetItem(obj1, i);
37866 wxString* s = wxString_in_helper(item);
37867 if (PyErr_Occurred()) SWIG_fail;
37868 arg2->Add(*s);
37869 delete s;
37870 Py_DECREF(item);
37871 }
37872 }
37873 {
37874 PyThreadState* __tstate = wxPyBeginAllowThreads();
37875 (arg1)->Append((wxArrayString const &)*arg2);
37876
37877 wxPyEndAllowThreads(__tstate);
37878 if (PyErr_Occurred()) SWIG_fail;
37879 }
37880 Py_INCREF(Py_None); resultobj = Py_None;
37881 {
37882 if (temp2) delete arg2;
37883 }
37884 return resultobj;
37885 fail:
37886 {
37887 if (temp2) delete arg2;
37888 }
37889 return NULL;
37890 }
37891
37892
37893 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37894 PyObject *resultobj;
37895 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37896 wxString *arg2 = 0 ;
37897 int arg3 ;
37898 PyObject *arg4 = (PyObject *) NULL ;
37899 int result;
37900 bool temp2 = false ;
37901 PyObject * obj0 = 0 ;
37902 PyObject * obj1 = 0 ;
37903 PyObject * obj2 = 0 ;
37904 PyObject * obj3 = 0 ;
37905 char *kwnames[] = {
37906 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37907 };
37908
37909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37911 if (SWIG_arg_fail(1)) SWIG_fail;
37912 {
37913 arg2 = wxString_in_helper(obj1);
37914 if (arg2 == NULL) SWIG_fail;
37915 temp2 = true;
37916 }
37917 {
37918 arg3 = (int)(SWIG_As_int(obj2));
37919 if (SWIG_arg_fail(3)) SWIG_fail;
37920 }
37921 if (obj3) {
37922 arg4 = obj3;
37923 }
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37927
37928 wxPyEndAllowThreads(__tstate);
37929 if (PyErr_Occurred()) SWIG_fail;
37930 }
37931 {
37932 resultobj = SWIG_From_int((int)(result));
37933 }
37934 {
37935 if (temp2)
37936 delete arg2;
37937 }
37938 return resultobj;
37939 fail:
37940 {
37941 if (temp2)
37942 delete arg2;
37943 }
37944 return NULL;
37945 }
37946
37947
37948 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37949 PyObject *resultobj;
37950 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37951 PyObject * obj0 = 0 ;
37952 char *kwnames[] = {
37953 (char *) "self", NULL
37954 };
37955
37956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",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 (arg1)->Clear();
37962
37963 wxPyEndAllowThreads(__tstate);
37964 if (PyErr_Occurred()) SWIG_fail;
37965 }
37966 Py_INCREF(Py_None); resultobj = Py_None;
37967 return resultobj;
37968 fail:
37969 return NULL;
37970 }
37971
37972
37973 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37974 PyObject *resultobj;
37975 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37976 int arg2 ;
37977 PyObject * obj0 = 0 ;
37978 PyObject * obj1 = 0 ;
37979 char *kwnames[] = {
37980 (char *) "self",(char *) "n", NULL
37981 };
37982
37983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37985 if (SWIG_arg_fail(1)) SWIG_fail;
37986 {
37987 arg2 = (int)(SWIG_As_int(obj1));
37988 if (SWIG_arg_fail(2)) SWIG_fail;
37989 }
37990 {
37991 PyThreadState* __tstate = wxPyBeginAllowThreads();
37992 (arg1)->Delete(arg2);
37993
37994 wxPyEndAllowThreads(__tstate);
37995 if (PyErr_Occurred()) SWIG_fail;
37996 }
37997 Py_INCREF(Py_None); resultobj = Py_None;
37998 return resultobj;
37999 fail:
38000 return NULL;
38001 }
38002
38003
38004 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38005 PyObject *resultobj;
38006 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38007 int arg2 ;
38008 PyObject *result;
38009 PyObject * obj0 = 0 ;
38010 PyObject * obj1 = 0 ;
38011 char *kwnames[] = {
38012 (char *) "self",(char *) "n", NULL
38013 };
38014
38015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38017 if (SWIG_arg_fail(1)) SWIG_fail;
38018 {
38019 arg2 = (int)(SWIG_As_int(obj1));
38020 if (SWIG_arg_fail(2)) SWIG_fail;
38021 }
38022 {
38023 PyThreadState* __tstate = wxPyBeginAllowThreads();
38024 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38025
38026 wxPyEndAllowThreads(__tstate);
38027 if (PyErr_Occurred()) SWIG_fail;
38028 }
38029 resultobj = result;
38030 return resultobj;
38031 fail:
38032 return NULL;
38033 }
38034
38035
38036 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38037 PyObject *resultobj;
38038 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38039 int arg2 ;
38040 PyObject *arg3 = (PyObject *) 0 ;
38041 PyObject * obj0 = 0 ;
38042 PyObject * obj1 = 0 ;
38043 PyObject * obj2 = 0 ;
38044 char *kwnames[] = {
38045 (char *) "self",(char *) "n",(char *) "clientData", NULL
38046 };
38047
38048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38050 if (SWIG_arg_fail(1)) SWIG_fail;
38051 {
38052 arg2 = (int)(SWIG_As_int(obj1));
38053 if (SWIG_arg_fail(2)) SWIG_fail;
38054 }
38055 arg3 = obj2;
38056 {
38057 PyThreadState* __tstate = wxPyBeginAllowThreads();
38058 wxItemContainer_SetClientData(arg1,arg2,arg3);
38059
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 Py_INCREF(Py_None); resultobj = Py_None;
38064 return resultobj;
38065 fail:
38066 return NULL;
38067 }
38068
38069
38070 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38071 PyObject *resultobj;
38072 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38073 int result;
38074 PyObject * obj0 = 0 ;
38075 char *kwnames[] = {
38076 (char *) "self", NULL
38077 };
38078
38079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38081 if (SWIG_arg_fail(1)) SWIG_fail;
38082 {
38083 PyThreadState* __tstate = wxPyBeginAllowThreads();
38084 result = (int)((wxItemContainer const *)arg1)->GetCount();
38085
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 {
38090 resultobj = SWIG_From_int((int)(result));
38091 }
38092 return resultobj;
38093 fail:
38094 return NULL;
38095 }
38096
38097
38098 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38099 PyObject *resultobj;
38100 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38101 bool result;
38102 PyObject * obj0 = 0 ;
38103 char *kwnames[] = {
38104 (char *) "self", NULL
38105 };
38106
38107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38109 if (SWIG_arg_fail(1)) SWIG_fail;
38110 {
38111 PyThreadState* __tstate = wxPyBeginAllowThreads();
38112 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38113
38114 wxPyEndAllowThreads(__tstate);
38115 if (PyErr_Occurred()) SWIG_fail;
38116 }
38117 {
38118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38119 }
38120 return resultobj;
38121 fail:
38122 return NULL;
38123 }
38124
38125
38126 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38127 PyObject *resultobj;
38128 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38129 int arg2 ;
38130 wxString result;
38131 PyObject * obj0 = 0 ;
38132 PyObject * obj1 = 0 ;
38133 char *kwnames[] = {
38134 (char *) "self",(char *) "n", NULL
38135 };
38136
38137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38139 if (SWIG_arg_fail(1)) SWIG_fail;
38140 {
38141 arg2 = (int)(SWIG_As_int(obj1));
38142 if (SWIG_arg_fail(2)) SWIG_fail;
38143 }
38144 {
38145 PyThreadState* __tstate = wxPyBeginAllowThreads();
38146 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38147
38148 wxPyEndAllowThreads(__tstate);
38149 if (PyErr_Occurred()) SWIG_fail;
38150 }
38151 {
38152 #if wxUSE_UNICODE
38153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38154 #else
38155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38156 #endif
38157 }
38158 return resultobj;
38159 fail:
38160 return NULL;
38161 }
38162
38163
38164 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38165 PyObject *resultobj;
38166 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38167 wxArrayString result;
38168 PyObject * obj0 = 0 ;
38169 char *kwnames[] = {
38170 (char *) "self", NULL
38171 };
38172
38173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38175 if (SWIG_arg_fail(1)) SWIG_fail;
38176 {
38177 PyThreadState* __tstate = wxPyBeginAllowThreads();
38178 result = ((wxItemContainer const *)arg1)->GetStrings();
38179
38180 wxPyEndAllowThreads(__tstate);
38181 if (PyErr_Occurred()) SWIG_fail;
38182 }
38183 {
38184 resultobj = wxArrayString2PyList_helper(result);
38185 }
38186 return resultobj;
38187 fail:
38188 return NULL;
38189 }
38190
38191
38192 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38193 PyObject *resultobj;
38194 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38195 int arg2 ;
38196 wxString *arg3 = 0 ;
38197 bool temp3 = false ;
38198 PyObject * obj0 = 0 ;
38199 PyObject * obj1 = 0 ;
38200 PyObject * obj2 = 0 ;
38201 char *kwnames[] = {
38202 (char *) "self",(char *) "n",(char *) "s", NULL
38203 };
38204
38205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38207 if (SWIG_arg_fail(1)) SWIG_fail;
38208 {
38209 arg2 = (int)(SWIG_As_int(obj1));
38210 if (SWIG_arg_fail(2)) SWIG_fail;
38211 }
38212 {
38213 arg3 = wxString_in_helper(obj2);
38214 if (arg3 == NULL) SWIG_fail;
38215 temp3 = true;
38216 }
38217 {
38218 PyThreadState* __tstate = wxPyBeginAllowThreads();
38219 (arg1)->SetString(arg2,(wxString const &)*arg3);
38220
38221 wxPyEndAllowThreads(__tstate);
38222 if (PyErr_Occurred()) SWIG_fail;
38223 }
38224 Py_INCREF(Py_None); resultobj = Py_None;
38225 {
38226 if (temp3)
38227 delete arg3;
38228 }
38229 return resultobj;
38230 fail:
38231 {
38232 if (temp3)
38233 delete arg3;
38234 }
38235 return NULL;
38236 }
38237
38238
38239 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38240 PyObject *resultobj;
38241 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38242 wxString *arg2 = 0 ;
38243 int result;
38244 bool temp2 = false ;
38245 PyObject * obj0 = 0 ;
38246 PyObject * obj1 = 0 ;
38247 char *kwnames[] = {
38248 (char *) "self",(char *) "s", NULL
38249 };
38250
38251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38253 if (SWIG_arg_fail(1)) SWIG_fail;
38254 {
38255 arg2 = wxString_in_helper(obj1);
38256 if (arg2 == NULL) SWIG_fail;
38257 temp2 = true;
38258 }
38259 {
38260 PyThreadState* __tstate = wxPyBeginAllowThreads();
38261 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38262
38263 wxPyEndAllowThreads(__tstate);
38264 if (PyErr_Occurred()) SWIG_fail;
38265 }
38266 {
38267 resultobj = SWIG_From_int((int)(result));
38268 }
38269 {
38270 if (temp2)
38271 delete arg2;
38272 }
38273 return resultobj;
38274 fail:
38275 {
38276 if (temp2)
38277 delete arg2;
38278 }
38279 return NULL;
38280 }
38281
38282
38283 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38284 PyObject *resultobj;
38285 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38286 int arg2 ;
38287 PyObject * obj0 = 0 ;
38288 PyObject * obj1 = 0 ;
38289 char *kwnames[] = {
38290 (char *) "self",(char *) "n", NULL
38291 };
38292
38293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38295 if (SWIG_arg_fail(1)) SWIG_fail;
38296 {
38297 arg2 = (int)(SWIG_As_int(obj1));
38298 if (SWIG_arg_fail(2)) SWIG_fail;
38299 }
38300 {
38301 PyThreadState* __tstate = wxPyBeginAllowThreads();
38302 (arg1)->SetSelection(arg2);
38303
38304 wxPyEndAllowThreads(__tstate);
38305 if (PyErr_Occurred()) SWIG_fail;
38306 }
38307 Py_INCREF(Py_None); resultobj = Py_None;
38308 return resultobj;
38309 fail:
38310 return NULL;
38311 }
38312
38313
38314 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38315 PyObject *resultobj;
38316 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38317 int result;
38318 PyObject * obj0 = 0 ;
38319 char *kwnames[] = {
38320 (char *) "self", NULL
38321 };
38322
38323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38325 if (SWIG_arg_fail(1)) SWIG_fail;
38326 {
38327 PyThreadState* __tstate = wxPyBeginAllowThreads();
38328 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38329
38330 wxPyEndAllowThreads(__tstate);
38331 if (PyErr_Occurred()) SWIG_fail;
38332 }
38333 {
38334 resultobj = SWIG_From_int((int)(result));
38335 }
38336 return resultobj;
38337 fail:
38338 return NULL;
38339 }
38340
38341
38342 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38343 PyObject *resultobj;
38344 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38345 wxString *arg2 = 0 ;
38346 bool result;
38347 bool temp2 = false ;
38348 PyObject * obj0 = 0 ;
38349 PyObject * obj1 = 0 ;
38350 char *kwnames[] = {
38351 (char *) "self",(char *) "s", NULL
38352 };
38353
38354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38356 if (SWIG_arg_fail(1)) SWIG_fail;
38357 {
38358 arg2 = wxString_in_helper(obj1);
38359 if (arg2 == NULL) SWIG_fail;
38360 temp2 = true;
38361 }
38362 {
38363 PyThreadState* __tstate = wxPyBeginAllowThreads();
38364 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38365
38366 wxPyEndAllowThreads(__tstate);
38367 if (PyErr_Occurred()) SWIG_fail;
38368 }
38369 {
38370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38371 }
38372 {
38373 if (temp2)
38374 delete arg2;
38375 }
38376 return resultobj;
38377 fail:
38378 {
38379 if (temp2)
38380 delete arg2;
38381 }
38382 return NULL;
38383 }
38384
38385
38386 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38387 PyObject *resultobj;
38388 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38389 wxString result;
38390 PyObject * obj0 = 0 ;
38391 char *kwnames[] = {
38392 (char *) "self", NULL
38393 };
38394
38395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38397 if (SWIG_arg_fail(1)) SWIG_fail;
38398 {
38399 PyThreadState* __tstate = wxPyBeginAllowThreads();
38400 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38401
38402 wxPyEndAllowThreads(__tstate);
38403 if (PyErr_Occurred()) SWIG_fail;
38404 }
38405 {
38406 #if wxUSE_UNICODE
38407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38408 #else
38409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38410 #endif
38411 }
38412 return resultobj;
38413 fail:
38414 return NULL;
38415 }
38416
38417
38418 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38419 PyObject *resultobj;
38420 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38421 int arg2 ;
38422 PyObject * obj0 = 0 ;
38423 PyObject * obj1 = 0 ;
38424 char *kwnames[] = {
38425 (char *) "self",(char *) "n", NULL
38426 };
38427
38428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38430 if (SWIG_arg_fail(1)) SWIG_fail;
38431 {
38432 arg2 = (int)(SWIG_As_int(obj1));
38433 if (SWIG_arg_fail(2)) SWIG_fail;
38434 }
38435 {
38436 PyThreadState* __tstate = wxPyBeginAllowThreads();
38437 (arg1)->Select(arg2);
38438
38439 wxPyEndAllowThreads(__tstate);
38440 if (PyErr_Occurred()) SWIG_fail;
38441 }
38442 Py_INCREF(Py_None); resultobj = Py_None;
38443 return resultobj;
38444 fail:
38445 return NULL;
38446 }
38447
38448
38449 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38450 PyObject *obj;
38451 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38452 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38453 Py_INCREF(obj);
38454 return Py_BuildValue((char *)"");
38455 }
38456 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38457 PyObject *obj;
38458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38459 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38460 Py_INCREF(obj);
38461 return Py_BuildValue((char *)"");
38462 }
38463 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38464 PyObject *resultobj;
38465 wxSizerItem *result;
38466 char *kwnames[] = {
38467 NULL
38468 };
38469
38470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38471 {
38472 PyThreadState* __tstate = wxPyBeginAllowThreads();
38473 result = (wxSizerItem *)new wxSizerItem();
38474
38475 wxPyEndAllowThreads(__tstate);
38476 if (PyErr_Occurred()) SWIG_fail;
38477 }
38478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38479 return resultobj;
38480 fail:
38481 return NULL;
38482 }
38483
38484
38485 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38486 PyObject *resultobj;
38487 wxWindow *arg1 = (wxWindow *) 0 ;
38488 int arg2 ;
38489 int arg3 ;
38490 int arg4 ;
38491 PyObject *arg5 = (PyObject *) NULL ;
38492 wxSizerItem *result;
38493 PyObject * obj0 = 0 ;
38494 PyObject * obj1 = 0 ;
38495 PyObject * obj2 = 0 ;
38496 PyObject * obj3 = 0 ;
38497 PyObject * obj4 = 0 ;
38498 char *kwnames[] = {
38499 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38500 };
38501
38502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38504 if (SWIG_arg_fail(1)) SWIG_fail;
38505 {
38506 arg2 = (int)(SWIG_As_int(obj1));
38507 if (SWIG_arg_fail(2)) SWIG_fail;
38508 }
38509 {
38510 arg3 = (int)(SWIG_As_int(obj2));
38511 if (SWIG_arg_fail(3)) SWIG_fail;
38512 }
38513 {
38514 arg4 = (int)(SWIG_As_int(obj3));
38515 if (SWIG_arg_fail(4)) SWIG_fail;
38516 }
38517 if (obj4) {
38518 arg5 = obj4;
38519 }
38520 {
38521 PyThreadState* __tstate = wxPyBeginAllowThreads();
38522 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38523
38524 wxPyEndAllowThreads(__tstate);
38525 if (PyErr_Occurred()) SWIG_fail;
38526 }
38527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38528 return resultobj;
38529 fail:
38530 return NULL;
38531 }
38532
38533
38534 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38535 PyObject *resultobj;
38536 int arg1 ;
38537 int arg2 ;
38538 int arg3 ;
38539 int arg4 ;
38540 int arg5 ;
38541 PyObject *arg6 = (PyObject *) NULL ;
38542 wxSizerItem *result;
38543 PyObject * obj0 = 0 ;
38544 PyObject * obj1 = 0 ;
38545 PyObject * obj2 = 0 ;
38546 PyObject * obj3 = 0 ;
38547 PyObject * obj4 = 0 ;
38548 PyObject * obj5 = 0 ;
38549 char *kwnames[] = {
38550 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38551 };
38552
38553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38554 {
38555 arg1 = (int)(SWIG_As_int(obj0));
38556 if (SWIG_arg_fail(1)) SWIG_fail;
38557 }
38558 {
38559 arg2 = (int)(SWIG_As_int(obj1));
38560 if (SWIG_arg_fail(2)) SWIG_fail;
38561 }
38562 {
38563 arg3 = (int)(SWIG_As_int(obj2));
38564 if (SWIG_arg_fail(3)) SWIG_fail;
38565 }
38566 {
38567 arg4 = (int)(SWIG_As_int(obj3));
38568 if (SWIG_arg_fail(4)) SWIG_fail;
38569 }
38570 {
38571 arg5 = (int)(SWIG_As_int(obj4));
38572 if (SWIG_arg_fail(5)) SWIG_fail;
38573 }
38574 if (obj5) {
38575 arg6 = obj5;
38576 }
38577 {
38578 PyThreadState* __tstate = wxPyBeginAllowThreads();
38579 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38580
38581 wxPyEndAllowThreads(__tstate);
38582 if (PyErr_Occurred()) SWIG_fail;
38583 }
38584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38585 return resultobj;
38586 fail:
38587 return NULL;
38588 }
38589
38590
38591 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38592 PyObject *resultobj;
38593 wxSizer *arg1 = (wxSizer *) 0 ;
38594 int arg2 ;
38595 int arg3 ;
38596 int arg4 ;
38597 PyObject *arg5 = (PyObject *) NULL ;
38598 wxSizerItem *result;
38599 PyObject * obj0 = 0 ;
38600 PyObject * obj1 = 0 ;
38601 PyObject * obj2 = 0 ;
38602 PyObject * obj3 = 0 ;
38603 PyObject * obj4 = 0 ;
38604 char *kwnames[] = {
38605 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38606 };
38607
38608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38610 if (SWIG_arg_fail(1)) SWIG_fail;
38611 {
38612 arg2 = (int)(SWIG_As_int(obj1));
38613 if (SWIG_arg_fail(2)) SWIG_fail;
38614 }
38615 {
38616 arg3 = (int)(SWIG_As_int(obj2));
38617 if (SWIG_arg_fail(3)) SWIG_fail;
38618 }
38619 {
38620 arg4 = (int)(SWIG_As_int(obj3));
38621 if (SWIG_arg_fail(4)) SWIG_fail;
38622 }
38623 if (obj4) {
38624 arg5 = obj4;
38625 }
38626 {
38627 PyThreadState* __tstate = wxPyBeginAllowThreads();
38628 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38629
38630 wxPyEndAllowThreads(__tstate);
38631 if (PyErr_Occurred()) SWIG_fail;
38632 }
38633 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38634 return resultobj;
38635 fail:
38636 return NULL;
38637 }
38638
38639
38640 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38641 PyObject *resultobj;
38642 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38643 PyObject * obj0 = 0 ;
38644 char *kwnames[] = {
38645 (char *) "self", NULL
38646 };
38647
38648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38650 if (SWIG_arg_fail(1)) SWIG_fail;
38651 {
38652 PyThreadState* __tstate = wxPyBeginAllowThreads();
38653 (arg1)->DeleteWindows();
38654
38655 wxPyEndAllowThreads(__tstate);
38656 if (PyErr_Occurred()) SWIG_fail;
38657 }
38658 Py_INCREF(Py_None); resultobj = Py_None;
38659 return resultobj;
38660 fail:
38661 return NULL;
38662 }
38663
38664
38665 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38666 PyObject *resultobj;
38667 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38668 PyObject * obj0 = 0 ;
38669 char *kwnames[] = {
38670 (char *) "self", NULL
38671 };
38672
38673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38675 if (SWIG_arg_fail(1)) SWIG_fail;
38676 {
38677 PyThreadState* __tstate = wxPyBeginAllowThreads();
38678 (arg1)->DetachSizer();
38679
38680 wxPyEndAllowThreads(__tstate);
38681 if (PyErr_Occurred()) SWIG_fail;
38682 }
38683 Py_INCREF(Py_None); resultobj = Py_None;
38684 return resultobj;
38685 fail:
38686 return NULL;
38687 }
38688
38689
38690 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38691 PyObject *resultobj;
38692 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38693 wxSize result;
38694 PyObject * obj0 = 0 ;
38695 char *kwnames[] = {
38696 (char *) "self", NULL
38697 };
38698
38699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38701 if (SWIG_arg_fail(1)) SWIG_fail;
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 result = (arg1)->GetSize();
38705
38706 wxPyEndAllowThreads(__tstate);
38707 if (PyErr_Occurred()) SWIG_fail;
38708 }
38709 {
38710 wxSize * resultptr;
38711 resultptr = new wxSize((wxSize &)(result));
38712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38713 }
38714 return resultobj;
38715 fail:
38716 return NULL;
38717 }
38718
38719
38720 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38721 PyObject *resultobj;
38722 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38723 wxSize result;
38724 PyObject * obj0 = 0 ;
38725 char *kwnames[] = {
38726 (char *) "self", NULL
38727 };
38728
38729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38731 if (SWIG_arg_fail(1)) SWIG_fail;
38732 {
38733 PyThreadState* __tstate = wxPyBeginAllowThreads();
38734 result = (arg1)->CalcMin();
38735
38736 wxPyEndAllowThreads(__tstate);
38737 if (PyErr_Occurred()) SWIG_fail;
38738 }
38739 {
38740 wxSize * resultptr;
38741 resultptr = new wxSize((wxSize &)(result));
38742 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38743 }
38744 return resultobj;
38745 fail:
38746 return NULL;
38747 }
38748
38749
38750 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38751 PyObject *resultobj;
38752 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38753 wxPoint arg2 ;
38754 wxSize arg3 ;
38755 PyObject * obj0 = 0 ;
38756 PyObject * obj1 = 0 ;
38757 PyObject * obj2 = 0 ;
38758 char *kwnames[] = {
38759 (char *) "self",(char *) "pos",(char *) "size", NULL
38760 };
38761
38762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38764 if (SWIG_arg_fail(1)) SWIG_fail;
38765 {
38766 wxPoint * argp;
38767 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38768 if (SWIG_arg_fail(2)) SWIG_fail;
38769 if (argp == NULL) {
38770 SWIG_null_ref("wxPoint");
38771 }
38772 if (SWIG_arg_fail(2)) SWIG_fail;
38773 arg2 = *argp;
38774 }
38775 {
38776 wxSize * argp;
38777 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38778 if (SWIG_arg_fail(3)) SWIG_fail;
38779 if (argp == NULL) {
38780 SWIG_null_ref("wxSize");
38781 }
38782 if (SWIG_arg_fail(3)) SWIG_fail;
38783 arg3 = *argp;
38784 }
38785 {
38786 PyThreadState* __tstate = wxPyBeginAllowThreads();
38787 (arg1)->SetDimension(arg2,arg3);
38788
38789 wxPyEndAllowThreads(__tstate);
38790 if (PyErr_Occurred()) SWIG_fail;
38791 }
38792 Py_INCREF(Py_None); resultobj = Py_None;
38793 return resultobj;
38794 fail:
38795 return NULL;
38796 }
38797
38798
38799 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38800 PyObject *resultobj;
38801 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38802 wxSize result;
38803 PyObject * obj0 = 0 ;
38804 char *kwnames[] = {
38805 (char *) "self", NULL
38806 };
38807
38808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38810 if (SWIG_arg_fail(1)) SWIG_fail;
38811 {
38812 PyThreadState* __tstate = wxPyBeginAllowThreads();
38813 result = (arg1)->GetMinSize();
38814
38815 wxPyEndAllowThreads(__tstate);
38816 if (PyErr_Occurred()) SWIG_fail;
38817 }
38818 {
38819 wxSize * resultptr;
38820 resultptr = new wxSize((wxSize &)(result));
38821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38822 }
38823 return resultobj;
38824 fail:
38825 return NULL;
38826 }
38827
38828
38829 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38830 PyObject *resultobj;
38831 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38832 wxSize result;
38833 PyObject * obj0 = 0 ;
38834 char *kwnames[] = {
38835 (char *) "self", NULL
38836 };
38837
38838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38840 if (SWIG_arg_fail(1)) SWIG_fail;
38841 {
38842 PyThreadState* __tstate = wxPyBeginAllowThreads();
38843 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38844
38845 wxPyEndAllowThreads(__tstate);
38846 if (PyErr_Occurred()) SWIG_fail;
38847 }
38848 {
38849 wxSize * resultptr;
38850 resultptr = new wxSize((wxSize &)(result));
38851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38852 }
38853 return resultobj;
38854 fail:
38855 return NULL;
38856 }
38857
38858
38859 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38860 PyObject *resultobj;
38861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38862 int arg2 ;
38863 int arg3 ;
38864 PyObject * obj0 = 0 ;
38865 PyObject * obj1 = 0 ;
38866 PyObject * obj2 = 0 ;
38867 char *kwnames[] = {
38868 (char *) "self",(char *) "x",(char *) "y", NULL
38869 };
38870
38871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38873 if (SWIG_arg_fail(1)) SWIG_fail;
38874 {
38875 arg2 = (int)(SWIG_As_int(obj1));
38876 if (SWIG_arg_fail(2)) SWIG_fail;
38877 }
38878 {
38879 arg3 = (int)(SWIG_As_int(obj2));
38880 if (SWIG_arg_fail(3)) SWIG_fail;
38881 }
38882 {
38883 PyThreadState* __tstate = wxPyBeginAllowThreads();
38884 (arg1)->SetInitSize(arg2,arg3);
38885
38886 wxPyEndAllowThreads(__tstate);
38887 if (PyErr_Occurred()) SWIG_fail;
38888 }
38889 Py_INCREF(Py_None); resultobj = Py_None;
38890 return resultobj;
38891 fail:
38892 return NULL;
38893 }
38894
38895
38896 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38897 PyObject *resultobj;
38898 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38899 int arg2 ;
38900 int arg3 ;
38901 PyObject * obj0 = 0 ;
38902 PyObject * obj1 = 0 ;
38903 PyObject * obj2 = 0 ;
38904 char *kwnames[] = {
38905 (char *) "self",(char *) "width",(char *) "height", NULL
38906 };
38907
38908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38910 if (SWIG_arg_fail(1)) SWIG_fail;
38911 {
38912 arg2 = (int)(SWIG_As_int(obj1));
38913 if (SWIG_arg_fail(2)) SWIG_fail;
38914 }
38915 {
38916 arg3 = (int)(SWIG_As_int(obj2));
38917 if (SWIG_arg_fail(3)) SWIG_fail;
38918 }
38919 {
38920 PyThreadState* __tstate = wxPyBeginAllowThreads();
38921 (arg1)->SetRatio(arg2,arg3);
38922
38923 wxPyEndAllowThreads(__tstate);
38924 if (PyErr_Occurred()) SWIG_fail;
38925 }
38926 Py_INCREF(Py_None); resultobj = Py_None;
38927 return resultobj;
38928 fail:
38929 return NULL;
38930 }
38931
38932
38933 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38934 PyObject *resultobj;
38935 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38936 wxSize *arg2 = 0 ;
38937 wxSize temp2 ;
38938 PyObject * obj0 = 0 ;
38939 PyObject * obj1 = 0 ;
38940 char *kwnames[] = {
38941 (char *) "self",(char *) "size", NULL
38942 };
38943
38944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38946 if (SWIG_arg_fail(1)) SWIG_fail;
38947 {
38948 arg2 = &temp2;
38949 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38950 }
38951 {
38952 PyThreadState* __tstate = wxPyBeginAllowThreads();
38953 (arg1)->SetRatio((wxSize const &)*arg2);
38954
38955 wxPyEndAllowThreads(__tstate);
38956 if (PyErr_Occurred()) SWIG_fail;
38957 }
38958 Py_INCREF(Py_None); resultobj = Py_None;
38959 return resultobj;
38960 fail:
38961 return NULL;
38962 }
38963
38964
38965 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38966 PyObject *resultobj;
38967 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38968 float arg2 ;
38969 PyObject * obj0 = 0 ;
38970 PyObject * obj1 = 0 ;
38971 char *kwnames[] = {
38972 (char *) "self",(char *) "ratio", NULL
38973 };
38974
38975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38977 if (SWIG_arg_fail(1)) SWIG_fail;
38978 {
38979 arg2 = (float)(SWIG_As_float(obj1));
38980 if (SWIG_arg_fail(2)) SWIG_fail;
38981 }
38982 {
38983 PyThreadState* __tstate = wxPyBeginAllowThreads();
38984 (arg1)->SetRatio(arg2);
38985
38986 wxPyEndAllowThreads(__tstate);
38987 if (PyErr_Occurred()) SWIG_fail;
38988 }
38989 Py_INCREF(Py_None); resultobj = Py_None;
38990 return resultobj;
38991 fail:
38992 return NULL;
38993 }
38994
38995
38996 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38997 PyObject *resultobj;
38998 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38999 float result;
39000 PyObject * obj0 = 0 ;
39001 char *kwnames[] = {
39002 (char *) "self", NULL
39003 };
39004
39005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39007 if (SWIG_arg_fail(1)) SWIG_fail;
39008 {
39009 PyThreadState* __tstate = wxPyBeginAllowThreads();
39010 result = (float)(arg1)->GetRatio();
39011
39012 wxPyEndAllowThreads(__tstate);
39013 if (PyErr_Occurred()) SWIG_fail;
39014 }
39015 {
39016 resultobj = SWIG_From_float((float)(result));
39017 }
39018 return resultobj;
39019 fail:
39020 return NULL;
39021 }
39022
39023
39024 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39025 PyObject *resultobj;
39026 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39027 wxRect result;
39028 PyObject * obj0 = 0 ;
39029 char *kwnames[] = {
39030 (char *) "self", NULL
39031 };
39032
39033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39035 if (SWIG_arg_fail(1)) SWIG_fail;
39036 {
39037 PyThreadState* __tstate = wxPyBeginAllowThreads();
39038 result = (arg1)->GetRect();
39039
39040 wxPyEndAllowThreads(__tstate);
39041 if (PyErr_Occurred()) SWIG_fail;
39042 }
39043 {
39044 wxRect * resultptr;
39045 resultptr = new wxRect((wxRect &)(result));
39046 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39047 }
39048 return resultobj;
39049 fail:
39050 return NULL;
39051 }
39052
39053
39054 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39055 PyObject *resultobj;
39056 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39057 bool result;
39058 PyObject * obj0 = 0 ;
39059 char *kwnames[] = {
39060 (char *) "self", NULL
39061 };
39062
39063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39065 if (SWIG_arg_fail(1)) SWIG_fail;
39066 {
39067 PyThreadState* __tstate = wxPyBeginAllowThreads();
39068 result = (bool)(arg1)->IsWindow();
39069
39070 wxPyEndAllowThreads(__tstate);
39071 if (PyErr_Occurred()) SWIG_fail;
39072 }
39073 {
39074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39075 }
39076 return resultobj;
39077 fail:
39078 return NULL;
39079 }
39080
39081
39082 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39083 PyObject *resultobj;
39084 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39085 bool result;
39086 PyObject * obj0 = 0 ;
39087 char *kwnames[] = {
39088 (char *) "self", NULL
39089 };
39090
39091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39093 if (SWIG_arg_fail(1)) SWIG_fail;
39094 {
39095 PyThreadState* __tstate = wxPyBeginAllowThreads();
39096 result = (bool)(arg1)->IsSizer();
39097
39098 wxPyEndAllowThreads(__tstate);
39099 if (PyErr_Occurred()) SWIG_fail;
39100 }
39101 {
39102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39103 }
39104 return resultobj;
39105 fail:
39106 return NULL;
39107 }
39108
39109
39110 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39111 PyObject *resultobj;
39112 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39113 bool result;
39114 PyObject * obj0 = 0 ;
39115 char *kwnames[] = {
39116 (char *) "self", NULL
39117 };
39118
39119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39121 if (SWIG_arg_fail(1)) SWIG_fail;
39122 {
39123 PyThreadState* __tstate = wxPyBeginAllowThreads();
39124 result = (bool)(arg1)->IsSpacer();
39125
39126 wxPyEndAllowThreads(__tstate);
39127 if (PyErr_Occurred()) SWIG_fail;
39128 }
39129 {
39130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39131 }
39132 return resultobj;
39133 fail:
39134 return NULL;
39135 }
39136
39137
39138 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39139 PyObject *resultobj;
39140 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39141 int arg2 ;
39142 PyObject * obj0 = 0 ;
39143 PyObject * obj1 = 0 ;
39144 char *kwnames[] = {
39145 (char *) "self",(char *) "proportion", NULL
39146 };
39147
39148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39150 if (SWIG_arg_fail(1)) SWIG_fail;
39151 {
39152 arg2 = (int)(SWIG_As_int(obj1));
39153 if (SWIG_arg_fail(2)) SWIG_fail;
39154 }
39155 {
39156 PyThreadState* __tstate = wxPyBeginAllowThreads();
39157 (arg1)->SetProportion(arg2);
39158
39159 wxPyEndAllowThreads(__tstate);
39160 if (PyErr_Occurred()) SWIG_fail;
39161 }
39162 Py_INCREF(Py_None); resultobj = Py_None;
39163 return resultobj;
39164 fail:
39165 return NULL;
39166 }
39167
39168
39169 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39170 PyObject *resultobj;
39171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39172 int result;
39173 PyObject * obj0 = 0 ;
39174 char *kwnames[] = {
39175 (char *) "self", NULL
39176 };
39177
39178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39180 if (SWIG_arg_fail(1)) SWIG_fail;
39181 {
39182 PyThreadState* __tstate = wxPyBeginAllowThreads();
39183 result = (int)(arg1)->GetProportion();
39184
39185 wxPyEndAllowThreads(__tstate);
39186 if (PyErr_Occurred()) SWIG_fail;
39187 }
39188 {
39189 resultobj = SWIG_From_int((int)(result));
39190 }
39191 return resultobj;
39192 fail:
39193 return NULL;
39194 }
39195
39196
39197 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39198 PyObject *resultobj;
39199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39200 int arg2 ;
39201 PyObject * obj0 = 0 ;
39202 PyObject * obj1 = 0 ;
39203 char *kwnames[] = {
39204 (char *) "self",(char *) "flag", NULL
39205 };
39206
39207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39209 if (SWIG_arg_fail(1)) SWIG_fail;
39210 {
39211 arg2 = (int)(SWIG_As_int(obj1));
39212 if (SWIG_arg_fail(2)) SWIG_fail;
39213 }
39214 {
39215 PyThreadState* __tstate = wxPyBeginAllowThreads();
39216 (arg1)->SetFlag(arg2);
39217
39218 wxPyEndAllowThreads(__tstate);
39219 if (PyErr_Occurred()) SWIG_fail;
39220 }
39221 Py_INCREF(Py_None); resultobj = Py_None;
39222 return resultobj;
39223 fail:
39224 return NULL;
39225 }
39226
39227
39228 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39229 PyObject *resultobj;
39230 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39231 int result;
39232 PyObject * obj0 = 0 ;
39233 char *kwnames[] = {
39234 (char *) "self", NULL
39235 };
39236
39237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39239 if (SWIG_arg_fail(1)) SWIG_fail;
39240 {
39241 PyThreadState* __tstate = wxPyBeginAllowThreads();
39242 result = (int)(arg1)->GetFlag();
39243
39244 wxPyEndAllowThreads(__tstate);
39245 if (PyErr_Occurred()) SWIG_fail;
39246 }
39247 {
39248 resultobj = SWIG_From_int((int)(result));
39249 }
39250 return resultobj;
39251 fail:
39252 return NULL;
39253 }
39254
39255
39256 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39257 PyObject *resultobj;
39258 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39259 int arg2 ;
39260 PyObject * obj0 = 0 ;
39261 PyObject * obj1 = 0 ;
39262 char *kwnames[] = {
39263 (char *) "self",(char *) "border", NULL
39264 };
39265
39266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39268 if (SWIG_arg_fail(1)) SWIG_fail;
39269 {
39270 arg2 = (int)(SWIG_As_int(obj1));
39271 if (SWIG_arg_fail(2)) SWIG_fail;
39272 }
39273 {
39274 PyThreadState* __tstate = wxPyBeginAllowThreads();
39275 (arg1)->SetBorder(arg2);
39276
39277 wxPyEndAllowThreads(__tstate);
39278 if (PyErr_Occurred()) SWIG_fail;
39279 }
39280 Py_INCREF(Py_None); resultobj = Py_None;
39281 return resultobj;
39282 fail:
39283 return NULL;
39284 }
39285
39286
39287 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39288 PyObject *resultobj;
39289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39290 int result;
39291 PyObject * obj0 = 0 ;
39292 char *kwnames[] = {
39293 (char *) "self", NULL
39294 };
39295
39296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39298 if (SWIG_arg_fail(1)) SWIG_fail;
39299 {
39300 PyThreadState* __tstate = wxPyBeginAllowThreads();
39301 result = (int)(arg1)->GetBorder();
39302
39303 wxPyEndAllowThreads(__tstate);
39304 if (PyErr_Occurred()) SWIG_fail;
39305 }
39306 {
39307 resultobj = SWIG_From_int((int)(result));
39308 }
39309 return resultobj;
39310 fail:
39311 return NULL;
39312 }
39313
39314
39315 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39316 PyObject *resultobj;
39317 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39318 wxWindow *result;
39319 PyObject * obj0 = 0 ;
39320 char *kwnames[] = {
39321 (char *) "self", NULL
39322 };
39323
39324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39326 if (SWIG_arg_fail(1)) SWIG_fail;
39327 {
39328 PyThreadState* __tstate = wxPyBeginAllowThreads();
39329 result = (wxWindow *)(arg1)->GetWindow();
39330
39331 wxPyEndAllowThreads(__tstate);
39332 if (PyErr_Occurred()) SWIG_fail;
39333 }
39334 {
39335 resultobj = wxPyMake_wxObject(result, 0);
39336 }
39337 return resultobj;
39338 fail:
39339 return NULL;
39340 }
39341
39342
39343 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39344 PyObject *resultobj;
39345 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39346 wxWindow *arg2 = (wxWindow *) 0 ;
39347 PyObject * obj0 = 0 ;
39348 PyObject * obj1 = 0 ;
39349 char *kwnames[] = {
39350 (char *) "self",(char *) "window", NULL
39351 };
39352
39353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39355 if (SWIG_arg_fail(1)) SWIG_fail;
39356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39357 if (SWIG_arg_fail(2)) SWIG_fail;
39358 {
39359 PyThreadState* __tstate = wxPyBeginAllowThreads();
39360 (arg1)->SetWindow(arg2);
39361
39362 wxPyEndAllowThreads(__tstate);
39363 if (PyErr_Occurred()) SWIG_fail;
39364 }
39365 Py_INCREF(Py_None); resultobj = Py_None;
39366 return resultobj;
39367 fail:
39368 return NULL;
39369 }
39370
39371
39372 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39373 PyObject *resultobj;
39374 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39375 wxSizer *result;
39376 PyObject * obj0 = 0 ;
39377 char *kwnames[] = {
39378 (char *) "self", NULL
39379 };
39380
39381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39383 if (SWIG_arg_fail(1)) SWIG_fail;
39384 {
39385 PyThreadState* __tstate = wxPyBeginAllowThreads();
39386 result = (wxSizer *)(arg1)->GetSizer();
39387
39388 wxPyEndAllowThreads(__tstate);
39389 if (PyErr_Occurred()) SWIG_fail;
39390 }
39391 {
39392 resultobj = wxPyMake_wxObject(result, 0);
39393 }
39394 return resultobj;
39395 fail:
39396 return NULL;
39397 }
39398
39399
39400 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39401 PyObject *resultobj;
39402 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39403 wxSizer *arg2 = (wxSizer *) 0 ;
39404 PyObject * obj0 = 0 ;
39405 PyObject * obj1 = 0 ;
39406 char *kwnames[] = {
39407 (char *) "self",(char *) "sizer", NULL
39408 };
39409
39410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39412 if (SWIG_arg_fail(1)) SWIG_fail;
39413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39414 if (SWIG_arg_fail(2)) SWIG_fail;
39415 {
39416 PyThreadState* __tstate = wxPyBeginAllowThreads();
39417 (arg1)->SetSizer(arg2);
39418
39419 wxPyEndAllowThreads(__tstate);
39420 if (PyErr_Occurred()) SWIG_fail;
39421 }
39422 Py_INCREF(Py_None); resultobj = Py_None;
39423 return resultobj;
39424 fail:
39425 return NULL;
39426 }
39427
39428
39429 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39430 PyObject *resultobj;
39431 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39432 wxSize *result;
39433 PyObject * obj0 = 0 ;
39434 char *kwnames[] = {
39435 (char *) "self", NULL
39436 };
39437
39438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39440 if (SWIG_arg_fail(1)) SWIG_fail;
39441 {
39442 PyThreadState* __tstate = wxPyBeginAllowThreads();
39443 {
39444 wxSize const &_result_ref = (arg1)->GetSpacer();
39445 result = (wxSize *) &_result_ref;
39446 }
39447
39448 wxPyEndAllowThreads(__tstate);
39449 if (PyErr_Occurred()) SWIG_fail;
39450 }
39451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39452 return resultobj;
39453 fail:
39454 return NULL;
39455 }
39456
39457
39458 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39459 PyObject *resultobj;
39460 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39461 wxSize *arg2 = 0 ;
39462 wxSize temp2 ;
39463 PyObject * obj0 = 0 ;
39464 PyObject * obj1 = 0 ;
39465 char *kwnames[] = {
39466 (char *) "self",(char *) "size", NULL
39467 };
39468
39469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39471 if (SWIG_arg_fail(1)) SWIG_fail;
39472 {
39473 arg2 = &temp2;
39474 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39475 }
39476 {
39477 PyThreadState* __tstate = wxPyBeginAllowThreads();
39478 (arg1)->SetSpacer((wxSize const &)*arg2);
39479
39480 wxPyEndAllowThreads(__tstate);
39481 if (PyErr_Occurred()) SWIG_fail;
39482 }
39483 Py_INCREF(Py_None); resultobj = Py_None;
39484 return resultobj;
39485 fail:
39486 return NULL;
39487 }
39488
39489
39490 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39491 PyObject *resultobj;
39492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39493 bool arg2 ;
39494 PyObject * obj0 = 0 ;
39495 PyObject * obj1 = 0 ;
39496 char *kwnames[] = {
39497 (char *) "self",(char *) "show", NULL
39498 };
39499
39500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39502 if (SWIG_arg_fail(1)) SWIG_fail;
39503 {
39504 arg2 = (bool)(SWIG_As_bool(obj1));
39505 if (SWIG_arg_fail(2)) SWIG_fail;
39506 }
39507 {
39508 PyThreadState* __tstate = wxPyBeginAllowThreads();
39509 (arg1)->Show(arg2);
39510
39511 wxPyEndAllowThreads(__tstate);
39512 if (PyErr_Occurred()) SWIG_fail;
39513 }
39514 Py_INCREF(Py_None); resultobj = Py_None;
39515 return resultobj;
39516 fail:
39517 return NULL;
39518 }
39519
39520
39521 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39522 PyObject *resultobj;
39523 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39524 bool result;
39525 PyObject * obj0 = 0 ;
39526 char *kwnames[] = {
39527 (char *) "self", NULL
39528 };
39529
39530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39532 if (SWIG_arg_fail(1)) SWIG_fail;
39533 {
39534 PyThreadState* __tstate = wxPyBeginAllowThreads();
39535 result = (bool)(arg1)->IsShown();
39536
39537 wxPyEndAllowThreads(__tstate);
39538 if (PyErr_Occurred()) SWIG_fail;
39539 }
39540 {
39541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39542 }
39543 return resultobj;
39544 fail:
39545 return NULL;
39546 }
39547
39548
39549 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39550 PyObject *resultobj;
39551 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39552 wxPoint result;
39553 PyObject * obj0 = 0 ;
39554 char *kwnames[] = {
39555 (char *) "self", NULL
39556 };
39557
39558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39560 if (SWIG_arg_fail(1)) SWIG_fail;
39561 {
39562 PyThreadState* __tstate = wxPyBeginAllowThreads();
39563 result = (arg1)->GetPosition();
39564
39565 wxPyEndAllowThreads(__tstate);
39566 if (PyErr_Occurred()) SWIG_fail;
39567 }
39568 {
39569 wxPoint * resultptr;
39570 resultptr = new wxPoint((wxPoint &)(result));
39571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39572 }
39573 return resultobj;
39574 fail:
39575 return NULL;
39576 }
39577
39578
39579 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39580 PyObject *resultobj;
39581 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39582 PyObject *result;
39583 PyObject * obj0 = 0 ;
39584 char *kwnames[] = {
39585 (char *) "self", NULL
39586 };
39587
39588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39590 if (SWIG_arg_fail(1)) SWIG_fail;
39591 {
39592 PyThreadState* __tstate = wxPyBeginAllowThreads();
39593 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39594
39595 wxPyEndAllowThreads(__tstate);
39596 if (PyErr_Occurred()) SWIG_fail;
39597 }
39598 resultobj = result;
39599 return resultobj;
39600 fail:
39601 return NULL;
39602 }
39603
39604
39605 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39606 PyObject *obj;
39607 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39608 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39609 Py_INCREF(obj);
39610 return Py_BuildValue((char *)"");
39611 }
39612 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39613 PyObject *resultobj;
39614 wxSizer *arg1 = (wxSizer *) 0 ;
39615 PyObject *arg2 = (PyObject *) 0 ;
39616 PyObject * obj0 = 0 ;
39617 PyObject * obj1 = 0 ;
39618 char *kwnames[] = {
39619 (char *) "self",(char *) "_self", NULL
39620 };
39621
39622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39624 if (SWIG_arg_fail(1)) SWIG_fail;
39625 arg2 = obj1;
39626 {
39627 PyThreadState* __tstate = wxPyBeginAllowThreads();
39628 wxSizer__setOORInfo(arg1,arg2);
39629
39630 wxPyEndAllowThreads(__tstate);
39631 if (PyErr_Occurred()) SWIG_fail;
39632 }
39633 Py_INCREF(Py_None); resultobj = Py_None;
39634 return resultobj;
39635 fail:
39636 return NULL;
39637 }
39638
39639
39640 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39641 PyObject *resultobj;
39642 wxSizer *arg1 = (wxSizer *) 0 ;
39643 PyObject *arg2 = (PyObject *) 0 ;
39644 int arg3 = (int) 0 ;
39645 int arg4 = (int) 0 ;
39646 int arg5 = (int) 0 ;
39647 PyObject *arg6 = (PyObject *) NULL ;
39648 wxSizerItem *result;
39649 PyObject * obj0 = 0 ;
39650 PyObject * obj1 = 0 ;
39651 PyObject * obj2 = 0 ;
39652 PyObject * obj3 = 0 ;
39653 PyObject * obj4 = 0 ;
39654 PyObject * obj5 = 0 ;
39655 char *kwnames[] = {
39656 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39657 };
39658
39659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39661 if (SWIG_arg_fail(1)) SWIG_fail;
39662 arg2 = obj1;
39663 if (obj2) {
39664 {
39665 arg3 = (int)(SWIG_As_int(obj2));
39666 if (SWIG_arg_fail(3)) SWIG_fail;
39667 }
39668 }
39669 if (obj3) {
39670 {
39671 arg4 = (int)(SWIG_As_int(obj3));
39672 if (SWIG_arg_fail(4)) SWIG_fail;
39673 }
39674 }
39675 if (obj4) {
39676 {
39677 arg5 = (int)(SWIG_As_int(obj4));
39678 if (SWIG_arg_fail(5)) SWIG_fail;
39679 }
39680 }
39681 if (obj5) {
39682 arg6 = obj5;
39683 }
39684 {
39685 PyThreadState* __tstate = wxPyBeginAllowThreads();
39686 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39687
39688 wxPyEndAllowThreads(__tstate);
39689 if (PyErr_Occurred()) SWIG_fail;
39690 }
39691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39692 return resultobj;
39693 fail:
39694 return NULL;
39695 }
39696
39697
39698 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39699 PyObject *resultobj;
39700 wxSizer *arg1 = (wxSizer *) 0 ;
39701 int arg2 ;
39702 PyObject *arg3 = (PyObject *) 0 ;
39703 int arg4 = (int) 0 ;
39704 int arg5 = (int) 0 ;
39705 int arg6 = (int) 0 ;
39706 PyObject *arg7 = (PyObject *) NULL ;
39707 wxSizerItem *result;
39708 PyObject * obj0 = 0 ;
39709 PyObject * obj1 = 0 ;
39710 PyObject * obj2 = 0 ;
39711 PyObject * obj3 = 0 ;
39712 PyObject * obj4 = 0 ;
39713 PyObject * obj5 = 0 ;
39714 PyObject * obj6 = 0 ;
39715 char *kwnames[] = {
39716 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39717 };
39718
39719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39721 if (SWIG_arg_fail(1)) SWIG_fail;
39722 {
39723 arg2 = (int)(SWIG_As_int(obj1));
39724 if (SWIG_arg_fail(2)) SWIG_fail;
39725 }
39726 arg3 = obj2;
39727 if (obj3) {
39728 {
39729 arg4 = (int)(SWIG_As_int(obj3));
39730 if (SWIG_arg_fail(4)) SWIG_fail;
39731 }
39732 }
39733 if (obj4) {
39734 {
39735 arg5 = (int)(SWIG_As_int(obj4));
39736 if (SWIG_arg_fail(5)) SWIG_fail;
39737 }
39738 }
39739 if (obj5) {
39740 {
39741 arg6 = (int)(SWIG_As_int(obj5));
39742 if (SWIG_arg_fail(6)) SWIG_fail;
39743 }
39744 }
39745 if (obj6) {
39746 arg7 = obj6;
39747 }
39748 {
39749 PyThreadState* __tstate = wxPyBeginAllowThreads();
39750 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39751
39752 wxPyEndAllowThreads(__tstate);
39753 if (PyErr_Occurred()) SWIG_fail;
39754 }
39755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39756 return resultobj;
39757 fail:
39758 return NULL;
39759 }
39760
39761
39762 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39763 PyObject *resultobj;
39764 wxSizer *arg1 = (wxSizer *) 0 ;
39765 PyObject *arg2 = (PyObject *) 0 ;
39766 int arg3 = (int) 0 ;
39767 int arg4 = (int) 0 ;
39768 int arg5 = (int) 0 ;
39769 PyObject *arg6 = (PyObject *) NULL ;
39770 wxSizerItem *result;
39771 PyObject * obj0 = 0 ;
39772 PyObject * obj1 = 0 ;
39773 PyObject * obj2 = 0 ;
39774 PyObject * obj3 = 0 ;
39775 PyObject * obj4 = 0 ;
39776 PyObject * obj5 = 0 ;
39777 char *kwnames[] = {
39778 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39779 };
39780
39781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39783 if (SWIG_arg_fail(1)) SWIG_fail;
39784 arg2 = obj1;
39785 if (obj2) {
39786 {
39787 arg3 = (int)(SWIG_As_int(obj2));
39788 if (SWIG_arg_fail(3)) SWIG_fail;
39789 }
39790 }
39791 if (obj3) {
39792 {
39793 arg4 = (int)(SWIG_As_int(obj3));
39794 if (SWIG_arg_fail(4)) SWIG_fail;
39795 }
39796 }
39797 if (obj4) {
39798 {
39799 arg5 = (int)(SWIG_As_int(obj4));
39800 if (SWIG_arg_fail(5)) SWIG_fail;
39801 }
39802 }
39803 if (obj5) {
39804 arg6 = obj5;
39805 }
39806 {
39807 PyThreadState* __tstate = wxPyBeginAllowThreads();
39808 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39809
39810 wxPyEndAllowThreads(__tstate);
39811 if (PyErr_Occurred()) SWIG_fail;
39812 }
39813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39814 return resultobj;
39815 fail:
39816 return NULL;
39817 }
39818
39819
39820 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39821 PyObject *resultobj;
39822 wxSizer *arg1 = (wxSizer *) 0 ;
39823 PyObject *arg2 = (PyObject *) 0 ;
39824 bool result;
39825 PyObject * obj0 = 0 ;
39826 PyObject * obj1 = 0 ;
39827 char *kwnames[] = {
39828 (char *) "self",(char *) "item", NULL
39829 };
39830
39831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39833 if (SWIG_arg_fail(1)) SWIG_fail;
39834 arg2 = obj1;
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 result = (bool)wxSizer_Remove(arg1,arg2);
39838
39839 wxPyEndAllowThreads(__tstate);
39840 if (PyErr_Occurred()) SWIG_fail;
39841 }
39842 {
39843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39844 }
39845 return resultobj;
39846 fail:
39847 return NULL;
39848 }
39849
39850
39851 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39852 PyObject *resultobj;
39853 wxSizer *arg1 = (wxSizer *) 0 ;
39854 PyObject *arg2 = (PyObject *) 0 ;
39855 bool result;
39856 PyObject * obj0 = 0 ;
39857 PyObject * obj1 = 0 ;
39858 char *kwnames[] = {
39859 (char *) "self",(char *) "item", NULL
39860 };
39861
39862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39864 if (SWIG_arg_fail(1)) SWIG_fail;
39865 arg2 = obj1;
39866 {
39867 PyThreadState* __tstate = wxPyBeginAllowThreads();
39868 result = (bool)wxSizer_Detach(arg1,arg2);
39869
39870 wxPyEndAllowThreads(__tstate);
39871 if (PyErr_Occurred()) SWIG_fail;
39872 }
39873 {
39874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39875 }
39876 return resultobj;
39877 fail:
39878 return NULL;
39879 }
39880
39881
39882 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39883 PyObject *resultobj;
39884 wxSizer *arg1 = (wxSizer *) 0 ;
39885 PyObject *arg2 = (PyObject *) 0 ;
39886 wxSizerItem *result;
39887 PyObject * obj0 = 0 ;
39888 PyObject * obj1 = 0 ;
39889 char *kwnames[] = {
39890 (char *) "self",(char *) "item", NULL
39891 };
39892
39893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39895 if (SWIG_arg_fail(1)) SWIG_fail;
39896 arg2 = obj1;
39897 {
39898 PyThreadState* __tstate = wxPyBeginAllowThreads();
39899 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39900
39901 wxPyEndAllowThreads(__tstate);
39902 if (PyErr_Occurred()) SWIG_fail;
39903 }
39904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39905 return resultobj;
39906 fail:
39907 return NULL;
39908 }
39909
39910
39911 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39912 PyObject *resultobj;
39913 wxSizer *arg1 = (wxSizer *) 0 ;
39914 PyObject *arg2 = (PyObject *) 0 ;
39915 wxSize *arg3 = 0 ;
39916 wxSize temp3 ;
39917 PyObject * obj0 = 0 ;
39918 PyObject * obj1 = 0 ;
39919 PyObject * obj2 = 0 ;
39920 char *kwnames[] = {
39921 (char *) "self",(char *) "item",(char *) "size", NULL
39922 };
39923
39924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39926 if (SWIG_arg_fail(1)) SWIG_fail;
39927 arg2 = obj1;
39928 {
39929 arg3 = &temp3;
39930 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39931 }
39932 {
39933 PyThreadState* __tstate = wxPyBeginAllowThreads();
39934 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39935
39936 wxPyEndAllowThreads(__tstate);
39937 if (PyErr_Occurred()) SWIG_fail;
39938 }
39939 Py_INCREF(Py_None); resultobj = Py_None;
39940 return resultobj;
39941 fail:
39942 return NULL;
39943 }
39944
39945
39946 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj;
39948 wxSizer *arg1 = (wxSizer *) 0 ;
39949 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39950 wxSizerItem *result;
39951 PyObject * obj0 = 0 ;
39952 PyObject * obj1 = 0 ;
39953 char *kwnames[] = {
39954 (char *) "self",(char *) "item", NULL
39955 };
39956
39957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39959 if (SWIG_arg_fail(1)) SWIG_fail;
39960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39961 if (SWIG_arg_fail(2)) SWIG_fail;
39962 {
39963 PyThreadState* __tstate = wxPyBeginAllowThreads();
39964 result = (wxSizerItem *)(arg1)->Add(arg2);
39965
39966 wxPyEndAllowThreads(__tstate);
39967 if (PyErr_Occurred()) SWIG_fail;
39968 }
39969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39970 return resultobj;
39971 fail:
39972 return NULL;
39973 }
39974
39975
39976 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39977 PyObject *resultobj;
39978 wxSizer *arg1 = (wxSizer *) 0 ;
39979 size_t arg2 ;
39980 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39981 wxSizerItem *result;
39982 PyObject * obj0 = 0 ;
39983 PyObject * obj1 = 0 ;
39984 PyObject * obj2 = 0 ;
39985 char *kwnames[] = {
39986 (char *) "self",(char *) "index",(char *) "item", NULL
39987 };
39988
39989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39991 if (SWIG_arg_fail(1)) SWIG_fail;
39992 {
39993 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39994 if (SWIG_arg_fail(2)) SWIG_fail;
39995 }
39996 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39997 if (SWIG_arg_fail(3)) SWIG_fail;
39998 {
39999 PyThreadState* __tstate = wxPyBeginAllowThreads();
40000 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40001
40002 wxPyEndAllowThreads(__tstate);
40003 if (PyErr_Occurred()) SWIG_fail;
40004 }
40005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40013 PyObject *resultobj;
40014 wxSizer *arg1 = (wxSizer *) 0 ;
40015 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40016 wxSizerItem *result;
40017 PyObject * obj0 = 0 ;
40018 PyObject * obj1 = 0 ;
40019 char *kwnames[] = {
40020 (char *) "self",(char *) "item", NULL
40021 };
40022
40023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40025 if (SWIG_arg_fail(1)) SWIG_fail;
40026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40027 if (SWIG_arg_fail(2)) SWIG_fail;
40028 {
40029 PyThreadState* __tstate = wxPyBeginAllowThreads();
40030 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40031
40032 wxPyEndAllowThreads(__tstate);
40033 if (PyErr_Occurred()) SWIG_fail;
40034 }
40035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40036 return resultobj;
40037 fail:
40038 return NULL;
40039 }
40040
40041
40042 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40043 PyObject *resultobj;
40044 wxSizer *arg1 = (wxSizer *) 0 ;
40045 int arg2 ;
40046 int arg3 ;
40047 int arg4 ;
40048 int arg5 ;
40049 PyObject * obj0 = 0 ;
40050 PyObject * obj1 = 0 ;
40051 PyObject * obj2 = 0 ;
40052 PyObject * obj3 = 0 ;
40053 PyObject * obj4 = 0 ;
40054 char *kwnames[] = {
40055 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40056 };
40057
40058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40060 if (SWIG_arg_fail(1)) SWIG_fail;
40061 {
40062 arg2 = (int)(SWIG_As_int(obj1));
40063 if (SWIG_arg_fail(2)) SWIG_fail;
40064 }
40065 {
40066 arg3 = (int)(SWIG_As_int(obj2));
40067 if (SWIG_arg_fail(3)) SWIG_fail;
40068 }
40069 {
40070 arg4 = (int)(SWIG_As_int(obj3));
40071 if (SWIG_arg_fail(4)) SWIG_fail;
40072 }
40073 {
40074 arg5 = (int)(SWIG_As_int(obj4));
40075 if (SWIG_arg_fail(5)) SWIG_fail;
40076 }
40077 {
40078 PyThreadState* __tstate = wxPyBeginAllowThreads();
40079 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40080
40081 wxPyEndAllowThreads(__tstate);
40082 if (PyErr_Occurred()) SWIG_fail;
40083 }
40084 Py_INCREF(Py_None); resultobj = Py_None;
40085 return resultobj;
40086 fail:
40087 return NULL;
40088 }
40089
40090
40091 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40092 PyObject *resultobj;
40093 wxSizer *arg1 = (wxSizer *) 0 ;
40094 wxSize *arg2 = 0 ;
40095 wxSize temp2 ;
40096 PyObject * obj0 = 0 ;
40097 PyObject * obj1 = 0 ;
40098 char *kwnames[] = {
40099 (char *) "self",(char *) "size", NULL
40100 };
40101
40102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40104 if (SWIG_arg_fail(1)) SWIG_fail;
40105 {
40106 arg2 = &temp2;
40107 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40108 }
40109 {
40110 PyThreadState* __tstate = wxPyBeginAllowThreads();
40111 (arg1)->SetMinSize((wxSize const &)*arg2);
40112
40113 wxPyEndAllowThreads(__tstate);
40114 if (PyErr_Occurred()) SWIG_fail;
40115 }
40116 Py_INCREF(Py_None); resultobj = Py_None;
40117 return resultobj;
40118 fail:
40119 return NULL;
40120 }
40121
40122
40123 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40124 PyObject *resultobj;
40125 wxSizer *arg1 = (wxSizer *) 0 ;
40126 wxSize result;
40127 PyObject * obj0 = 0 ;
40128 char *kwnames[] = {
40129 (char *) "self", NULL
40130 };
40131
40132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40134 if (SWIG_arg_fail(1)) SWIG_fail;
40135 {
40136 PyThreadState* __tstate = wxPyBeginAllowThreads();
40137 result = (arg1)->GetSize();
40138
40139 wxPyEndAllowThreads(__tstate);
40140 if (PyErr_Occurred()) SWIG_fail;
40141 }
40142 {
40143 wxSize * resultptr;
40144 resultptr = new wxSize((wxSize &)(result));
40145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40146 }
40147 return resultobj;
40148 fail:
40149 return NULL;
40150 }
40151
40152
40153 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40154 PyObject *resultobj;
40155 wxSizer *arg1 = (wxSizer *) 0 ;
40156 wxPoint result;
40157 PyObject * obj0 = 0 ;
40158 char *kwnames[] = {
40159 (char *) "self", NULL
40160 };
40161
40162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40164 if (SWIG_arg_fail(1)) SWIG_fail;
40165 {
40166 PyThreadState* __tstate = wxPyBeginAllowThreads();
40167 result = (arg1)->GetPosition();
40168
40169 wxPyEndAllowThreads(__tstate);
40170 if (PyErr_Occurred()) SWIG_fail;
40171 }
40172 {
40173 wxPoint * resultptr;
40174 resultptr = new wxPoint((wxPoint &)(result));
40175 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40176 }
40177 return resultobj;
40178 fail:
40179 return NULL;
40180 }
40181
40182
40183 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40184 PyObject *resultobj;
40185 wxSizer *arg1 = (wxSizer *) 0 ;
40186 wxSize result;
40187 PyObject * obj0 = 0 ;
40188 char *kwnames[] = {
40189 (char *) "self", NULL
40190 };
40191
40192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40194 if (SWIG_arg_fail(1)) SWIG_fail;
40195 {
40196 PyThreadState* __tstate = wxPyBeginAllowThreads();
40197 result = (arg1)->GetMinSize();
40198
40199 wxPyEndAllowThreads(__tstate);
40200 if (PyErr_Occurred()) SWIG_fail;
40201 }
40202 {
40203 wxSize * resultptr;
40204 resultptr = new wxSize((wxSize &)(result));
40205 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40206 }
40207 return resultobj;
40208 fail:
40209 return NULL;
40210 }
40211
40212
40213 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40214 PyObject *resultobj;
40215 wxSizer *arg1 = (wxSizer *) 0 ;
40216 PyObject * obj0 = 0 ;
40217 char *kwnames[] = {
40218 (char *) "self", NULL
40219 };
40220
40221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40223 if (SWIG_arg_fail(1)) SWIG_fail;
40224 {
40225 PyThreadState* __tstate = wxPyBeginAllowThreads();
40226 (arg1)->RecalcSizes();
40227
40228 wxPyEndAllowThreads(__tstate);
40229 if (PyErr_Occurred()) SWIG_fail;
40230 }
40231 Py_INCREF(Py_None); resultobj = Py_None;
40232 return resultobj;
40233 fail:
40234 return NULL;
40235 }
40236
40237
40238 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40239 PyObject *resultobj;
40240 wxSizer *arg1 = (wxSizer *) 0 ;
40241 wxSize result;
40242 PyObject * obj0 = 0 ;
40243 char *kwnames[] = {
40244 (char *) "self", NULL
40245 };
40246
40247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40249 if (SWIG_arg_fail(1)) SWIG_fail;
40250 {
40251 PyThreadState* __tstate = wxPyBeginAllowThreads();
40252 result = (arg1)->CalcMin();
40253
40254 wxPyEndAllowThreads(__tstate);
40255 if (PyErr_Occurred()) SWIG_fail;
40256 }
40257 {
40258 wxSize * resultptr;
40259 resultptr = new wxSize((wxSize &)(result));
40260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40261 }
40262 return resultobj;
40263 fail:
40264 return NULL;
40265 }
40266
40267
40268 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40269 PyObject *resultobj;
40270 wxSizer *arg1 = (wxSizer *) 0 ;
40271 PyObject * obj0 = 0 ;
40272 char *kwnames[] = {
40273 (char *) "self", NULL
40274 };
40275
40276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40278 if (SWIG_arg_fail(1)) SWIG_fail;
40279 {
40280 PyThreadState* __tstate = wxPyBeginAllowThreads();
40281 (arg1)->Layout();
40282
40283 wxPyEndAllowThreads(__tstate);
40284 if (PyErr_Occurred()) SWIG_fail;
40285 }
40286 Py_INCREF(Py_None); resultobj = Py_None;
40287 return resultobj;
40288 fail:
40289 return NULL;
40290 }
40291
40292
40293 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40294 PyObject *resultobj;
40295 wxSizer *arg1 = (wxSizer *) 0 ;
40296 wxWindow *arg2 = (wxWindow *) 0 ;
40297 wxSize result;
40298 PyObject * obj0 = 0 ;
40299 PyObject * obj1 = 0 ;
40300 char *kwnames[] = {
40301 (char *) "self",(char *) "window", NULL
40302 };
40303
40304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40306 if (SWIG_arg_fail(1)) SWIG_fail;
40307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40308 if (SWIG_arg_fail(2)) SWIG_fail;
40309 {
40310 PyThreadState* __tstate = wxPyBeginAllowThreads();
40311 result = (arg1)->Fit(arg2);
40312
40313 wxPyEndAllowThreads(__tstate);
40314 if (PyErr_Occurred()) SWIG_fail;
40315 }
40316 {
40317 wxSize * resultptr;
40318 resultptr = new wxSize((wxSize &)(result));
40319 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40320 }
40321 return resultobj;
40322 fail:
40323 return NULL;
40324 }
40325
40326
40327 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40328 PyObject *resultobj;
40329 wxSizer *arg1 = (wxSizer *) 0 ;
40330 wxWindow *arg2 = (wxWindow *) 0 ;
40331 PyObject * obj0 = 0 ;
40332 PyObject * obj1 = 0 ;
40333 char *kwnames[] = {
40334 (char *) "self",(char *) "window", NULL
40335 };
40336
40337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40339 if (SWIG_arg_fail(1)) SWIG_fail;
40340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40341 if (SWIG_arg_fail(2)) SWIG_fail;
40342 {
40343 PyThreadState* __tstate = wxPyBeginAllowThreads();
40344 (arg1)->FitInside(arg2);
40345
40346 wxPyEndAllowThreads(__tstate);
40347 if (PyErr_Occurred()) SWIG_fail;
40348 }
40349 Py_INCREF(Py_None); resultobj = Py_None;
40350 return resultobj;
40351 fail:
40352 return NULL;
40353 }
40354
40355
40356 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40357 PyObject *resultobj;
40358 wxSizer *arg1 = (wxSizer *) 0 ;
40359 wxWindow *arg2 = (wxWindow *) 0 ;
40360 PyObject * obj0 = 0 ;
40361 PyObject * obj1 = 0 ;
40362 char *kwnames[] = {
40363 (char *) "self",(char *) "window", NULL
40364 };
40365
40366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40368 if (SWIG_arg_fail(1)) SWIG_fail;
40369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40370 if (SWIG_arg_fail(2)) SWIG_fail;
40371 {
40372 PyThreadState* __tstate = wxPyBeginAllowThreads();
40373 (arg1)->SetSizeHints(arg2);
40374
40375 wxPyEndAllowThreads(__tstate);
40376 if (PyErr_Occurred()) SWIG_fail;
40377 }
40378 Py_INCREF(Py_None); resultobj = Py_None;
40379 return resultobj;
40380 fail:
40381 return NULL;
40382 }
40383
40384
40385 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40386 PyObject *resultobj;
40387 wxSizer *arg1 = (wxSizer *) 0 ;
40388 wxWindow *arg2 = (wxWindow *) 0 ;
40389 PyObject * obj0 = 0 ;
40390 PyObject * obj1 = 0 ;
40391 char *kwnames[] = {
40392 (char *) "self",(char *) "window", NULL
40393 };
40394
40395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40397 if (SWIG_arg_fail(1)) SWIG_fail;
40398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40399 if (SWIG_arg_fail(2)) SWIG_fail;
40400 {
40401 PyThreadState* __tstate = wxPyBeginAllowThreads();
40402 (arg1)->SetVirtualSizeHints(arg2);
40403
40404 wxPyEndAllowThreads(__tstate);
40405 if (PyErr_Occurred()) SWIG_fail;
40406 }
40407 Py_INCREF(Py_None); resultobj = Py_None;
40408 return resultobj;
40409 fail:
40410 return NULL;
40411 }
40412
40413
40414 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40415 PyObject *resultobj;
40416 wxSizer *arg1 = (wxSizer *) 0 ;
40417 bool arg2 = (bool) false ;
40418 PyObject * obj0 = 0 ;
40419 PyObject * obj1 = 0 ;
40420 char *kwnames[] = {
40421 (char *) "self",(char *) "deleteWindows", NULL
40422 };
40423
40424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40426 if (SWIG_arg_fail(1)) SWIG_fail;
40427 if (obj1) {
40428 {
40429 arg2 = (bool)(SWIG_As_bool(obj1));
40430 if (SWIG_arg_fail(2)) SWIG_fail;
40431 }
40432 }
40433 {
40434 PyThreadState* __tstate = wxPyBeginAllowThreads();
40435 (arg1)->Clear(arg2);
40436
40437 wxPyEndAllowThreads(__tstate);
40438 if (PyErr_Occurred()) SWIG_fail;
40439 }
40440 Py_INCREF(Py_None); resultobj = Py_None;
40441 return resultobj;
40442 fail:
40443 return NULL;
40444 }
40445
40446
40447 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40448 PyObject *resultobj;
40449 wxSizer *arg1 = (wxSizer *) 0 ;
40450 PyObject * obj0 = 0 ;
40451 char *kwnames[] = {
40452 (char *) "self", NULL
40453 };
40454
40455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40457 if (SWIG_arg_fail(1)) SWIG_fail;
40458 {
40459 PyThreadState* __tstate = wxPyBeginAllowThreads();
40460 (arg1)->DeleteWindows();
40461
40462 wxPyEndAllowThreads(__tstate);
40463 if (PyErr_Occurred()) SWIG_fail;
40464 }
40465 Py_INCREF(Py_None); resultobj = Py_None;
40466 return resultobj;
40467 fail:
40468 return NULL;
40469 }
40470
40471
40472 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40473 PyObject *resultobj;
40474 wxSizer *arg1 = (wxSizer *) 0 ;
40475 PyObject *result;
40476 PyObject * obj0 = 0 ;
40477 char *kwnames[] = {
40478 (char *) "self", NULL
40479 };
40480
40481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40483 if (SWIG_arg_fail(1)) SWIG_fail;
40484 {
40485 PyThreadState* __tstate = wxPyBeginAllowThreads();
40486 result = (PyObject *)wxSizer_GetChildren(arg1);
40487
40488 wxPyEndAllowThreads(__tstate);
40489 if (PyErr_Occurred()) SWIG_fail;
40490 }
40491 resultobj = result;
40492 return resultobj;
40493 fail:
40494 return NULL;
40495 }
40496
40497
40498 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40499 PyObject *resultobj;
40500 wxSizer *arg1 = (wxSizer *) 0 ;
40501 PyObject *arg2 = (PyObject *) 0 ;
40502 bool arg3 = (bool) true ;
40503 bool arg4 = (bool) false ;
40504 bool result;
40505 PyObject * obj0 = 0 ;
40506 PyObject * obj1 = 0 ;
40507 PyObject * obj2 = 0 ;
40508 PyObject * obj3 = 0 ;
40509 char *kwnames[] = {
40510 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40511 };
40512
40513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40515 if (SWIG_arg_fail(1)) SWIG_fail;
40516 arg2 = obj1;
40517 if (obj2) {
40518 {
40519 arg3 = (bool)(SWIG_As_bool(obj2));
40520 if (SWIG_arg_fail(3)) SWIG_fail;
40521 }
40522 }
40523 if (obj3) {
40524 {
40525 arg4 = (bool)(SWIG_As_bool(obj3));
40526 if (SWIG_arg_fail(4)) SWIG_fail;
40527 }
40528 }
40529 {
40530 PyThreadState* __tstate = wxPyBeginAllowThreads();
40531 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40532
40533 wxPyEndAllowThreads(__tstate);
40534 if (PyErr_Occurred()) SWIG_fail;
40535 }
40536 {
40537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40538 }
40539 return resultobj;
40540 fail:
40541 return NULL;
40542 }
40543
40544
40545 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40546 PyObject *resultobj;
40547 wxSizer *arg1 = (wxSizer *) 0 ;
40548 PyObject *arg2 = (PyObject *) 0 ;
40549 bool result;
40550 PyObject * obj0 = 0 ;
40551 PyObject * obj1 = 0 ;
40552 char *kwnames[] = {
40553 (char *) "self",(char *) "item", NULL
40554 };
40555
40556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40558 if (SWIG_arg_fail(1)) SWIG_fail;
40559 arg2 = obj1;
40560 {
40561 PyThreadState* __tstate = wxPyBeginAllowThreads();
40562 result = (bool)wxSizer_IsShown(arg1,arg2);
40563
40564 wxPyEndAllowThreads(__tstate);
40565 if (PyErr_Occurred()) SWIG_fail;
40566 }
40567 {
40568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40569 }
40570 return resultobj;
40571 fail:
40572 return NULL;
40573 }
40574
40575
40576 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40577 PyObject *resultobj;
40578 wxSizer *arg1 = (wxSizer *) 0 ;
40579 bool arg2 ;
40580 PyObject * obj0 = 0 ;
40581 PyObject * obj1 = 0 ;
40582 char *kwnames[] = {
40583 (char *) "self",(char *) "show", NULL
40584 };
40585
40586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40588 if (SWIG_arg_fail(1)) SWIG_fail;
40589 {
40590 arg2 = (bool)(SWIG_As_bool(obj1));
40591 if (SWIG_arg_fail(2)) SWIG_fail;
40592 }
40593 {
40594 PyThreadState* __tstate = wxPyBeginAllowThreads();
40595 (arg1)->ShowItems(arg2);
40596
40597 wxPyEndAllowThreads(__tstate);
40598 if (PyErr_Occurred()) SWIG_fail;
40599 }
40600 Py_INCREF(Py_None); resultobj = Py_None;
40601 return resultobj;
40602 fail:
40603 return NULL;
40604 }
40605
40606
40607 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40608 PyObject *obj;
40609 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40610 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40611 Py_INCREF(obj);
40612 return Py_BuildValue((char *)"");
40613 }
40614 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40615 PyObject *resultobj;
40616 wxPySizer *result;
40617 char *kwnames[] = {
40618 NULL
40619 };
40620
40621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40622 {
40623 PyThreadState* __tstate = wxPyBeginAllowThreads();
40624 result = (wxPySizer *)new wxPySizer();
40625
40626 wxPyEndAllowThreads(__tstate);
40627 if (PyErr_Occurred()) SWIG_fail;
40628 }
40629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40630 return resultobj;
40631 fail:
40632 return NULL;
40633 }
40634
40635
40636 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40637 PyObject *resultobj;
40638 wxPySizer *arg1 = (wxPySizer *) 0 ;
40639 PyObject *arg2 = (PyObject *) 0 ;
40640 PyObject *arg3 = (PyObject *) 0 ;
40641 PyObject * obj0 = 0 ;
40642 PyObject * obj1 = 0 ;
40643 PyObject * obj2 = 0 ;
40644 char *kwnames[] = {
40645 (char *) "self",(char *) "self",(char *) "_class", NULL
40646 };
40647
40648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40650 if (SWIG_arg_fail(1)) SWIG_fail;
40651 arg2 = obj1;
40652 arg3 = obj2;
40653 {
40654 PyThreadState* __tstate = wxPyBeginAllowThreads();
40655 (arg1)->_setCallbackInfo(arg2,arg3);
40656
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 Py_INCREF(Py_None); resultobj = Py_None;
40661 return resultobj;
40662 fail:
40663 return NULL;
40664 }
40665
40666
40667 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40668 PyObject *obj;
40669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40670 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40671 Py_INCREF(obj);
40672 return Py_BuildValue((char *)"");
40673 }
40674 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40675 PyObject *resultobj;
40676 int arg1 = (int) wxHORIZONTAL ;
40677 wxBoxSizer *result;
40678 PyObject * obj0 = 0 ;
40679 char *kwnames[] = {
40680 (char *) "orient", NULL
40681 };
40682
40683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40684 if (obj0) {
40685 {
40686 arg1 = (int)(SWIG_As_int(obj0));
40687 if (SWIG_arg_fail(1)) SWIG_fail;
40688 }
40689 }
40690 {
40691 PyThreadState* __tstate = wxPyBeginAllowThreads();
40692 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40693
40694 wxPyEndAllowThreads(__tstate);
40695 if (PyErr_Occurred()) SWIG_fail;
40696 }
40697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40698 return resultobj;
40699 fail:
40700 return NULL;
40701 }
40702
40703
40704 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40705 PyObject *resultobj;
40706 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40707 int result;
40708 PyObject * obj0 = 0 ;
40709 char *kwnames[] = {
40710 (char *) "self", NULL
40711 };
40712
40713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40715 if (SWIG_arg_fail(1)) SWIG_fail;
40716 {
40717 PyThreadState* __tstate = wxPyBeginAllowThreads();
40718 result = (int)(arg1)->GetOrientation();
40719
40720 wxPyEndAllowThreads(__tstate);
40721 if (PyErr_Occurred()) SWIG_fail;
40722 }
40723 {
40724 resultobj = SWIG_From_int((int)(result));
40725 }
40726 return resultobj;
40727 fail:
40728 return NULL;
40729 }
40730
40731
40732 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40733 PyObject *resultobj;
40734 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40735 int arg2 ;
40736 PyObject * obj0 = 0 ;
40737 PyObject * obj1 = 0 ;
40738 char *kwnames[] = {
40739 (char *) "self",(char *) "orient", NULL
40740 };
40741
40742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40744 if (SWIG_arg_fail(1)) SWIG_fail;
40745 {
40746 arg2 = (int)(SWIG_As_int(obj1));
40747 if (SWIG_arg_fail(2)) SWIG_fail;
40748 }
40749 {
40750 PyThreadState* __tstate = wxPyBeginAllowThreads();
40751 (arg1)->SetOrientation(arg2);
40752
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 Py_INCREF(Py_None); resultobj = Py_None;
40757 return resultobj;
40758 fail:
40759 return NULL;
40760 }
40761
40762
40763 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40764 PyObject *obj;
40765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40766 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40767 Py_INCREF(obj);
40768 return Py_BuildValue((char *)"");
40769 }
40770 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40771 PyObject *resultobj;
40772 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40773 int arg2 = (int) wxHORIZONTAL ;
40774 wxStaticBoxSizer *result;
40775 PyObject * obj0 = 0 ;
40776 PyObject * obj1 = 0 ;
40777 char *kwnames[] = {
40778 (char *) "box",(char *) "orient", NULL
40779 };
40780
40781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40783 if (SWIG_arg_fail(1)) SWIG_fail;
40784 if (obj1) {
40785 {
40786 arg2 = (int)(SWIG_As_int(obj1));
40787 if (SWIG_arg_fail(2)) SWIG_fail;
40788 }
40789 }
40790 {
40791 PyThreadState* __tstate = wxPyBeginAllowThreads();
40792 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40793
40794 wxPyEndAllowThreads(__tstate);
40795 if (PyErr_Occurred()) SWIG_fail;
40796 }
40797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40798 return resultobj;
40799 fail:
40800 return NULL;
40801 }
40802
40803
40804 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40805 PyObject *resultobj;
40806 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40807 wxStaticBox *result;
40808 PyObject * obj0 = 0 ;
40809 char *kwnames[] = {
40810 (char *) "self", NULL
40811 };
40812
40813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40815 if (SWIG_arg_fail(1)) SWIG_fail;
40816 {
40817 PyThreadState* __tstate = wxPyBeginAllowThreads();
40818 result = (wxStaticBox *)(arg1)->GetStaticBox();
40819
40820 wxPyEndAllowThreads(__tstate);
40821 if (PyErr_Occurred()) SWIG_fail;
40822 }
40823 {
40824 resultobj = wxPyMake_wxObject(result, 0);
40825 }
40826 return resultobj;
40827 fail:
40828 return NULL;
40829 }
40830
40831
40832 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40833 PyObject *obj;
40834 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40835 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40836 Py_INCREF(obj);
40837 return Py_BuildValue((char *)"");
40838 }
40839 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40840 PyObject *resultobj;
40841 int arg1 = (int) 1 ;
40842 int arg2 = (int) 0 ;
40843 int arg3 = (int) 0 ;
40844 int arg4 = (int) 0 ;
40845 wxGridSizer *result;
40846 PyObject * obj0 = 0 ;
40847 PyObject * obj1 = 0 ;
40848 PyObject * obj2 = 0 ;
40849 PyObject * obj3 = 0 ;
40850 char *kwnames[] = {
40851 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40852 };
40853
40854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40855 if (obj0) {
40856 {
40857 arg1 = (int)(SWIG_As_int(obj0));
40858 if (SWIG_arg_fail(1)) SWIG_fail;
40859 }
40860 }
40861 if (obj1) {
40862 {
40863 arg2 = (int)(SWIG_As_int(obj1));
40864 if (SWIG_arg_fail(2)) SWIG_fail;
40865 }
40866 }
40867 if (obj2) {
40868 {
40869 arg3 = (int)(SWIG_As_int(obj2));
40870 if (SWIG_arg_fail(3)) SWIG_fail;
40871 }
40872 }
40873 if (obj3) {
40874 {
40875 arg4 = (int)(SWIG_As_int(obj3));
40876 if (SWIG_arg_fail(4)) SWIG_fail;
40877 }
40878 }
40879 {
40880 PyThreadState* __tstate = wxPyBeginAllowThreads();
40881 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40882
40883 wxPyEndAllowThreads(__tstate);
40884 if (PyErr_Occurred()) SWIG_fail;
40885 }
40886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40887 return resultobj;
40888 fail:
40889 return NULL;
40890 }
40891
40892
40893 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40894 PyObject *resultobj;
40895 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40896 int arg2 ;
40897 PyObject * obj0 = 0 ;
40898 PyObject * obj1 = 0 ;
40899 char *kwnames[] = {
40900 (char *) "self",(char *) "cols", NULL
40901 };
40902
40903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
40908 if (SWIG_arg_fail(2)) SWIG_fail;
40909 }
40910 {
40911 PyThreadState* __tstate = wxPyBeginAllowThreads();
40912 (arg1)->SetCols(arg2);
40913
40914 wxPyEndAllowThreads(__tstate);
40915 if (PyErr_Occurred()) SWIG_fail;
40916 }
40917 Py_INCREF(Py_None); resultobj = Py_None;
40918 return resultobj;
40919 fail:
40920 return NULL;
40921 }
40922
40923
40924 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40925 PyObject *resultobj;
40926 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40927 int arg2 ;
40928 PyObject * obj0 = 0 ;
40929 PyObject * obj1 = 0 ;
40930 char *kwnames[] = {
40931 (char *) "self",(char *) "rows", NULL
40932 };
40933
40934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40936 if (SWIG_arg_fail(1)) SWIG_fail;
40937 {
40938 arg2 = (int)(SWIG_As_int(obj1));
40939 if (SWIG_arg_fail(2)) SWIG_fail;
40940 }
40941 {
40942 PyThreadState* __tstate = wxPyBeginAllowThreads();
40943 (arg1)->SetRows(arg2);
40944
40945 wxPyEndAllowThreads(__tstate);
40946 if (PyErr_Occurred()) SWIG_fail;
40947 }
40948 Py_INCREF(Py_None); resultobj = Py_None;
40949 return resultobj;
40950 fail:
40951 return NULL;
40952 }
40953
40954
40955 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40956 PyObject *resultobj;
40957 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40958 int arg2 ;
40959 PyObject * obj0 = 0 ;
40960 PyObject * obj1 = 0 ;
40961 char *kwnames[] = {
40962 (char *) "self",(char *) "gap", NULL
40963 };
40964
40965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40967 if (SWIG_arg_fail(1)) SWIG_fail;
40968 {
40969 arg2 = (int)(SWIG_As_int(obj1));
40970 if (SWIG_arg_fail(2)) SWIG_fail;
40971 }
40972 {
40973 PyThreadState* __tstate = wxPyBeginAllowThreads();
40974 (arg1)->SetVGap(arg2);
40975
40976 wxPyEndAllowThreads(__tstate);
40977 if (PyErr_Occurred()) SWIG_fail;
40978 }
40979 Py_INCREF(Py_None); resultobj = Py_None;
40980 return resultobj;
40981 fail:
40982 return NULL;
40983 }
40984
40985
40986 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40987 PyObject *resultobj;
40988 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40989 int arg2 ;
40990 PyObject * obj0 = 0 ;
40991 PyObject * obj1 = 0 ;
40992 char *kwnames[] = {
40993 (char *) "self",(char *) "gap", NULL
40994 };
40995
40996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40998 if (SWIG_arg_fail(1)) SWIG_fail;
40999 {
41000 arg2 = (int)(SWIG_As_int(obj1));
41001 if (SWIG_arg_fail(2)) SWIG_fail;
41002 }
41003 {
41004 PyThreadState* __tstate = wxPyBeginAllowThreads();
41005 (arg1)->SetHGap(arg2);
41006
41007 wxPyEndAllowThreads(__tstate);
41008 if (PyErr_Occurred()) SWIG_fail;
41009 }
41010 Py_INCREF(Py_None); resultobj = Py_None;
41011 return resultobj;
41012 fail:
41013 return NULL;
41014 }
41015
41016
41017 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41018 PyObject *resultobj;
41019 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41020 int result;
41021 PyObject * obj0 = 0 ;
41022 char *kwnames[] = {
41023 (char *) "self", NULL
41024 };
41025
41026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41028 if (SWIG_arg_fail(1)) SWIG_fail;
41029 {
41030 PyThreadState* __tstate = wxPyBeginAllowThreads();
41031 result = (int)(arg1)->GetCols();
41032
41033 wxPyEndAllowThreads(__tstate);
41034 if (PyErr_Occurred()) SWIG_fail;
41035 }
41036 {
41037 resultobj = SWIG_From_int((int)(result));
41038 }
41039 return resultobj;
41040 fail:
41041 return NULL;
41042 }
41043
41044
41045 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41046 PyObject *resultobj;
41047 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41048 int result;
41049 PyObject * obj0 = 0 ;
41050 char *kwnames[] = {
41051 (char *) "self", NULL
41052 };
41053
41054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41056 if (SWIG_arg_fail(1)) SWIG_fail;
41057 {
41058 PyThreadState* __tstate = wxPyBeginAllowThreads();
41059 result = (int)(arg1)->GetRows();
41060
41061 wxPyEndAllowThreads(__tstate);
41062 if (PyErr_Occurred()) SWIG_fail;
41063 }
41064 {
41065 resultobj = SWIG_From_int((int)(result));
41066 }
41067 return resultobj;
41068 fail:
41069 return NULL;
41070 }
41071
41072
41073 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41074 PyObject *resultobj;
41075 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41076 int result;
41077 PyObject * obj0 = 0 ;
41078 char *kwnames[] = {
41079 (char *) "self", NULL
41080 };
41081
41082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41084 if (SWIG_arg_fail(1)) SWIG_fail;
41085 {
41086 PyThreadState* __tstate = wxPyBeginAllowThreads();
41087 result = (int)(arg1)->GetVGap();
41088
41089 wxPyEndAllowThreads(__tstate);
41090 if (PyErr_Occurred()) SWIG_fail;
41091 }
41092 {
41093 resultobj = SWIG_From_int((int)(result));
41094 }
41095 return resultobj;
41096 fail:
41097 return NULL;
41098 }
41099
41100
41101 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41102 PyObject *resultobj;
41103 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41104 int result;
41105 PyObject * obj0 = 0 ;
41106 char *kwnames[] = {
41107 (char *) "self", NULL
41108 };
41109
41110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41112 if (SWIG_arg_fail(1)) SWIG_fail;
41113 {
41114 PyThreadState* __tstate = wxPyBeginAllowThreads();
41115 result = (int)(arg1)->GetHGap();
41116
41117 wxPyEndAllowThreads(__tstate);
41118 if (PyErr_Occurred()) SWIG_fail;
41119 }
41120 {
41121 resultobj = SWIG_From_int((int)(result));
41122 }
41123 return resultobj;
41124 fail:
41125 return NULL;
41126 }
41127
41128
41129 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41130 PyObject *obj;
41131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41132 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41133 Py_INCREF(obj);
41134 return Py_BuildValue((char *)"");
41135 }
41136 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41137 PyObject *resultobj;
41138 int arg1 = (int) 1 ;
41139 int arg2 = (int) 0 ;
41140 int arg3 = (int) 0 ;
41141 int arg4 = (int) 0 ;
41142 wxFlexGridSizer *result;
41143 PyObject * obj0 = 0 ;
41144 PyObject * obj1 = 0 ;
41145 PyObject * obj2 = 0 ;
41146 PyObject * obj3 = 0 ;
41147 char *kwnames[] = {
41148 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41149 };
41150
41151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41152 if (obj0) {
41153 {
41154 arg1 = (int)(SWIG_As_int(obj0));
41155 if (SWIG_arg_fail(1)) SWIG_fail;
41156 }
41157 }
41158 if (obj1) {
41159 {
41160 arg2 = (int)(SWIG_As_int(obj1));
41161 if (SWIG_arg_fail(2)) SWIG_fail;
41162 }
41163 }
41164 if (obj2) {
41165 {
41166 arg3 = (int)(SWIG_As_int(obj2));
41167 if (SWIG_arg_fail(3)) SWIG_fail;
41168 }
41169 }
41170 if (obj3) {
41171 {
41172 arg4 = (int)(SWIG_As_int(obj3));
41173 if (SWIG_arg_fail(4)) SWIG_fail;
41174 }
41175 }
41176 {
41177 PyThreadState* __tstate = wxPyBeginAllowThreads();
41178 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41179
41180 wxPyEndAllowThreads(__tstate);
41181 if (PyErr_Occurred()) SWIG_fail;
41182 }
41183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41184 return resultobj;
41185 fail:
41186 return NULL;
41187 }
41188
41189
41190 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41191 PyObject *resultobj;
41192 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41193 size_t arg2 ;
41194 int arg3 = (int) 0 ;
41195 PyObject * obj0 = 0 ;
41196 PyObject * obj1 = 0 ;
41197 PyObject * obj2 = 0 ;
41198 char *kwnames[] = {
41199 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41200 };
41201
41202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41204 if (SWIG_arg_fail(1)) SWIG_fail;
41205 {
41206 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41207 if (SWIG_arg_fail(2)) SWIG_fail;
41208 }
41209 if (obj2) {
41210 {
41211 arg3 = (int)(SWIG_As_int(obj2));
41212 if (SWIG_arg_fail(3)) SWIG_fail;
41213 }
41214 }
41215 {
41216 PyThreadState* __tstate = wxPyBeginAllowThreads();
41217 (arg1)->AddGrowableRow(arg2,arg3);
41218
41219 wxPyEndAllowThreads(__tstate);
41220 if (PyErr_Occurred()) SWIG_fail;
41221 }
41222 Py_INCREF(Py_None); resultobj = Py_None;
41223 return resultobj;
41224 fail:
41225 return NULL;
41226 }
41227
41228
41229 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41230 PyObject *resultobj;
41231 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41232 size_t arg2 ;
41233 PyObject * obj0 = 0 ;
41234 PyObject * obj1 = 0 ;
41235 char *kwnames[] = {
41236 (char *) "self",(char *) "idx", NULL
41237 };
41238
41239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41241 if (SWIG_arg_fail(1)) SWIG_fail;
41242 {
41243 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41244 if (SWIG_arg_fail(2)) SWIG_fail;
41245 }
41246 {
41247 PyThreadState* __tstate = wxPyBeginAllowThreads();
41248 (arg1)->RemoveGrowableRow(arg2);
41249
41250 wxPyEndAllowThreads(__tstate);
41251 if (PyErr_Occurred()) SWIG_fail;
41252 }
41253 Py_INCREF(Py_None); resultobj = Py_None;
41254 return resultobj;
41255 fail:
41256 return NULL;
41257 }
41258
41259
41260 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41261 PyObject *resultobj;
41262 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41263 size_t arg2 ;
41264 int arg3 = (int) 0 ;
41265 PyObject * obj0 = 0 ;
41266 PyObject * obj1 = 0 ;
41267 PyObject * obj2 = 0 ;
41268 char *kwnames[] = {
41269 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41270 };
41271
41272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41274 if (SWIG_arg_fail(1)) SWIG_fail;
41275 {
41276 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41277 if (SWIG_arg_fail(2)) SWIG_fail;
41278 }
41279 if (obj2) {
41280 {
41281 arg3 = (int)(SWIG_As_int(obj2));
41282 if (SWIG_arg_fail(3)) SWIG_fail;
41283 }
41284 }
41285 {
41286 PyThreadState* __tstate = wxPyBeginAllowThreads();
41287 (arg1)->AddGrowableCol(arg2,arg3);
41288
41289 wxPyEndAllowThreads(__tstate);
41290 if (PyErr_Occurred()) SWIG_fail;
41291 }
41292 Py_INCREF(Py_None); resultobj = Py_None;
41293 return resultobj;
41294 fail:
41295 return NULL;
41296 }
41297
41298
41299 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41300 PyObject *resultobj;
41301 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41302 size_t arg2 ;
41303 PyObject * obj0 = 0 ;
41304 PyObject * obj1 = 0 ;
41305 char *kwnames[] = {
41306 (char *) "self",(char *) "idx", NULL
41307 };
41308
41309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41311 if (SWIG_arg_fail(1)) SWIG_fail;
41312 {
41313 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41314 if (SWIG_arg_fail(2)) SWIG_fail;
41315 }
41316 {
41317 PyThreadState* __tstate = wxPyBeginAllowThreads();
41318 (arg1)->RemoveGrowableCol(arg2);
41319
41320 wxPyEndAllowThreads(__tstate);
41321 if (PyErr_Occurred()) SWIG_fail;
41322 }
41323 Py_INCREF(Py_None); resultobj = Py_None;
41324 return resultobj;
41325 fail:
41326 return NULL;
41327 }
41328
41329
41330 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41331 PyObject *resultobj;
41332 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41333 int arg2 ;
41334 PyObject * obj0 = 0 ;
41335 PyObject * obj1 = 0 ;
41336 char *kwnames[] = {
41337 (char *) "self",(char *) "direction", NULL
41338 };
41339
41340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41342 if (SWIG_arg_fail(1)) SWIG_fail;
41343 {
41344 arg2 = (int)(SWIG_As_int(obj1));
41345 if (SWIG_arg_fail(2)) SWIG_fail;
41346 }
41347 {
41348 PyThreadState* __tstate = wxPyBeginAllowThreads();
41349 (arg1)->SetFlexibleDirection(arg2);
41350
41351 wxPyEndAllowThreads(__tstate);
41352 if (PyErr_Occurred()) SWIG_fail;
41353 }
41354 Py_INCREF(Py_None); resultobj = Py_None;
41355 return resultobj;
41356 fail:
41357 return NULL;
41358 }
41359
41360
41361 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41362 PyObject *resultobj;
41363 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41364 int result;
41365 PyObject * obj0 = 0 ;
41366 char *kwnames[] = {
41367 (char *) "self", NULL
41368 };
41369
41370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41372 if (SWIG_arg_fail(1)) SWIG_fail;
41373 {
41374 PyThreadState* __tstate = wxPyBeginAllowThreads();
41375 result = (int)(arg1)->GetFlexibleDirection();
41376
41377 wxPyEndAllowThreads(__tstate);
41378 if (PyErr_Occurred()) SWIG_fail;
41379 }
41380 {
41381 resultobj = SWIG_From_int((int)(result));
41382 }
41383 return resultobj;
41384 fail:
41385 return NULL;
41386 }
41387
41388
41389 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41390 PyObject *resultobj;
41391 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41392 wxFlexSizerGrowMode arg2 ;
41393 PyObject * obj0 = 0 ;
41394 PyObject * obj1 = 0 ;
41395 char *kwnames[] = {
41396 (char *) "self",(char *) "mode", NULL
41397 };
41398
41399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41401 if (SWIG_arg_fail(1)) SWIG_fail;
41402 {
41403 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41404 if (SWIG_arg_fail(2)) SWIG_fail;
41405 }
41406 {
41407 PyThreadState* __tstate = wxPyBeginAllowThreads();
41408 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41409
41410 wxPyEndAllowThreads(__tstate);
41411 if (PyErr_Occurred()) SWIG_fail;
41412 }
41413 Py_INCREF(Py_None); resultobj = Py_None;
41414 return resultobj;
41415 fail:
41416 return NULL;
41417 }
41418
41419
41420 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41421 PyObject *resultobj;
41422 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41423 wxFlexSizerGrowMode result;
41424 PyObject * obj0 = 0 ;
41425 char *kwnames[] = {
41426 (char *) "self", NULL
41427 };
41428
41429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41431 if (SWIG_arg_fail(1)) SWIG_fail;
41432 {
41433 PyThreadState* __tstate = wxPyBeginAllowThreads();
41434 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41435
41436 wxPyEndAllowThreads(__tstate);
41437 if (PyErr_Occurred()) SWIG_fail;
41438 }
41439 resultobj = SWIG_From_int((result));
41440 return resultobj;
41441 fail:
41442 return NULL;
41443 }
41444
41445
41446 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41447 PyObject *resultobj;
41448 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41449 wxArrayInt *result;
41450 PyObject * obj0 = 0 ;
41451 char *kwnames[] = {
41452 (char *) "self", NULL
41453 };
41454
41455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41457 if (SWIG_arg_fail(1)) SWIG_fail;
41458 {
41459 PyThreadState* __tstate = wxPyBeginAllowThreads();
41460 {
41461 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41462 result = (wxArrayInt *) &_result_ref;
41463 }
41464
41465 wxPyEndAllowThreads(__tstate);
41466 if (PyErr_Occurred()) SWIG_fail;
41467 }
41468 {
41469 resultobj = PyList_New(0);
41470 size_t idx;
41471 for (idx = 0; idx < result->GetCount(); idx += 1) {
41472 PyObject* val = PyInt_FromLong( result->Item(idx) );
41473 PyList_Append(resultobj, val);
41474 Py_DECREF(val);
41475 }
41476 }
41477 return resultobj;
41478 fail:
41479 return NULL;
41480 }
41481
41482
41483 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41484 PyObject *resultobj;
41485 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41486 wxArrayInt *result;
41487 PyObject * obj0 = 0 ;
41488 char *kwnames[] = {
41489 (char *) "self", NULL
41490 };
41491
41492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41494 if (SWIG_arg_fail(1)) SWIG_fail;
41495 {
41496 PyThreadState* __tstate = wxPyBeginAllowThreads();
41497 {
41498 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41499 result = (wxArrayInt *) &_result_ref;
41500 }
41501
41502 wxPyEndAllowThreads(__tstate);
41503 if (PyErr_Occurred()) SWIG_fail;
41504 }
41505 {
41506 resultobj = PyList_New(0);
41507 size_t idx;
41508 for (idx = 0; idx < result->GetCount(); idx += 1) {
41509 PyObject* val = PyInt_FromLong( result->Item(idx) );
41510 PyList_Append(resultobj, val);
41511 Py_DECREF(val);
41512 }
41513 }
41514 return resultobj;
41515 fail:
41516 return NULL;
41517 }
41518
41519
41520 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41521 PyObject *obj;
41522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41523 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41524 Py_INCREF(obj);
41525 return Py_BuildValue((char *)"");
41526 }
41527 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41528 PyObject *resultobj;
41529 wxStdDialogButtonSizer *result;
41530 char *kwnames[] = {
41531 NULL
41532 };
41533
41534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41535 {
41536 PyThreadState* __tstate = wxPyBeginAllowThreads();
41537 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41538
41539 wxPyEndAllowThreads(__tstate);
41540 if (PyErr_Occurred()) SWIG_fail;
41541 }
41542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41543 return resultobj;
41544 fail:
41545 return NULL;
41546 }
41547
41548
41549 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41550 PyObject *resultobj;
41551 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41552 wxButton *arg2 = (wxButton *) 0 ;
41553 PyObject * obj0 = 0 ;
41554 PyObject * obj1 = 0 ;
41555 char *kwnames[] = {
41556 (char *) "self",(char *) "button", NULL
41557 };
41558
41559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41561 if (SWIG_arg_fail(1)) SWIG_fail;
41562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41563 if (SWIG_arg_fail(2)) SWIG_fail;
41564 {
41565 PyThreadState* __tstate = wxPyBeginAllowThreads();
41566 (arg1)->AddButton(arg2);
41567
41568 wxPyEndAllowThreads(__tstate);
41569 if (PyErr_Occurred()) SWIG_fail;
41570 }
41571 Py_INCREF(Py_None); resultobj = Py_None;
41572 return resultobj;
41573 fail:
41574 return NULL;
41575 }
41576
41577
41578 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41579 PyObject *resultobj;
41580 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41581 PyObject * obj0 = 0 ;
41582 char *kwnames[] = {
41583 (char *) "self", NULL
41584 };
41585
41586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41588 if (SWIG_arg_fail(1)) SWIG_fail;
41589 {
41590 PyThreadState* __tstate = wxPyBeginAllowThreads();
41591 (arg1)->Realize();
41592
41593 wxPyEndAllowThreads(__tstate);
41594 if (PyErr_Occurred()) SWIG_fail;
41595 }
41596 Py_INCREF(Py_None); resultobj = Py_None;
41597 return resultobj;
41598 fail:
41599 return NULL;
41600 }
41601
41602
41603 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41604 PyObject *resultobj;
41605 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41606 wxButton *arg2 = (wxButton *) 0 ;
41607 PyObject * obj0 = 0 ;
41608 PyObject * obj1 = 0 ;
41609 char *kwnames[] = {
41610 (char *) "self",(char *) "button", NULL
41611 };
41612
41613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41615 if (SWIG_arg_fail(1)) SWIG_fail;
41616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41617 if (SWIG_arg_fail(2)) SWIG_fail;
41618 {
41619 PyThreadState* __tstate = wxPyBeginAllowThreads();
41620 (arg1)->SetAffirmativeButton(arg2);
41621
41622 wxPyEndAllowThreads(__tstate);
41623 if (PyErr_Occurred()) SWIG_fail;
41624 }
41625 Py_INCREF(Py_None); resultobj = Py_None;
41626 return resultobj;
41627 fail:
41628 return NULL;
41629 }
41630
41631
41632 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41633 PyObject *resultobj;
41634 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41635 wxButton *arg2 = (wxButton *) 0 ;
41636 PyObject * obj0 = 0 ;
41637 PyObject * obj1 = 0 ;
41638 char *kwnames[] = {
41639 (char *) "self",(char *) "button", NULL
41640 };
41641
41642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41644 if (SWIG_arg_fail(1)) SWIG_fail;
41645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41646 if (SWIG_arg_fail(2)) SWIG_fail;
41647 {
41648 PyThreadState* __tstate = wxPyBeginAllowThreads();
41649 (arg1)->SetNegativeButton(arg2);
41650
41651 wxPyEndAllowThreads(__tstate);
41652 if (PyErr_Occurred()) SWIG_fail;
41653 }
41654 Py_INCREF(Py_None); resultobj = Py_None;
41655 return resultobj;
41656 fail:
41657 return NULL;
41658 }
41659
41660
41661 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41662 PyObject *resultobj;
41663 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41664 wxButton *arg2 = (wxButton *) 0 ;
41665 PyObject * obj0 = 0 ;
41666 PyObject * obj1 = 0 ;
41667 char *kwnames[] = {
41668 (char *) "self",(char *) "button", NULL
41669 };
41670
41671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41673 if (SWIG_arg_fail(1)) SWIG_fail;
41674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41675 if (SWIG_arg_fail(2)) SWIG_fail;
41676 {
41677 PyThreadState* __tstate = wxPyBeginAllowThreads();
41678 (arg1)->SetCancelButton(arg2);
41679
41680 wxPyEndAllowThreads(__tstate);
41681 if (PyErr_Occurred()) SWIG_fail;
41682 }
41683 Py_INCREF(Py_None); resultobj = Py_None;
41684 return resultobj;
41685 fail:
41686 return NULL;
41687 }
41688
41689
41690 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41691 PyObject *resultobj;
41692 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41693 wxButton *result;
41694 PyObject * obj0 = 0 ;
41695 char *kwnames[] = {
41696 (char *) "self", NULL
41697 };
41698
41699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41701 if (SWIG_arg_fail(1)) SWIG_fail;
41702 {
41703 PyThreadState* __tstate = wxPyBeginAllowThreads();
41704 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41705
41706 wxPyEndAllowThreads(__tstate);
41707 if (PyErr_Occurred()) SWIG_fail;
41708 }
41709 {
41710 resultobj = wxPyMake_wxObject(result, 0);
41711 }
41712 return resultobj;
41713 fail:
41714 return NULL;
41715 }
41716
41717
41718 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41719 PyObject *resultobj;
41720 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41721 wxButton *result;
41722 PyObject * obj0 = 0 ;
41723 char *kwnames[] = {
41724 (char *) "self", NULL
41725 };
41726
41727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41729 if (SWIG_arg_fail(1)) SWIG_fail;
41730 {
41731 PyThreadState* __tstate = wxPyBeginAllowThreads();
41732 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41733
41734 wxPyEndAllowThreads(__tstate);
41735 if (PyErr_Occurred()) SWIG_fail;
41736 }
41737 {
41738 resultobj = wxPyMake_wxObject(result, 0);
41739 }
41740 return resultobj;
41741 fail:
41742 return NULL;
41743 }
41744
41745
41746 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41747 PyObject *resultobj;
41748 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41749 wxButton *result;
41750 PyObject * obj0 = 0 ;
41751 char *kwnames[] = {
41752 (char *) "self", NULL
41753 };
41754
41755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41757 if (SWIG_arg_fail(1)) SWIG_fail;
41758 {
41759 PyThreadState* __tstate = wxPyBeginAllowThreads();
41760 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41761
41762 wxPyEndAllowThreads(__tstate);
41763 if (PyErr_Occurred()) SWIG_fail;
41764 }
41765 {
41766 resultobj = wxPyMake_wxObject(result, 0);
41767 }
41768 return resultobj;
41769 fail:
41770 return NULL;
41771 }
41772
41773
41774 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41775 PyObject *resultobj;
41776 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41777 wxButton *result;
41778 PyObject * obj0 = 0 ;
41779 char *kwnames[] = {
41780 (char *) "self", NULL
41781 };
41782
41783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41785 if (SWIG_arg_fail(1)) SWIG_fail;
41786 {
41787 PyThreadState* __tstate = wxPyBeginAllowThreads();
41788 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41789
41790 wxPyEndAllowThreads(__tstate);
41791 if (PyErr_Occurred()) SWIG_fail;
41792 }
41793 {
41794 resultobj = wxPyMake_wxObject(result, 0);
41795 }
41796 return resultobj;
41797 fail:
41798 return NULL;
41799 }
41800
41801
41802 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41803 PyObject *resultobj;
41804 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41805 wxButton *result;
41806 PyObject * obj0 = 0 ;
41807 char *kwnames[] = {
41808 (char *) "self", NULL
41809 };
41810
41811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41813 if (SWIG_arg_fail(1)) SWIG_fail;
41814 {
41815 PyThreadState* __tstate = wxPyBeginAllowThreads();
41816 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41817
41818 wxPyEndAllowThreads(__tstate);
41819 if (PyErr_Occurred()) SWIG_fail;
41820 }
41821 {
41822 resultobj = wxPyMake_wxObject(result, 0);
41823 }
41824 return resultobj;
41825 fail:
41826 return NULL;
41827 }
41828
41829
41830 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41831 PyObject *obj;
41832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41833 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41834 Py_INCREF(obj);
41835 return Py_BuildValue((char *)"");
41836 }
41837 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41838 PyObject *resultobj;
41839 int arg1 = (int) 0 ;
41840 int arg2 = (int) 0 ;
41841 wxGBPosition *result;
41842 PyObject * obj0 = 0 ;
41843 PyObject * obj1 = 0 ;
41844 char *kwnames[] = {
41845 (char *) "row",(char *) "col", NULL
41846 };
41847
41848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41849 if (obj0) {
41850 {
41851 arg1 = (int)(SWIG_As_int(obj0));
41852 if (SWIG_arg_fail(1)) SWIG_fail;
41853 }
41854 }
41855 if (obj1) {
41856 {
41857 arg2 = (int)(SWIG_As_int(obj1));
41858 if (SWIG_arg_fail(2)) SWIG_fail;
41859 }
41860 }
41861 {
41862 PyThreadState* __tstate = wxPyBeginAllowThreads();
41863 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41864
41865 wxPyEndAllowThreads(__tstate);
41866 if (PyErr_Occurred()) SWIG_fail;
41867 }
41868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41869 return resultobj;
41870 fail:
41871 return NULL;
41872 }
41873
41874
41875 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41876 PyObject *resultobj;
41877 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41878 int result;
41879 PyObject * obj0 = 0 ;
41880 char *kwnames[] = {
41881 (char *) "self", NULL
41882 };
41883
41884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41886 if (SWIG_arg_fail(1)) SWIG_fail;
41887 {
41888 PyThreadState* __tstate = wxPyBeginAllowThreads();
41889 result = (int)((wxGBPosition const *)arg1)->GetRow();
41890
41891 wxPyEndAllowThreads(__tstate);
41892 if (PyErr_Occurred()) SWIG_fail;
41893 }
41894 {
41895 resultobj = SWIG_From_int((int)(result));
41896 }
41897 return resultobj;
41898 fail:
41899 return NULL;
41900 }
41901
41902
41903 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41904 PyObject *resultobj;
41905 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41906 int result;
41907 PyObject * obj0 = 0 ;
41908 char *kwnames[] = {
41909 (char *) "self", NULL
41910 };
41911
41912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41914 if (SWIG_arg_fail(1)) SWIG_fail;
41915 {
41916 PyThreadState* __tstate = wxPyBeginAllowThreads();
41917 result = (int)((wxGBPosition const *)arg1)->GetCol();
41918
41919 wxPyEndAllowThreads(__tstate);
41920 if (PyErr_Occurred()) SWIG_fail;
41921 }
41922 {
41923 resultobj = SWIG_From_int((int)(result));
41924 }
41925 return resultobj;
41926 fail:
41927 return NULL;
41928 }
41929
41930
41931 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41932 PyObject *resultobj;
41933 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41934 int arg2 ;
41935 PyObject * obj0 = 0 ;
41936 PyObject * obj1 = 0 ;
41937 char *kwnames[] = {
41938 (char *) "self",(char *) "row", NULL
41939 };
41940
41941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41943 if (SWIG_arg_fail(1)) SWIG_fail;
41944 {
41945 arg2 = (int)(SWIG_As_int(obj1));
41946 if (SWIG_arg_fail(2)) SWIG_fail;
41947 }
41948 {
41949 PyThreadState* __tstate = wxPyBeginAllowThreads();
41950 (arg1)->SetRow(arg2);
41951
41952 wxPyEndAllowThreads(__tstate);
41953 if (PyErr_Occurred()) SWIG_fail;
41954 }
41955 Py_INCREF(Py_None); resultobj = Py_None;
41956 return resultobj;
41957 fail:
41958 return NULL;
41959 }
41960
41961
41962 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41963 PyObject *resultobj;
41964 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41965 int arg2 ;
41966 PyObject * obj0 = 0 ;
41967 PyObject * obj1 = 0 ;
41968 char *kwnames[] = {
41969 (char *) "self",(char *) "col", NULL
41970 };
41971
41972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41974 if (SWIG_arg_fail(1)) SWIG_fail;
41975 {
41976 arg2 = (int)(SWIG_As_int(obj1));
41977 if (SWIG_arg_fail(2)) SWIG_fail;
41978 }
41979 {
41980 PyThreadState* __tstate = wxPyBeginAllowThreads();
41981 (arg1)->SetCol(arg2);
41982
41983 wxPyEndAllowThreads(__tstate);
41984 if (PyErr_Occurred()) SWIG_fail;
41985 }
41986 Py_INCREF(Py_None); resultobj = Py_None;
41987 return resultobj;
41988 fail:
41989 return NULL;
41990 }
41991
41992
41993 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41994 PyObject *resultobj;
41995 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41996 wxGBPosition *arg2 = 0 ;
41997 bool result;
41998 wxGBPosition temp2 ;
41999 PyObject * obj0 = 0 ;
42000 PyObject * obj1 = 0 ;
42001 char *kwnames[] = {
42002 (char *) "self",(char *) "other", NULL
42003 };
42004
42005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42007 if (SWIG_arg_fail(1)) SWIG_fail;
42008 {
42009 arg2 = &temp2;
42010 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42011 }
42012 {
42013 PyThreadState* __tstate = wxPyBeginAllowThreads();
42014 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42015
42016 wxPyEndAllowThreads(__tstate);
42017 if (PyErr_Occurred()) SWIG_fail;
42018 }
42019 {
42020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42021 }
42022 return resultobj;
42023 fail:
42024 return NULL;
42025 }
42026
42027
42028 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42029 PyObject *resultobj;
42030 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42031 wxGBPosition *arg2 = 0 ;
42032 bool result;
42033 wxGBPosition temp2 ;
42034 PyObject * obj0 = 0 ;
42035 PyObject * obj1 = 0 ;
42036 char *kwnames[] = {
42037 (char *) "self",(char *) "other", NULL
42038 };
42039
42040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42042 if (SWIG_arg_fail(1)) SWIG_fail;
42043 {
42044 arg2 = &temp2;
42045 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42046 }
42047 {
42048 PyThreadState* __tstate = wxPyBeginAllowThreads();
42049 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42050
42051 wxPyEndAllowThreads(__tstate);
42052 if (PyErr_Occurred()) SWIG_fail;
42053 }
42054 {
42055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42056 }
42057 return resultobj;
42058 fail:
42059 return NULL;
42060 }
42061
42062
42063 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42064 PyObject *resultobj;
42065 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42066 int arg2 = (int) 0 ;
42067 int arg3 = (int) 0 ;
42068 PyObject * obj0 = 0 ;
42069 PyObject * obj1 = 0 ;
42070 PyObject * obj2 = 0 ;
42071 char *kwnames[] = {
42072 (char *) "self",(char *) "row",(char *) "col", NULL
42073 };
42074
42075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42077 if (SWIG_arg_fail(1)) SWIG_fail;
42078 if (obj1) {
42079 {
42080 arg2 = (int)(SWIG_As_int(obj1));
42081 if (SWIG_arg_fail(2)) SWIG_fail;
42082 }
42083 }
42084 if (obj2) {
42085 {
42086 arg3 = (int)(SWIG_As_int(obj2));
42087 if (SWIG_arg_fail(3)) SWIG_fail;
42088 }
42089 }
42090 {
42091 PyThreadState* __tstate = wxPyBeginAllowThreads();
42092 wxGBPosition_Set(arg1,arg2,arg3);
42093
42094 wxPyEndAllowThreads(__tstate);
42095 if (PyErr_Occurred()) SWIG_fail;
42096 }
42097 Py_INCREF(Py_None); resultobj = Py_None;
42098 return resultobj;
42099 fail:
42100 return NULL;
42101 }
42102
42103
42104 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42105 PyObject *resultobj;
42106 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42107 PyObject *result;
42108 PyObject * obj0 = 0 ;
42109 char *kwnames[] = {
42110 (char *) "self", NULL
42111 };
42112
42113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42115 if (SWIG_arg_fail(1)) SWIG_fail;
42116 {
42117 PyThreadState* __tstate = wxPyBeginAllowThreads();
42118 result = (PyObject *)wxGBPosition_Get(arg1);
42119
42120 wxPyEndAllowThreads(__tstate);
42121 if (PyErr_Occurred()) SWIG_fail;
42122 }
42123 resultobj = result;
42124 return resultobj;
42125 fail:
42126 return NULL;
42127 }
42128
42129
42130 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42131 PyObject *obj;
42132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42133 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42134 Py_INCREF(obj);
42135 return Py_BuildValue((char *)"");
42136 }
42137 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42138 PyObject *resultobj;
42139 int arg1 = (int) 1 ;
42140 int arg2 = (int) 1 ;
42141 wxGBSpan *result;
42142 PyObject * obj0 = 0 ;
42143 PyObject * obj1 = 0 ;
42144 char *kwnames[] = {
42145 (char *) "rowspan",(char *) "colspan", NULL
42146 };
42147
42148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42149 if (obj0) {
42150 {
42151 arg1 = (int)(SWIG_As_int(obj0));
42152 if (SWIG_arg_fail(1)) SWIG_fail;
42153 }
42154 }
42155 if (obj1) {
42156 {
42157 arg2 = (int)(SWIG_As_int(obj1));
42158 if (SWIG_arg_fail(2)) SWIG_fail;
42159 }
42160 }
42161 {
42162 PyThreadState* __tstate = wxPyBeginAllowThreads();
42163 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42164
42165 wxPyEndAllowThreads(__tstate);
42166 if (PyErr_Occurred()) SWIG_fail;
42167 }
42168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42169 return resultobj;
42170 fail:
42171 return NULL;
42172 }
42173
42174
42175 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42176 PyObject *resultobj;
42177 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42178 int result;
42179 PyObject * obj0 = 0 ;
42180 char *kwnames[] = {
42181 (char *) "self", NULL
42182 };
42183
42184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42186 if (SWIG_arg_fail(1)) SWIG_fail;
42187 {
42188 PyThreadState* __tstate = wxPyBeginAllowThreads();
42189 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42190
42191 wxPyEndAllowThreads(__tstate);
42192 if (PyErr_Occurred()) SWIG_fail;
42193 }
42194 {
42195 resultobj = SWIG_From_int((int)(result));
42196 }
42197 return resultobj;
42198 fail:
42199 return NULL;
42200 }
42201
42202
42203 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42204 PyObject *resultobj;
42205 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42206 int result;
42207 PyObject * obj0 = 0 ;
42208 char *kwnames[] = {
42209 (char *) "self", NULL
42210 };
42211
42212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42214 if (SWIG_arg_fail(1)) SWIG_fail;
42215 {
42216 PyThreadState* __tstate = wxPyBeginAllowThreads();
42217 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42218
42219 wxPyEndAllowThreads(__tstate);
42220 if (PyErr_Occurred()) SWIG_fail;
42221 }
42222 {
42223 resultobj = SWIG_From_int((int)(result));
42224 }
42225 return resultobj;
42226 fail:
42227 return NULL;
42228 }
42229
42230
42231 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42232 PyObject *resultobj;
42233 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42234 int arg2 ;
42235 PyObject * obj0 = 0 ;
42236 PyObject * obj1 = 0 ;
42237 char *kwnames[] = {
42238 (char *) "self",(char *) "rowspan", NULL
42239 };
42240
42241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42243 if (SWIG_arg_fail(1)) SWIG_fail;
42244 {
42245 arg2 = (int)(SWIG_As_int(obj1));
42246 if (SWIG_arg_fail(2)) SWIG_fail;
42247 }
42248 {
42249 PyThreadState* __tstate = wxPyBeginAllowThreads();
42250 (arg1)->SetRowspan(arg2);
42251
42252 wxPyEndAllowThreads(__tstate);
42253 if (PyErr_Occurred()) SWIG_fail;
42254 }
42255 Py_INCREF(Py_None); resultobj = Py_None;
42256 return resultobj;
42257 fail:
42258 return NULL;
42259 }
42260
42261
42262 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42263 PyObject *resultobj;
42264 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42265 int arg2 ;
42266 PyObject * obj0 = 0 ;
42267 PyObject * obj1 = 0 ;
42268 char *kwnames[] = {
42269 (char *) "self",(char *) "colspan", NULL
42270 };
42271
42272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42274 if (SWIG_arg_fail(1)) SWIG_fail;
42275 {
42276 arg2 = (int)(SWIG_As_int(obj1));
42277 if (SWIG_arg_fail(2)) SWIG_fail;
42278 }
42279 {
42280 PyThreadState* __tstate = wxPyBeginAllowThreads();
42281 (arg1)->SetColspan(arg2);
42282
42283 wxPyEndAllowThreads(__tstate);
42284 if (PyErr_Occurred()) SWIG_fail;
42285 }
42286 Py_INCREF(Py_None); resultobj = Py_None;
42287 return resultobj;
42288 fail:
42289 return NULL;
42290 }
42291
42292
42293 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42294 PyObject *resultobj;
42295 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42296 wxGBSpan *arg2 = 0 ;
42297 bool result;
42298 wxGBSpan temp2 ;
42299 PyObject * obj0 = 0 ;
42300 PyObject * obj1 = 0 ;
42301 char *kwnames[] = {
42302 (char *) "self",(char *) "other", NULL
42303 };
42304
42305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42307 if (SWIG_arg_fail(1)) SWIG_fail;
42308 {
42309 arg2 = &temp2;
42310 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42311 }
42312 {
42313 PyThreadState* __tstate = wxPyBeginAllowThreads();
42314 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42315
42316 wxPyEndAllowThreads(__tstate);
42317 if (PyErr_Occurred()) SWIG_fail;
42318 }
42319 {
42320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42321 }
42322 return resultobj;
42323 fail:
42324 return NULL;
42325 }
42326
42327
42328 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42329 PyObject *resultobj;
42330 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42331 wxGBSpan *arg2 = 0 ;
42332 bool result;
42333 wxGBSpan temp2 ;
42334 PyObject * obj0 = 0 ;
42335 PyObject * obj1 = 0 ;
42336 char *kwnames[] = {
42337 (char *) "self",(char *) "other", NULL
42338 };
42339
42340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42342 if (SWIG_arg_fail(1)) SWIG_fail;
42343 {
42344 arg2 = &temp2;
42345 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42346 }
42347 {
42348 PyThreadState* __tstate = wxPyBeginAllowThreads();
42349 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42350
42351 wxPyEndAllowThreads(__tstate);
42352 if (PyErr_Occurred()) SWIG_fail;
42353 }
42354 {
42355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42356 }
42357 return resultobj;
42358 fail:
42359 return NULL;
42360 }
42361
42362
42363 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42364 PyObject *resultobj;
42365 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42366 int arg2 = (int) 1 ;
42367 int arg3 = (int) 1 ;
42368 PyObject * obj0 = 0 ;
42369 PyObject * obj1 = 0 ;
42370 PyObject * obj2 = 0 ;
42371 char *kwnames[] = {
42372 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42373 };
42374
42375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42377 if (SWIG_arg_fail(1)) SWIG_fail;
42378 if (obj1) {
42379 {
42380 arg2 = (int)(SWIG_As_int(obj1));
42381 if (SWIG_arg_fail(2)) SWIG_fail;
42382 }
42383 }
42384 if (obj2) {
42385 {
42386 arg3 = (int)(SWIG_As_int(obj2));
42387 if (SWIG_arg_fail(3)) SWIG_fail;
42388 }
42389 }
42390 {
42391 PyThreadState* __tstate = wxPyBeginAllowThreads();
42392 wxGBSpan_Set(arg1,arg2,arg3);
42393
42394 wxPyEndAllowThreads(__tstate);
42395 if (PyErr_Occurred()) SWIG_fail;
42396 }
42397 Py_INCREF(Py_None); resultobj = Py_None;
42398 return resultobj;
42399 fail:
42400 return NULL;
42401 }
42402
42403
42404 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42405 PyObject *resultobj;
42406 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42407 PyObject *result;
42408 PyObject * obj0 = 0 ;
42409 char *kwnames[] = {
42410 (char *) "self", NULL
42411 };
42412
42413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42415 if (SWIG_arg_fail(1)) SWIG_fail;
42416 {
42417 PyThreadState* __tstate = wxPyBeginAllowThreads();
42418 result = (PyObject *)wxGBSpan_Get(arg1);
42419
42420 wxPyEndAllowThreads(__tstate);
42421 if (PyErr_Occurred()) SWIG_fail;
42422 }
42423 resultobj = result;
42424 return resultobj;
42425 fail:
42426 return NULL;
42427 }
42428
42429
42430 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42431 PyObject *obj;
42432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42433 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42434 Py_INCREF(obj);
42435 return Py_BuildValue((char *)"");
42436 }
42437 static int _wrap_DefaultSpan_set(PyObject *) {
42438 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42439 return 1;
42440 }
42441
42442
42443 static PyObject *_wrap_DefaultSpan_get(void) {
42444 PyObject *pyobj;
42445
42446 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42447 return pyobj;
42448 }
42449
42450
42451 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42452 PyObject *resultobj;
42453 wxGBSizerItem *result;
42454 char *kwnames[] = {
42455 NULL
42456 };
42457
42458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42459 {
42460 PyThreadState* __tstate = wxPyBeginAllowThreads();
42461 result = (wxGBSizerItem *)new wxGBSizerItem();
42462
42463 wxPyEndAllowThreads(__tstate);
42464 if (PyErr_Occurred()) SWIG_fail;
42465 }
42466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42467 return resultobj;
42468 fail:
42469 return NULL;
42470 }
42471
42472
42473 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42474 PyObject *resultobj;
42475 wxWindow *arg1 = (wxWindow *) 0 ;
42476 wxGBPosition *arg2 = 0 ;
42477 wxGBSpan *arg3 = 0 ;
42478 int arg4 ;
42479 int arg5 ;
42480 PyObject *arg6 = (PyObject *) NULL ;
42481 wxGBSizerItem *result;
42482 wxGBPosition temp2 ;
42483 wxGBSpan temp3 ;
42484 PyObject * obj0 = 0 ;
42485 PyObject * obj1 = 0 ;
42486 PyObject * obj2 = 0 ;
42487 PyObject * obj3 = 0 ;
42488 PyObject * obj4 = 0 ;
42489 PyObject * obj5 = 0 ;
42490 char *kwnames[] = {
42491 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42492 };
42493
42494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42496 if (SWIG_arg_fail(1)) SWIG_fail;
42497 {
42498 arg2 = &temp2;
42499 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42500 }
42501 {
42502 arg3 = &temp3;
42503 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42504 }
42505 {
42506 arg4 = (int)(SWIG_As_int(obj3));
42507 if (SWIG_arg_fail(4)) SWIG_fail;
42508 }
42509 {
42510 arg5 = (int)(SWIG_As_int(obj4));
42511 if (SWIG_arg_fail(5)) SWIG_fail;
42512 }
42513 if (obj5) {
42514 arg6 = obj5;
42515 }
42516 {
42517 PyThreadState* __tstate = wxPyBeginAllowThreads();
42518 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42519
42520 wxPyEndAllowThreads(__tstate);
42521 if (PyErr_Occurred()) SWIG_fail;
42522 }
42523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42524 return resultobj;
42525 fail:
42526 return NULL;
42527 }
42528
42529
42530 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42531 PyObject *resultobj;
42532 wxSizer *arg1 = (wxSizer *) 0 ;
42533 wxGBPosition *arg2 = 0 ;
42534 wxGBSpan *arg3 = 0 ;
42535 int arg4 ;
42536 int arg5 ;
42537 PyObject *arg6 = (PyObject *) NULL ;
42538 wxGBSizerItem *result;
42539 wxGBPosition temp2 ;
42540 wxGBSpan temp3 ;
42541 PyObject * obj0 = 0 ;
42542 PyObject * obj1 = 0 ;
42543 PyObject * obj2 = 0 ;
42544 PyObject * obj3 = 0 ;
42545 PyObject * obj4 = 0 ;
42546 PyObject * obj5 = 0 ;
42547 char *kwnames[] = {
42548 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42549 };
42550
42551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42553 if (SWIG_arg_fail(1)) SWIG_fail;
42554 {
42555 arg2 = &temp2;
42556 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42557 }
42558 {
42559 arg3 = &temp3;
42560 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42561 }
42562 {
42563 arg4 = (int)(SWIG_As_int(obj3));
42564 if (SWIG_arg_fail(4)) SWIG_fail;
42565 }
42566 {
42567 arg5 = (int)(SWIG_As_int(obj4));
42568 if (SWIG_arg_fail(5)) SWIG_fail;
42569 }
42570 if (obj5) {
42571 arg6 = obj5;
42572 }
42573 {
42574 PyThreadState* __tstate = wxPyBeginAllowThreads();
42575 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42576
42577 wxPyEndAllowThreads(__tstate);
42578 if (PyErr_Occurred()) SWIG_fail;
42579 }
42580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42581 return resultobj;
42582 fail:
42583 return NULL;
42584 }
42585
42586
42587 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42588 PyObject *resultobj;
42589 int arg1 ;
42590 int arg2 ;
42591 wxGBPosition *arg3 = 0 ;
42592 wxGBSpan *arg4 = 0 ;
42593 int arg5 ;
42594 int arg6 ;
42595 PyObject *arg7 = (PyObject *) NULL ;
42596 wxGBSizerItem *result;
42597 wxGBPosition temp3 ;
42598 wxGBSpan temp4 ;
42599 PyObject * obj0 = 0 ;
42600 PyObject * obj1 = 0 ;
42601 PyObject * obj2 = 0 ;
42602 PyObject * obj3 = 0 ;
42603 PyObject * obj4 = 0 ;
42604 PyObject * obj5 = 0 ;
42605 PyObject * obj6 = 0 ;
42606 char *kwnames[] = {
42607 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42608 };
42609
42610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42611 {
42612 arg1 = (int)(SWIG_As_int(obj0));
42613 if (SWIG_arg_fail(1)) SWIG_fail;
42614 }
42615 {
42616 arg2 = (int)(SWIG_As_int(obj1));
42617 if (SWIG_arg_fail(2)) SWIG_fail;
42618 }
42619 {
42620 arg3 = &temp3;
42621 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42622 }
42623 {
42624 arg4 = &temp4;
42625 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42626 }
42627 {
42628 arg5 = (int)(SWIG_As_int(obj4));
42629 if (SWIG_arg_fail(5)) SWIG_fail;
42630 }
42631 {
42632 arg6 = (int)(SWIG_As_int(obj5));
42633 if (SWIG_arg_fail(6)) SWIG_fail;
42634 }
42635 if (obj6) {
42636 arg7 = obj6;
42637 }
42638 {
42639 PyThreadState* __tstate = wxPyBeginAllowThreads();
42640 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42641
42642 wxPyEndAllowThreads(__tstate);
42643 if (PyErr_Occurred()) SWIG_fail;
42644 }
42645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42646 return resultobj;
42647 fail:
42648 return NULL;
42649 }
42650
42651
42652 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42653 PyObject *resultobj;
42654 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42655 wxGBPosition result;
42656 PyObject * obj0 = 0 ;
42657 char *kwnames[] = {
42658 (char *) "self", NULL
42659 };
42660
42661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42663 if (SWIG_arg_fail(1)) SWIG_fail;
42664 {
42665 PyThreadState* __tstate = wxPyBeginAllowThreads();
42666 result = ((wxGBSizerItem const *)arg1)->GetPos();
42667
42668 wxPyEndAllowThreads(__tstate);
42669 if (PyErr_Occurred()) SWIG_fail;
42670 }
42671 {
42672 wxGBPosition * resultptr;
42673 resultptr = new wxGBPosition((wxGBPosition &)(result));
42674 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42675 }
42676 return resultobj;
42677 fail:
42678 return NULL;
42679 }
42680
42681
42682 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42683 PyObject *resultobj;
42684 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42685 wxGBSpan result;
42686 PyObject * obj0 = 0 ;
42687 char *kwnames[] = {
42688 (char *) "self", NULL
42689 };
42690
42691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42693 if (SWIG_arg_fail(1)) SWIG_fail;
42694 {
42695 PyThreadState* __tstate = wxPyBeginAllowThreads();
42696 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42697
42698 wxPyEndAllowThreads(__tstate);
42699 if (PyErr_Occurred()) SWIG_fail;
42700 }
42701 {
42702 wxGBSpan * resultptr;
42703 resultptr = new wxGBSpan((wxGBSpan &)(result));
42704 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42705 }
42706 return resultobj;
42707 fail:
42708 return NULL;
42709 }
42710
42711
42712 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42713 PyObject *resultobj;
42714 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42715 wxGBPosition *arg2 = 0 ;
42716 bool result;
42717 wxGBPosition temp2 ;
42718 PyObject * obj0 = 0 ;
42719 PyObject * obj1 = 0 ;
42720 char *kwnames[] = {
42721 (char *) "self",(char *) "pos", NULL
42722 };
42723
42724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42726 if (SWIG_arg_fail(1)) SWIG_fail;
42727 {
42728 arg2 = &temp2;
42729 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42730 }
42731 {
42732 PyThreadState* __tstate = wxPyBeginAllowThreads();
42733 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42734
42735 wxPyEndAllowThreads(__tstate);
42736 if (PyErr_Occurred()) SWIG_fail;
42737 }
42738 {
42739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42740 }
42741 return resultobj;
42742 fail:
42743 return NULL;
42744 }
42745
42746
42747 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42748 PyObject *resultobj;
42749 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42750 wxGBSpan *arg2 = 0 ;
42751 bool result;
42752 wxGBSpan temp2 ;
42753 PyObject * obj0 = 0 ;
42754 PyObject * obj1 = 0 ;
42755 char *kwnames[] = {
42756 (char *) "self",(char *) "span", NULL
42757 };
42758
42759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42761 if (SWIG_arg_fail(1)) SWIG_fail;
42762 {
42763 arg2 = &temp2;
42764 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42765 }
42766 {
42767 PyThreadState* __tstate = wxPyBeginAllowThreads();
42768 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42769
42770 wxPyEndAllowThreads(__tstate);
42771 if (PyErr_Occurred()) SWIG_fail;
42772 }
42773 {
42774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42775 }
42776 return resultobj;
42777 fail:
42778 return NULL;
42779 }
42780
42781
42782 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42783 PyObject *resultobj;
42784 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42785 wxGBSizerItem *arg2 = 0 ;
42786 bool result;
42787 PyObject * obj0 = 0 ;
42788 PyObject * obj1 = 0 ;
42789 char *kwnames[] = {
42790 (char *) "self",(char *) "other", NULL
42791 };
42792
42793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42795 if (SWIG_arg_fail(1)) SWIG_fail;
42796 {
42797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42798 if (SWIG_arg_fail(2)) SWIG_fail;
42799 if (arg2 == NULL) {
42800 SWIG_null_ref("wxGBSizerItem");
42801 }
42802 if (SWIG_arg_fail(2)) SWIG_fail;
42803 }
42804 {
42805 PyThreadState* __tstate = wxPyBeginAllowThreads();
42806 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42807
42808 wxPyEndAllowThreads(__tstate);
42809 if (PyErr_Occurred()) SWIG_fail;
42810 }
42811 {
42812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42813 }
42814 return resultobj;
42815 fail:
42816 return NULL;
42817 }
42818
42819
42820 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42821 PyObject *resultobj;
42822 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42823 wxGBPosition *arg2 = 0 ;
42824 wxGBSpan *arg3 = 0 ;
42825 bool result;
42826 wxGBPosition temp2 ;
42827 wxGBSpan temp3 ;
42828 PyObject * obj0 = 0 ;
42829 PyObject * obj1 = 0 ;
42830 PyObject * obj2 = 0 ;
42831 char *kwnames[] = {
42832 (char *) "self",(char *) "pos",(char *) "span", NULL
42833 };
42834
42835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42837 if (SWIG_arg_fail(1)) SWIG_fail;
42838 {
42839 arg2 = &temp2;
42840 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42841 }
42842 {
42843 arg3 = &temp3;
42844 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42845 }
42846 {
42847 PyThreadState* __tstate = wxPyBeginAllowThreads();
42848 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42849
42850 wxPyEndAllowThreads(__tstate);
42851 if (PyErr_Occurred()) SWIG_fail;
42852 }
42853 {
42854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42855 }
42856 return resultobj;
42857 fail:
42858 return NULL;
42859 }
42860
42861
42862 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42863 PyObject *resultobj;
42864 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42865 wxGBPosition result;
42866 PyObject * obj0 = 0 ;
42867 char *kwnames[] = {
42868 (char *) "self", NULL
42869 };
42870
42871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42873 if (SWIG_arg_fail(1)) SWIG_fail;
42874 {
42875 PyThreadState* __tstate = wxPyBeginAllowThreads();
42876 result = wxGBSizerItem_GetEndPos(arg1);
42877
42878 wxPyEndAllowThreads(__tstate);
42879 if (PyErr_Occurred()) SWIG_fail;
42880 }
42881 {
42882 wxGBPosition * resultptr;
42883 resultptr = new wxGBPosition((wxGBPosition &)(result));
42884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42885 }
42886 return resultobj;
42887 fail:
42888 return NULL;
42889 }
42890
42891
42892 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42893 PyObject *resultobj;
42894 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42895 wxGridBagSizer *result;
42896 PyObject * obj0 = 0 ;
42897 char *kwnames[] = {
42898 (char *) "self", NULL
42899 };
42900
42901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42903 if (SWIG_arg_fail(1)) SWIG_fail;
42904 {
42905 PyThreadState* __tstate = wxPyBeginAllowThreads();
42906 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42907
42908 wxPyEndAllowThreads(__tstate);
42909 if (PyErr_Occurred()) SWIG_fail;
42910 }
42911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42912 return resultobj;
42913 fail:
42914 return NULL;
42915 }
42916
42917
42918 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42919 PyObject *resultobj;
42920 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42921 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42922 PyObject * obj0 = 0 ;
42923 PyObject * obj1 = 0 ;
42924 char *kwnames[] = {
42925 (char *) "self",(char *) "sizer", NULL
42926 };
42927
42928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42930 if (SWIG_arg_fail(1)) SWIG_fail;
42931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42932 if (SWIG_arg_fail(2)) SWIG_fail;
42933 {
42934 PyThreadState* __tstate = wxPyBeginAllowThreads();
42935 (arg1)->SetGBSizer(arg2);
42936
42937 wxPyEndAllowThreads(__tstate);
42938 if (PyErr_Occurred()) SWIG_fail;
42939 }
42940 Py_INCREF(Py_None); resultobj = Py_None;
42941 return resultobj;
42942 fail:
42943 return NULL;
42944 }
42945
42946
42947 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42948 PyObject *obj;
42949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42950 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42951 Py_INCREF(obj);
42952 return Py_BuildValue((char *)"");
42953 }
42954 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42955 PyObject *resultobj;
42956 int arg1 = (int) 0 ;
42957 int arg2 = (int) 0 ;
42958 wxGridBagSizer *result;
42959 PyObject * obj0 = 0 ;
42960 PyObject * obj1 = 0 ;
42961 char *kwnames[] = {
42962 (char *) "vgap",(char *) "hgap", NULL
42963 };
42964
42965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42966 if (obj0) {
42967 {
42968 arg1 = (int)(SWIG_As_int(obj0));
42969 if (SWIG_arg_fail(1)) SWIG_fail;
42970 }
42971 }
42972 if (obj1) {
42973 {
42974 arg2 = (int)(SWIG_As_int(obj1));
42975 if (SWIG_arg_fail(2)) SWIG_fail;
42976 }
42977 }
42978 {
42979 PyThreadState* __tstate = wxPyBeginAllowThreads();
42980 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42981
42982 wxPyEndAllowThreads(__tstate);
42983 if (PyErr_Occurred()) SWIG_fail;
42984 }
42985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42986 return resultobj;
42987 fail:
42988 return NULL;
42989 }
42990
42991
42992 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42993 PyObject *resultobj;
42994 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42995 PyObject *arg2 = (PyObject *) 0 ;
42996 wxGBPosition *arg3 = 0 ;
42997 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42998 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42999 int arg5 = (int) 0 ;
43000 int arg6 = (int) 0 ;
43001 PyObject *arg7 = (PyObject *) NULL ;
43002 wxGBSizerItem *result;
43003 wxGBPosition temp3 ;
43004 wxGBSpan temp4 ;
43005 PyObject * obj0 = 0 ;
43006 PyObject * obj1 = 0 ;
43007 PyObject * obj2 = 0 ;
43008 PyObject * obj3 = 0 ;
43009 PyObject * obj4 = 0 ;
43010 PyObject * obj5 = 0 ;
43011 PyObject * obj6 = 0 ;
43012 char *kwnames[] = {
43013 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43014 };
43015
43016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43018 if (SWIG_arg_fail(1)) SWIG_fail;
43019 arg2 = obj1;
43020 {
43021 arg3 = &temp3;
43022 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43023 }
43024 if (obj3) {
43025 {
43026 arg4 = &temp4;
43027 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43028 }
43029 }
43030 if (obj4) {
43031 {
43032 arg5 = (int)(SWIG_As_int(obj4));
43033 if (SWIG_arg_fail(5)) SWIG_fail;
43034 }
43035 }
43036 if (obj5) {
43037 {
43038 arg6 = (int)(SWIG_As_int(obj5));
43039 if (SWIG_arg_fail(6)) SWIG_fail;
43040 }
43041 }
43042 if (obj6) {
43043 arg7 = obj6;
43044 }
43045 {
43046 PyThreadState* __tstate = wxPyBeginAllowThreads();
43047 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43048
43049 wxPyEndAllowThreads(__tstate);
43050 if (PyErr_Occurred()) SWIG_fail;
43051 }
43052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43053 return resultobj;
43054 fail:
43055 return NULL;
43056 }
43057
43058
43059 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43060 PyObject *resultobj;
43061 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43062 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43063 wxGBSizerItem *result;
43064 PyObject * obj0 = 0 ;
43065 PyObject * obj1 = 0 ;
43066 char *kwnames[] = {
43067 (char *) "self",(char *) "item", NULL
43068 };
43069
43070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43072 if (SWIG_arg_fail(1)) SWIG_fail;
43073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43074 if (SWIG_arg_fail(2)) SWIG_fail;
43075 {
43076 PyThreadState* __tstate = wxPyBeginAllowThreads();
43077 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43078
43079 wxPyEndAllowThreads(__tstate);
43080 if (PyErr_Occurred()) SWIG_fail;
43081 }
43082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43083 return resultobj;
43084 fail:
43085 return NULL;
43086 }
43087
43088
43089 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43090 PyObject *resultobj;
43091 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43092 int arg2 ;
43093 int arg3 ;
43094 wxSize result;
43095 PyObject * obj0 = 0 ;
43096 PyObject * obj1 = 0 ;
43097 PyObject * obj2 = 0 ;
43098 char *kwnames[] = {
43099 (char *) "self",(char *) "row",(char *) "col", NULL
43100 };
43101
43102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43104 if (SWIG_arg_fail(1)) SWIG_fail;
43105 {
43106 arg2 = (int)(SWIG_As_int(obj1));
43107 if (SWIG_arg_fail(2)) SWIG_fail;
43108 }
43109 {
43110 arg3 = (int)(SWIG_As_int(obj2));
43111 if (SWIG_arg_fail(3)) SWIG_fail;
43112 }
43113 {
43114 PyThreadState* __tstate = wxPyBeginAllowThreads();
43115 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43116
43117 wxPyEndAllowThreads(__tstate);
43118 if (PyErr_Occurred()) SWIG_fail;
43119 }
43120 {
43121 wxSize * resultptr;
43122 resultptr = new wxSize((wxSize &)(result));
43123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43124 }
43125 return resultobj;
43126 fail:
43127 return NULL;
43128 }
43129
43130
43131 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43132 PyObject *resultobj;
43133 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43134 wxSize result;
43135 PyObject * obj0 = 0 ;
43136 char *kwnames[] = {
43137 (char *) "self", NULL
43138 };
43139
43140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
43145 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43146
43147 wxPyEndAllowThreads(__tstate);
43148 if (PyErr_Occurred()) SWIG_fail;
43149 }
43150 {
43151 wxSize * resultptr;
43152 resultptr = new wxSize((wxSize &)(result));
43153 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43154 }
43155 return resultobj;
43156 fail:
43157 return NULL;
43158 }
43159
43160
43161 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43162 PyObject *resultobj;
43163 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43164 wxSize *arg2 = 0 ;
43165 wxSize temp2 ;
43166 PyObject * obj0 = 0 ;
43167 PyObject * obj1 = 0 ;
43168 char *kwnames[] = {
43169 (char *) "self",(char *) "sz", NULL
43170 };
43171
43172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43174 if (SWIG_arg_fail(1)) SWIG_fail;
43175 {
43176 arg2 = &temp2;
43177 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43178 }
43179 {
43180 PyThreadState* __tstate = wxPyBeginAllowThreads();
43181 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43182
43183 wxPyEndAllowThreads(__tstate);
43184 if (PyErr_Occurred()) SWIG_fail;
43185 }
43186 Py_INCREF(Py_None); resultobj = Py_None;
43187 return resultobj;
43188 fail:
43189 return NULL;
43190 }
43191
43192
43193 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43194 PyObject *resultobj;
43195 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43196 wxWindow *arg2 = (wxWindow *) 0 ;
43197 wxGBPosition result;
43198 PyObject * obj0 = 0 ;
43199 PyObject * obj1 = 0 ;
43200
43201 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43203 if (SWIG_arg_fail(1)) SWIG_fail;
43204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43205 if (SWIG_arg_fail(2)) SWIG_fail;
43206 {
43207 PyThreadState* __tstate = wxPyBeginAllowThreads();
43208 result = (arg1)->GetItemPosition(arg2);
43209
43210 wxPyEndAllowThreads(__tstate);
43211 if (PyErr_Occurred()) SWIG_fail;
43212 }
43213 {
43214 wxGBPosition * resultptr;
43215 resultptr = new wxGBPosition((wxGBPosition &)(result));
43216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43217 }
43218 return resultobj;
43219 fail:
43220 return NULL;
43221 }
43222
43223
43224 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43225 PyObject *resultobj;
43226 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43227 wxSizer *arg2 = (wxSizer *) 0 ;
43228 wxGBPosition result;
43229 PyObject * obj0 = 0 ;
43230 PyObject * obj1 = 0 ;
43231
43232 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43234 if (SWIG_arg_fail(1)) SWIG_fail;
43235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43236 if (SWIG_arg_fail(2)) SWIG_fail;
43237 {
43238 PyThreadState* __tstate = wxPyBeginAllowThreads();
43239 result = (arg1)->GetItemPosition(arg2);
43240
43241 wxPyEndAllowThreads(__tstate);
43242 if (PyErr_Occurred()) SWIG_fail;
43243 }
43244 {
43245 wxGBPosition * resultptr;
43246 resultptr = new wxGBPosition((wxGBPosition &)(result));
43247 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43248 }
43249 return resultobj;
43250 fail:
43251 return NULL;
43252 }
43253
43254
43255 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43256 PyObject *resultobj;
43257 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43258 size_t arg2 ;
43259 wxGBPosition result;
43260 PyObject * obj0 = 0 ;
43261 PyObject * obj1 = 0 ;
43262
43263 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43265 if (SWIG_arg_fail(1)) SWIG_fail;
43266 {
43267 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43268 if (SWIG_arg_fail(2)) SWIG_fail;
43269 }
43270 {
43271 PyThreadState* __tstate = wxPyBeginAllowThreads();
43272 result = (arg1)->GetItemPosition(arg2);
43273
43274 wxPyEndAllowThreads(__tstate);
43275 if (PyErr_Occurred()) SWIG_fail;
43276 }
43277 {
43278 wxGBPosition * resultptr;
43279 resultptr = new wxGBPosition((wxGBPosition &)(result));
43280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43281 }
43282 return resultobj;
43283 fail:
43284 return NULL;
43285 }
43286
43287
43288 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43289 int argc;
43290 PyObject *argv[3];
43291 int ii;
43292
43293 argc = PyObject_Length(args);
43294 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43295 argv[ii] = PyTuple_GetItem(args,ii);
43296 }
43297 if (argc == 2) {
43298 int _v;
43299 {
43300 void *ptr;
43301 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43302 _v = 0;
43303 PyErr_Clear();
43304 } else {
43305 _v = 1;
43306 }
43307 }
43308 if (_v) {
43309 {
43310 void *ptr;
43311 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43312 _v = 0;
43313 PyErr_Clear();
43314 } else {
43315 _v = 1;
43316 }
43317 }
43318 if (_v) {
43319 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43320 }
43321 }
43322 }
43323 if (argc == 2) {
43324 int _v;
43325 {
43326 void *ptr;
43327 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43328 _v = 0;
43329 PyErr_Clear();
43330 } else {
43331 _v = 1;
43332 }
43333 }
43334 if (_v) {
43335 {
43336 void *ptr;
43337 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43338 _v = 0;
43339 PyErr_Clear();
43340 } else {
43341 _v = 1;
43342 }
43343 }
43344 if (_v) {
43345 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43346 }
43347 }
43348 }
43349 if (argc == 2) {
43350 int _v;
43351 {
43352 void *ptr;
43353 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43354 _v = 0;
43355 PyErr_Clear();
43356 } else {
43357 _v = 1;
43358 }
43359 }
43360 if (_v) {
43361 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43362 if (_v) {
43363 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43364 }
43365 }
43366 }
43367
43368 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43369 return NULL;
43370 }
43371
43372
43373 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43374 PyObject *resultobj;
43375 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43376 wxWindow *arg2 = (wxWindow *) 0 ;
43377 wxGBPosition *arg3 = 0 ;
43378 bool result;
43379 wxGBPosition temp3 ;
43380 PyObject * obj0 = 0 ;
43381 PyObject * obj1 = 0 ;
43382 PyObject * obj2 = 0 ;
43383
43384 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43386 if (SWIG_arg_fail(1)) SWIG_fail;
43387 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43388 if (SWIG_arg_fail(2)) SWIG_fail;
43389 {
43390 arg3 = &temp3;
43391 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43392 }
43393 {
43394 PyThreadState* __tstate = wxPyBeginAllowThreads();
43395 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43396
43397 wxPyEndAllowThreads(__tstate);
43398 if (PyErr_Occurred()) SWIG_fail;
43399 }
43400 {
43401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43402 }
43403 return resultobj;
43404 fail:
43405 return NULL;
43406 }
43407
43408
43409 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43410 PyObject *resultobj;
43411 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43412 wxSizer *arg2 = (wxSizer *) 0 ;
43413 wxGBPosition *arg3 = 0 ;
43414 bool result;
43415 wxGBPosition temp3 ;
43416 PyObject * obj0 = 0 ;
43417 PyObject * obj1 = 0 ;
43418 PyObject * obj2 = 0 ;
43419
43420 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43422 if (SWIG_arg_fail(1)) SWIG_fail;
43423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43424 if (SWIG_arg_fail(2)) SWIG_fail;
43425 {
43426 arg3 = &temp3;
43427 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43428 }
43429 {
43430 PyThreadState* __tstate = wxPyBeginAllowThreads();
43431 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43432
43433 wxPyEndAllowThreads(__tstate);
43434 if (PyErr_Occurred()) SWIG_fail;
43435 }
43436 {
43437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43438 }
43439 return resultobj;
43440 fail:
43441 return NULL;
43442 }
43443
43444
43445 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43446 PyObject *resultobj;
43447 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43448 size_t arg2 ;
43449 wxGBPosition *arg3 = 0 ;
43450 bool result;
43451 wxGBPosition temp3 ;
43452 PyObject * obj0 = 0 ;
43453 PyObject * obj1 = 0 ;
43454 PyObject * obj2 = 0 ;
43455
43456 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43458 if (SWIG_arg_fail(1)) SWIG_fail;
43459 {
43460 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43461 if (SWIG_arg_fail(2)) SWIG_fail;
43462 }
43463 {
43464 arg3 = &temp3;
43465 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43466 }
43467 {
43468 PyThreadState* __tstate = wxPyBeginAllowThreads();
43469 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43470
43471 wxPyEndAllowThreads(__tstate);
43472 if (PyErr_Occurred()) SWIG_fail;
43473 }
43474 {
43475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43476 }
43477 return resultobj;
43478 fail:
43479 return NULL;
43480 }
43481
43482
43483 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43484 int argc;
43485 PyObject *argv[4];
43486 int ii;
43487
43488 argc = PyObject_Length(args);
43489 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43490 argv[ii] = PyTuple_GetItem(args,ii);
43491 }
43492 if (argc == 3) {
43493 int _v;
43494 {
43495 void *ptr;
43496 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43497 _v = 0;
43498 PyErr_Clear();
43499 } else {
43500 _v = 1;
43501 }
43502 }
43503 if (_v) {
43504 {
43505 void *ptr;
43506 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43507 _v = 0;
43508 PyErr_Clear();
43509 } else {
43510 _v = 1;
43511 }
43512 }
43513 if (_v) {
43514 {
43515 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43516 }
43517 if (_v) {
43518 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43519 }
43520 }
43521 }
43522 }
43523 if (argc == 3) {
43524 int _v;
43525 {
43526 void *ptr;
43527 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43528 _v = 0;
43529 PyErr_Clear();
43530 } else {
43531 _v = 1;
43532 }
43533 }
43534 if (_v) {
43535 {
43536 void *ptr;
43537 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43538 _v = 0;
43539 PyErr_Clear();
43540 } else {
43541 _v = 1;
43542 }
43543 }
43544 if (_v) {
43545 {
43546 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43547 }
43548 if (_v) {
43549 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43550 }
43551 }
43552 }
43553 }
43554 if (argc == 3) {
43555 int _v;
43556 {
43557 void *ptr;
43558 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43559 _v = 0;
43560 PyErr_Clear();
43561 } else {
43562 _v = 1;
43563 }
43564 }
43565 if (_v) {
43566 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43567 if (_v) {
43568 {
43569 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43570 }
43571 if (_v) {
43572 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43573 }
43574 }
43575 }
43576 }
43577
43578 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43579 return NULL;
43580 }
43581
43582
43583 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43584 PyObject *resultobj;
43585 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43586 wxWindow *arg2 = (wxWindow *) 0 ;
43587 wxGBSpan result;
43588 PyObject * obj0 = 0 ;
43589 PyObject * obj1 = 0 ;
43590
43591 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43593 if (SWIG_arg_fail(1)) SWIG_fail;
43594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43595 if (SWIG_arg_fail(2)) SWIG_fail;
43596 {
43597 PyThreadState* __tstate = wxPyBeginAllowThreads();
43598 result = (arg1)->GetItemSpan(arg2);
43599
43600 wxPyEndAllowThreads(__tstate);
43601 if (PyErr_Occurred()) SWIG_fail;
43602 }
43603 {
43604 wxGBSpan * resultptr;
43605 resultptr = new wxGBSpan((wxGBSpan &)(result));
43606 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43607 }
43608 return resultobj;
43609 fail:
43610 return NULL;
43611 }
43612
43613
43614 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43615 PyObject *resultobj;
43616 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43617 wxSizer *arg2 = (wxSizer *) 0 ;
43618 wxGBSpan result;
43619 PyObject * obj0 = 0 ;
43620 PyObject * obj1 = 0 ;
43621
43622 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43624 if (SWIG_arg_fail(1)) SWIG_fail;
43625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43626 if (SWIG_arg_fail(2)) SWIG_fail;
43627 {
43628 PyThreadState* __tstate = wxPyBeginAllowThreads();
43629 result = (arg1)->GetItemSpan(arg2);
43630
43631 wxPyEndAllowThreads(__tstate);
43632 if (PyErr_Occurred()) SWIG_fail;
43633 }
43634 {
43635 wxGBSpan * resultptr;
43636 resultptr = new wxGBSpan((wxGBSpan &)(result));
43637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43638 }
43639 return resultobj;
43640 fail:
43641 return NULL;
43642 }
43643
43644
43645 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43646 PyObject *resultobj;
43647 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43648 size_t arg2 ;
43649 wxGBSpan result;
43650 PyObject * obj0 = 0 ;
43651 PyObject * obj1 = 0 ;
43652
43653 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43655 if (SWIG_arg_fail(1)) SWIG_fail;
43656 {
43657 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43658 if (SWIG_arg_fail(2)) SWIG_fail;
43659 }
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (arg1)->GetItemSpan(arg2);
43663
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 {
43668 wxGBSpan * resultptr;
43669 resultptr = new wxGBSpan((wxGBSpan &)(result));
43670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43671 }
43672 return resultobj;
43673 fail:
43674 return NULL;
43675 }
43676
43677
43678 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43679 int argc;
43680 PyObject *argv[3];
43681 int ii;
43682
43683 argc = PyObject_Length(args);
43684 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43685 argv[ii] = PyTuple_GetItem(args,ii);
43686 }
43687 if (argc == 2) {
43688 int _v;
43689 {
43690 void *ptr;
43691 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43692 _v = 0;
43693 PyErr_Clear();
43694 } else {
43695 _v = 1;
43696 }
43697 }
43698 if (_v) {
43699 {
43700 void *ptr;
43701 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43702 _v = 0;
43703 PyErr_Clear();
43704 } else {
43705 _v = 1;
43706 }
43707 }
43708 if (_v) {
43709 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43710 }
43711 }
43712 }
43713 if (argc == 2) {
43714 int _v;
43715 {
43716 void *ptr;
43717 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43718 _v = 0;
43719 PyErr_Clear();
43720 } else {
43721 _v = 1;
43722 }
43723 }
43724 if (_v) {
43725 {
43726 void *ptr;
43727 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43728 _v = 0;
43729 PyErr_Clear();
43730 } else {
43731 _v = 1;
43732 }
43733 }
43734 if (_v) {
43735 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43736 }
43737 }
43738 }
43739 if (argc == 2) {
43740 int _v;
43741 {
43742 void *ptr;
43743 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43744 _v = 0;
43745 PyErr_Clear();
43746 } else {
43747 _v = 1;
43748 }
43749 }
43750 if (_v) {
43751 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43752 if (_v) {
43753 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43754 }
43755 }
43756 }
43757
43758 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43759 return NULL;
43760 }
43761
43762
43763 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43764 PyObject *resultobj;
43765 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43766 wxWindow *arg2 = (wxWindow *) 0 ;
43767 wxGBSpan *arg3 = 0 ;
43768 bool result;
43769 wxGBSpan temp3 ;
43770 PyObject * obj0 = 0 ;
43771 PyObject * obj1 = 0 ;
43772 PyObject * obj2 = 0 ;
43773
43774 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43776 if (SWIG_arg_fail(1)) SWIG_fail;
43777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43778 if (SWIG_arg_fail(2)) SWIG_fail;
43779 {
43780 arg3 = &temp3;
43781 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43782 }
43783 {
43784 PyThreadState* __tstate = wxPyBeginAllowThreads();
43785 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43786
43787 wxPyEndAllowThreads(__tstate);
43788 if (PyErr_Occurred()) SWIG_fail;
43789 }
43790 {
43791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43792 }
43793 return resultobj;
43794 fail:
43795 return NULL;
43796 }
43797
43798
43799 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43800 PyObject *resultobj;
43801 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43802 wxSizer *arg2 = (wxSizer *) 0 ;
43803 wxGBSpan *arg3 = 0 ;
43804 bool result;
43805 wxGBSpan temp3 ;
43806 PyObject * obj0 = 0 ;
43807 PyObject * obj1 = 0 ;
43808 PyObject * obj2 = 0 ;
43809
43810 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43812 if (SWIG_arg_fail(1)) SWIG_fail;
43813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43814 if (SWIG_arg_fail(2)) SWIG_fail;
43815 {
43816 arg3 = &temp3;
43817 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43818 }
43819 {
43820 PyThreadState* __tstate = wxPyBeginAllowThreads();
43821 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43822
43823 wxPyEndAllowThreads(__tstate);
43824 if (PyErr_Occurred()) SWIG_fail;
43825 }
43826 {
43827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43828 }
43829 return resultobj;
43830 fail:
43831 return NULL;
43832 }
43833
43834
43835 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43836 PyObject *resultobj;
43837 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43838 size_t arg2 ;
43839 wxGBSpan *arg3 = 0 ;
43840 bool result;
43841 wxGBSpan temp3 ;
43842 PyObject * obj0 = 0 ;
43843 PyObject * obj1 = 0 ;
43844 PyObject * obj2 = 0 ;
43845
43846 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43848 if (SWIG_arg_fail(1)) SWIG_fail;
43849 {
43850 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43851 if (SWIG_arg_fail(2)) SWIG_fail;
43852 }
43853 {
43854 arg3 = &temp3;
43855 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43856 }
43857 {
43858 PyThreadState* __tstate = wxPyBeginAllowThreads();
43859 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43860
43861 wxPyEndAllowThreads(__tstate);
43862 if (PyErr_Occurred()) SWIG_fail;
43863 }
43864 {
43865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43866 }
43867 return resultobj;
43868 fail:
43869 return NULL;
43870 }
43871
43872
43873 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43874 int argc;
43875 PyObject *argv[4];
43876 int ii;
43877
43878 argc = PyObject_Length(args);
43879 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43880 argv[ii] = PyTuple_GetItem(args,ii);
43881 }
43882 if (argc == 3) {
43883 int _v;
43884 {
43885 void *ptr;
43886 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43887 _v = 0;
43888 PyErr_Clear();
43889 } else {
43890 _v = 1;
43891 }
43892 }
43893 if (_v) {
43894 {
43895 void *ptr;
43896 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43897 _v = 0;
43898 PyErr_Clear();
43899 } else {
43900 _v = 1;
43901 }
43902 }
43903 if (_v) {
43904 {
43905 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43906 }
43907 if (_v) {
43908 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43909 }
43910 }
43911 }
43912 }
43913 if (argc == 3) {
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_wxSizer, 0) == -1) {
43928 _v = 0;
43929 PyErr_Clear();
43930 } else {
43931 _v = 1;
43932 }
43933 }
43934 if (_v) {
43935 {
43936 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43937 }
43938 if (_v) {
43939 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43940 }
43941 }
43942 }
43943 }
43944 if (argc == 3) {
43945 int _v;
43946 {
43947 void *ptr;
43948 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43949 _v = 0;
43950 PyErr_Clear();
43951 } else {
43952 _v = 1;
43953 }
43954 }
43955 if (_v) {
43956 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43957 if (_v) {
43958 {
43959 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43960 }
43961 if (_v) {
43962 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43963 }
43964 }
43965 }
43966 }
43967
43968 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43969 return NULL;
43970 }
43971
43972
43973 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43974 PyObject *resultobj;
43975 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43976 wxWindow *arg2 = (wxWindow *) 0 ;
43977 wxGBSizerItem *result;
43978 PyObject * obj0 = 0 ;
43979 PyObject * obj1 = 0 ;
43980
43981 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43983 if (SWIG_arg_fail(1)) SWIG_fail;
43984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43985 if (SWIG_arg_fail(2)) SWIG_fail;
43986 {
43987 PyThreadState* __tstate = wxPyBeginAllowThreads();
43988 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43989
43990 wxPyEndAllowThreads(__tstate);
43991 if (PyErr_Occurred()) SWIG_fail;
43992 }
43993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43994 return resultobj;
43995 fail:
43996 return NULL;
43997 }
43998
43999
44000 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44001 PyObject *resultobj;
44002 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44003 wxSizer *arg2 = (wxSizer *) 0 ;
44004 wxGBSizerItem *result;
44005 PyObject * obj0 = 0 ;
44006 PyObject * obj1 = 0 ;
44007
44008 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44010 if (SWIG_arg_fail(1)) SWIG_fail;
44011 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44012 if (SWIG_arg_fail(2)) SWIG_fail;
44013 {
44014 PyThreadState* __tstate = wxPyBeginAllowThreads();
44015 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44016
44017 wxPyEndAllowThreads(__tstate);
44018 if (PyErr_Occurred()) SWIG_fail;
44019 }
44020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44021 return resultobj;
44022 fail:
44023 return NULL;
44024 }
44025
44026
44027 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44028 int argc;
44029 PyObject *argv[3];
44030 int ii;
44031
44032 argc = PyObject_Length(args);
44033 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44034 argv[ii] = PyTuple_GetItem(args,ii);
44035 }
44036 if (argc == 2) {
44037 int _v;
44038 {
44039 void *ptr;
44040 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44041 _v = 0;
44042 PyErr_Clear();
44043 } else {
44044 _v = 1;
44045 }
44046 }
44047 if (_v) {
44048 {
44049 void *ptr;
44050 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44051 _v = 0;
44052 PyErr_Clear();
44053 } else {
44054 _v = 1;
44055 }
44056 }
44057 if (_v) {
44058 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44059 }
44060 }
44061 }
44062 if (argc == 2) {
44063 int _v;
44064 {
44065 void *ptr;
44066 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44067 _v = 0;
44068 PyErr_Clear();
44069 } else {
44070 _v = 1;
44071 }
44072 }
44073 if (_v) {
44074 {
44075 void *ptr;
44076 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44077 _v = 0;
44078 PyErr_Clear();
44079 } else {
44080 _v = 1;
44081 }
44082 }
44083 if (_v) {
44084 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44085 }
44086 }
44087 }
44088
44089 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44090 return NULL;
44091 }
44092
44093
44094 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44095 PyObject *resultobj;
44096 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44097 wxGBPosition *arg2 = 0 ;
44098 wxGBSizerItem *result;
44099 wxGBPosition temp2 ;
44100 PyObject * obj0 = 0 ;
44101 PyObject * obj1 = 0 ;
44102 char *kwnames[] = {
44103 (char *) "self",(char *) "pos", NULL
44104 };
44105
44106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44108 if (SWIG_arg_fail(1)) SWIG_fail;
44109 {
44110 arg2 = &temp2;
44111 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44112 }
44113 {
44114 PyThreadState* __tstate = wxPyBeginAllowThreads();
44115 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44116
44117 wxPyEndAllowThreads(__tstate);
44118 if (PyErr_Occurred()) SWIG_fail;
44119 }
44120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44121 return resultobj;
44122 fail:
44123 return NULL;
44124 }
44125
44126
44127 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44128 PyObject *resultobj;
44129 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44130 wxPoint *arg2 = 0 ;
44131 wxGBSizerItem *result;
44132 wxPoint temp2 ;
44133 PyObject * obj0 = 0 ;
44134 PyObject * obj1 = 0 ;
44135 char *kwnames[] = {
44136 (char *) "self",(char *) "pt", NULL
44137 };
44138
44139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44141 if (SWIG_arg_fail(1)) SWIG_fail;
44142 {
44143 arg2 = &temp2;
44144 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44145 }
44146 {
44147 PyThreadState* __tstate = wxPyBeginAllowThreads();
44148 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44149
44150 wxPyEndAllowThreads(__tstate);
44151 if (PyErr_Occurred()) SWIG_fail;
44152 }
44153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44154 return resultobj;
44155 fail:
44156 return NULL;
44157 }
44158
44159
44160 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44161 PyObject *resultobj;
44162 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44163 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44164 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44165 bool result;
44166 PyObject * obj0 = 0 ;
44167 PyObject * obj1 = 0 ;
44168 PyObject * obj2 = 0 ;
44169 char *kwnames[] = {
44170 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44171 };
44172
44173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44175 if (SWIG_arg_fail(1)) SWIG_fail;
44176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44177 if (SWIG_arg_fail(2)) SWIG_fail;
44178 if (obj2) {
44179 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44180 if (SWIG_arg_fail(3)) SWIG_fail;
44181 }
44182 {
44183 PyThreadState* __tstate = wxPyBeginAllowThreads();
44184 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44185
44186 wxPyEndAllowThreads(__tstate);
44187 if (PyErr_Occurred()) SWIG_fail;
44188 }
44189 {
44190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44191 }
44192 return resultobj;
44193 fail:
44194 return NULL;
44195 }
44196
44197
44198 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44199 PyObject *resultobj;
44200 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44201 wxGBPosition *arg2 = 0 ;
44202 wxGBSpan *arg3 = 0 ;
44203 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44204 bool result;
44205 wxGBPosition temp2 ;
44206 wxGBSpan temp3 ;
44207 PyObject * obj0 = 0 ;
44208 PyObject * obj1 = 0 ;
44209 PyObject * obj2 = 0 ;
44210 PyObject * obj3 = 0 ;
44211 char *kwnames[] = {
44212 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44213 };
44214
44215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44217 if (SWIG_arg_fail(1)) SWIG_fail;
44218 {
44219 arg2 = &temp2;
44220 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44221 }
44222 {
44223 arg3 = &temp3;
44224 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44225 }
44226 if (obj3) {
44227 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44228 if (SWIG_arg_fail(4)) SWIG_fail;
44229 }
44230 {
44231 PyThreadState* __tstate = wxPyBeginAllowThreads();
44232 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44233
44234 wxPyEndAllowThreads(__tstate);
44235 if (PyErr_Occurred()) SWIG_fail;
44236 }
44237 {
44238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44239 }
44240 return resultobj;
44241 fail:
44242 return NULL;
44243 }
44244
44245
44246 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44247 PyObject *obj;
44248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44249 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44250 Py_INCREF(obj);
44251 return Py_BuildValue((char *)"");
44252 }
44253 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44254 PyObject *resultobj;
44255 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44256 wxRelationship arg2 ;
44257 wxWindow *arg3 = (wxWindow *) 0 ;
44258 wxEdge arg4 ;
44259 int arg5 = (int) 0 ;
44260 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44261 PyObject * obj0 = 0 ;
44262 PyObject * obj1 = 0 ;
44263 PyObject * obj2 = 0 ;
44264 PyObject * obj3 = 0 ;
44265 PyObject * obj4 = 0 ;
44266 PyObject * obj5 = 0 ;
44267 char *kwnames[] = {
44268 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44269 };
44270
44271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44273 if (SWIG_arg_fail(1)) SWIG_fail;
44274 {
44275 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44276 if (SWIG_arg_fail(2)) SWIG_fail;
44277 }
44278 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44279 if (SWIG_arg_fail(3)) SWIG_fail;
44280 {
44281 arg4 = (wxEdge)(SWIG_As_int(obj3));
44282 if (SWIG_arg_fail(4)) SWIG_fail;
44283 }
44284 if (obj4) {
44285 {
44286 arg5 = (int)(SWIG_As_int(obj4));
44287 if (SWIG_arg_fail(5)) SWIG_fail;
44288 }
44289 }
44290 if (obj5) {
44291 {
44292 arg6 = (int)(SWIG_As_int(obj5));
44293 if (SWIG_arg_fail(6)) SWIG_fail;
44294 }
44295 }
44296 {
44297 PyThreadState* __tstate = wxPyBeginAllowThreads();
44298 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44299
44300 wxPyEndAllowThreads(__tstate);
44301 if (PyErr_Occurred()) SWIG_fail;
44302 }
44303 Py_INCREF(Py_None); resultobj = Py_None;
44304 return resultobj;
44305 fail:
44306 return NULL;
44307 }
44308
44309
44310 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44311 PyObject *resultobj;
44312 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44313 wxWindow *arg2 = (wxWindow *) 0 ;
44314 int arg3 = (int) 0 ;
44315 PyObject * obj0 = 0 ;
44316 PyObject * obj1 = 0 ;
44317 PyObject * obj2 = 0 ;
44318 char *kwnames[] = {
44319 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44320 };
44321
44322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44324 if (SWIG_arg_fail(1)) SWIG_fail;
44325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44326 if (SWIG_arg_fail(2)) SWIG_fail;
44327 if (obj2) {
44328 {
44329 arg3 = (int)(SWIG_As_int(obj2));
44330 if (SWIG_arg_fail(3)) SWIG_fail;
44331 }
44332 }
44333 {
44334 PyThreadState* __tstate = wxPyBeginAllowThreads();
44335 (arg1)->LeftOf(arg2,arg3);
44336
44337 wxPyEndAllowThreads(__tstate);
44338 if (PyErr_Occurred()) SWIG_fail;
44339 }
44340 Py_INCREF(Py_None); resultobj = Py_None;
44341 return resultobj;
44342 fail:
44343 return NULL;
44344 }
44345
44346
44347 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44348 PyObject *resultobj;
44349 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44350 wxWindow *arg2 = (wxWindow *) 0 ;
44351 int arg3 = (int) 0 ;
44352 PyObject * obj0 = 0 ;
44353 PyObject * obj1 = 0 ;
44354 PyObject * obj2 = 0 ;
44355 char *kwnames[] = {
44356 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44357 };
44358
44359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44361 if (SWIG_arg_fail(1)) SWIG_fail;
44362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44363 if (SWIG_arg_fail(2)) SWIG_fail;
44364 if (obj2) {
44365 {
44366 arg3 = (int)(SWIG_As_int(obj2));
44367 if (SWIG_arg_fail(3)) SWIG_fail;
44368 }
44369 }
44370 {
44371 PyThreadState* __tstate = wxPyBeginAllowThreads();
44372 (arg1)->RightOf(arg2,arg3);
44373
44374 wxPyEndAllowThreads(__tstate);
44375 if (PyErr_Occurred()) SWIG_fail;
44376 }
44377 Py_INCREF(Py_None); resultobj = Py_None;
44378 return resultobj;
44379 fail:
44380 return NULL;
44381 }
44382
44383
44384 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44385 PyObject *resultobj;
44386 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44387 wxWindow *arg2 = (wxWindow *) 0 ;
44388 int arg3 = (int) 0 ;
44389 PyObject * obj0 = 0 ;
44390 PyObject * obj1 = 0 ;
44391 PyObject * obj2 = 0 ;
44392 char *kwnames[] = {
44393 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44394 };
44395
44396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44398 if (SWIG_arg_fail(1)) SWIG_fail;
44399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44400 if (SWIG_arg_fail(2)) SWIG_fail;
44401 if (obj2) {
44402 {
44403 arg3 = (int)(SWIG_As_int(obj2));
44404 if (SWIG_arg_fail(3)) SWIG_fail;
44405 }
44406 }
44407 {
44408 PyThreadState* __tstate = wxPyBeginAllowThreads();
44409 (arg1)->Above(arg2,arg3);
44410
44411 wxPyEndAllowThreads(__tstate);
44412 if (PyErr_Occurred()) SWIG_fail;
44413 }
44414 Py_INCREF(Py_None); resultobj = Py_None;
44415 return resultobj;
44416 fail:
44417 return NULL;
44418 }
44419
44420
44421 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44422 PyObject *resultobj;
44423 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44424 wxWindow *arg2 = (wxWindow *) 0 ;
44425 int arg3 = (int) 0 ;
44426 PyObject * obj0 = 0 ;
44427 PyObject * obj1 = 0 ;
44428 PyObject * obj2 = 0 ;
44429 char *kwnames[] = {
44430 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44431 };
44432
44433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44435 if (SWIG_arg_fail(1)) SWIG_fail;
44436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44437 if (SWIG_arg_fail(2)) SWIG_fail;
44438 if (obj2) {
44439 {
44440 arg3 = (int)(SWIG_As_int(obj2));
44441 if (SWIG_arg_fail(3)) SWIG_fail;
44442 }
44443 }
44444 {
44445 PyThreadState* __tstate = wxPyBeginAllowThreads();
44446 (arg1)->Below(arg2,arg3);
44447
44448 wxPyEndAllowThreads(__tstate);
44449 if (PyErr_Occurred()) SWIG_fail;
44450 }
44451 Py_INCREF(Py_None); resultobj = Py_None;
44452 return resultobj;
44453 fail:
44454 return NULL;
44455 }
44456
44457
44458 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44459 PyObject *resultobj;
44460 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44461 wxWindow *arg2 = (wxWindow *) 0 ;
44462 wxEdge arg3 ;
44463 int arg4 = (int) 0 ;
44464 PyObject * obj0 = 0 ;
44465 PyObject * obj1 = 0 ;
44466 PyObject * obj2 = 0 ;
44467 PyObject * obj3 = 0 ;
44468 char *kwnames[] = {
44469 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44470 };
44471
44472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44474 if (SWIG_arg_fail(1)) SWIG_fail;
44475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44476 if (SWIG_arg_fail(2)) SWIG_fail;
44477 {
44478 arg3 = (wxEdge)(SWIG_As_int(obj2));
44479 if (SWIG_arg_fail(3)) SWIG_fail;
44480 }
44481 if (obj3) {
44482 {
44483 arg4 = (int)(SWIG_As_int(obj3));
44484 if (SWIG_arg_fail(4)) SWIG_fail;
44485 }
44486 }
44487 {
44488 PyThreadState* __tstate = wxPyBeginAllowThreads();
44489 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44490
44491 wxPyEndAllowThreads(__tstate);
44492 if (PyErr_Occurred()) SWIG_fail;
44493 }
44494 Py_INCREF(Py_None); resultobj = Py_None;
44495 return resultobj;
44496 fail:
44497 return NULL;
44498 }
44499
44500
44501 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44502 PyObject *resultobj;
44503 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44504 wxWindow *arg2 = (wxWindow *) 0 ;
44505 wxEdge arg3 ;
44506 int arg4 ;
44507 PyObject * obj0 = 0 ;
44508 PyObject * obj1 = 0 ;
44509 PyObject * obj2 = 0 ;
44510 PyObject * obj3 = 0 ;
44511 char *kwnames[] = {
44512 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44513 };
44514
44515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44517 if (SWIG_arg_fail(1)) SWIG_fail;
44518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44519 if (SWIG_arg_fail(2)) SWIG_fail;
44520 {
44521 arg3 = (wxEdge)(SWIG_As_int(obj2));
44522 if (SWIG_arg_fail(3)) SWIG_fail;
44523 }
44524 {
44525 arg4 = (int)(SWIG_As_int(obj3));
44526 if (SWIG_arg_fail(4)) SWIG_fail;
44527 }
44528 {
44529 PyThreadState* __tstate = wxPyBeginAllowThreads();
44530 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44531
44532 wxPyEndAllowThreads(__tstate);
44533 if (PyErr_Occurred()) SWIG_fail;
44534 }
44535 Py_INCREF(Py_None); resultobj = Py_None;
44536 return resultobj;
44537 fail:
44538 return NULL;
44539 }
44540
44541
44542 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44543 PyObject *resultobj;
44544 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44545 int arg2 ;
44546 PyObject * obj0 = 0 ;
44547 PyObject * obj1 = 0 ;
44548 char *kwnames[] = {
44549 (char *) "self",(char *) "val", NULL
44550 };
44551
44552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44554 if (SWIG_arg_fail(1)) SWIG_fail;
44555 {
44556 arg2 = (int)(SWIG_As_int(obj1));
44557 if (SWIG_arg_fail(2)) SWIG_fail;
44558 }
44559 {
44560 PyThreadState* __tstate = wxPyBeginAllowThreads();
44561 (arg1)->Absolute(arg2);
44562
44563 wxPyEndAllowThreads(__tstate);
44564 if (PyErr_Occurred()) SWIG_fail;
44565 }
44566 Py_INCREF(Py_None); resultobj = Py_None;
44567 return resultobj;
44568 fail:
44569 return NULL;
44570 }
44571
44572
44573 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44574 PyObject *resultobj;
44575 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44576 PyObject * obj0 = 0 ;
44577 char *kwnames[] = {
44578 (char *) "self", NULL
44579 };
44580
44581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44583 if (SWIG_arg_fail(1)) SWIG_fail;
44584 {
44585 PyThreadState* __tstate = wxPyBeginAllowThreads();
44586 (arg1)->Unconstrained();
44587
44588 wxPyEndAllowThreads(__tstate);
44589 if (PyErr_Occurred()) SWIG_fail;
44590 }
44591 Py_INCREF(Py_None); resultobj = Py_None;
44592 return resultobj;
44593 fail:
44594 return NULL;
44595 }
44596
44597
44598 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44599 PyObject *resultobj;
44600 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44601 PyObject * obj0 = 0 ;
44602 char *kwnames[] = {
44603 (char *) "self", NULL
44604 };
44605
44606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44608 if (SWIG_arg_fail(1)) SWIG_fail;
44609 {
44610 PyThreadState* __tstate = wxPyBeginAllowThreads();
44611 (arg1)->AsIs();
44612
44613 wxPyEndAllowThreads(__tstate);
44614 if (PyErr_Occurred()) SWIG_fail;
44615 }
44616 Py_INCREF(Py_None); resultobj = Py_None;
44617 return resultobj;
44618 fail:
44619 return NULL;
44620 }
44621
44622
44623 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44624 PyObject *resultobj;
44625 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44626 wxWindow *result;
44627 PyObject * obj0 = 0 ;
44628 char *kwnames[] = {
44629 (char *) "self", NULL
44630 };
44631
44632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44634 if (SWIG_arg_fail(1)) SWIG_fail;
44635 {
44636 PyThreadState* __tstate = wxPyBeginAllowThreads();
44637 result = (wxWindow *)(arg1)->GetOtherWindow();
44638
44639 wxPyEndAllowThreads(__tstate);
44640 if (PyErr_Occurred()) SWIG_fail;
44641 }
44642 {
44643 resultobj = wxPyMake_wxObject(result, 0);
44644 }
44645 return resultobj;
44646 fail:
44647 return NULL;
44648 }
44649
44650
44651 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44652 PyObject *resultobj;
44653 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44654 wxEdge result;
44655 PyObject * obj0 = 0 ;
44656 char *kwnames[] = {
44657 (char *) "self", NULL
44658 };
44659
44660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44662 if (SWIG_arg_fail(1)) SWIG_fail;
44663 {
44664 PyThreadState* __tstate = wxPyBeginAllowThreads();
44665 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44666
44667 wxPyEndAllowThreads(__tstate);
44668 if (PyErr_Occurred()) SWIG_fail;
44669 }
44670 resultobj = SWIG_From_int((result));
44671 return resultobj;
44672 fail:
44673 return NULL;
44674 }
44675
44676
44677 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44678 PyObject *resultobj;
44679 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44680 wxEdge arg2 ;
44681 PyObject * obj0 = 0 ;
44682 PyObject * obj1 = 0 ;
44683 char *kwnames[] = {
44684 (char *) "self",(char *) "which", NULL
44685 };
44686
44687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44689 if (SWIG_arg_fail(1)) SWIG_fail;
44690 {
44691 arg2 = (wxEdge)(SWIG_As_int(obj1));
44692 if (SWIG_arg_fail(2)) SWIG_fail;
44693 }
44694 {
44695 PyThreadState* __tstate = wxPyBeginAllowThreads();
44696 (arg1)->SetEdge((wxEdge )arg2);
44697
44698 wxPyEndAllowThreads(__tstate);
44699 if (PyErr_Occurred()) SWIG_fail;
44700 }
44701 Py_INCREF(Py_None); resultobj = Py_None;
44702 return resultobj;
44703 fail:
44704 return NULL;
44705 }
44706
44707
44708 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44709 PyObject *resultobj;
44710 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44711 int arg2 ;
44712 PyObject * obj0 = 0 ;
44713 PyObject * obj1 = 0 ;
44714 char *kwnames[] = {
44715 (char *) "self",(char *) "v", NULL
44716 };
44717
44718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44720 if (SWIG_arg_fail(1)) SWIG_fail;
44721 {
44722 arg2 = (int)(SWIG_As_int(obj1));
44723 if (SWIG_arg_fail(2)) SWIG_fail;
44724 }
44725 {
44726 PyThreadState* __tstate = wxPyBeginAllowThreads();
44727 (arg1)->SetValue(arg2);
44728
44729 wxPyEndAllowThreads(__tstate);
44730 if (PyErr_Occurred()) SWIG_fail;
44731 }
44732 Py_INCREF(Py_None); resultobj = Py_None;
44733 return resultobj;
44734 fail:
44735 return NULL;
44736 }
44737
44738
44739 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44740 PyObject *resultobj;
44741 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44742 int result;
44743 PyObject * obj0 = 0 ;
44744 char *kwnames[] = {
44745 (char *) "self", NULL
44746 };
44747
44748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44750 if (SWIG_arg_fail(1)) SWIG_fail;
44751 {
44752 PyThreadState* __tstate = wxPyBeginAllowThreads();
44753 result = (int)(arg1)->GetMargin();
44754
44755 wxPyEndAllowThreads(__tstate);
44756 if (PyErr_Occurred()) SWIG_fail;
44757 }
44758 {
44759 resultobj = SWIG_From_int((int)(result));
44760 }
44761 return resultobj;
44762 fail:
44763 return NULL;
44764 }
44765
44766
44767 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44768 PyObject *resultobj;
44769 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44770 int arg2 ;
44771 PyObject * obj0 = 0 ;
44772 PyObject * obj1 = 0 ;
44773 char *kwnames[] = {
44774 (char *) "self",(char *) "m", NULL
44775 };
44776
44777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44779 if (SWIG_arg_fail(1)) SWIG_fail;
44780 {
44781 arg2 = (int)(SWIG_As_int(obj1));
44782 if (SWIG_arg_fail(2)) SWIG_fail;
44783 }
44784 {
44785 PyThreadState* __tstate = wxPyBeginAllowThreads();
44786 (arg1)->SetMargin(arg2);
44787
44788 wxPyEndAllowThreads(__tstate);
44789 if (PyErr_Occurred()) SWIG_fail;
44790 }
44791 Py_INCREF(Py_None); resultobj = Py_None;
44792 return resultobj;
44793 fail:
44794 return NULL;
44795 }
44796
44797
44798 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44799 PyObject *resultobj;
44800 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44801 int result;
44802 PyObject * obj0 = 0 ;
44803 char *kwnames[] = {
44804 (char *) "self", NULL
44805 };
44806
44807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44809 if (SWIG_arg_fail(1)) SWIG_fail;
44810 {
44811 PyThreadState* __tstate = wxPyBeginAllowThreads();
44812 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44813
44814 wxPyEndAllowThreads(__tstate);
44815 if (PyErr_Occurred()) SWIG_fail;
44816 }
44817 {
44818 resultobj = SWIG_From_int((int)(result));
44819 }
44820 return resultobj;
44821 fail:
44822 return NULL;
44823 }
44824
44825
44826 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44827 PyObject *resultobj;
44828 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44829 int result;
44830 PyObject * obj0 = 0 ;
44831 char *kwnames[] = {
44832 (char *) "self", NULL
44833 };
44834
44835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44837 if (SWIG_arg_fail(1)) SWIG_fail;
44838 {
44839 PyThreadState* __tstate = wxPyBeginAllowThreads();
44840 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44841
44842 wxPyEndAllowThreads(__tstate);
44843 if (PyErr_Occurred()) SWIG_fail;
44844 }
44845 {
44846 resultobj = SWIG_From_int((int)(result));
44847 }
44848 return resultobj;
44849 fail:
44850 return NULL;
44851 }
44852
44853
44854 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44855 PyObject *resultobj;
44856 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44857 int result;
44858 PyObject * obj0 = 0 ;
44859 char *kwnames[] = {
44860 (char *) "self", NULL
44861 };
44862
44863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44865 if (SWIG_arg_fail(1)) SWIG_fail;
44866 {
44867 PyThreadState* __tstate = wxPyBeginAllowThreads();
44868 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44869
44870 wxPyEndAllowThreads(__tstate);
44871 if (PyErr_Occurred()) SWIG_fail;
44872 }
44873 {
44874 resultobj = SWIG_From_int((int)(result));
44875 }
44876 return resultobj;
44877 fail:
44878 return NULL;
44879 }
44880
44881
44882 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44883 PyObject *resultobj;
44884 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44885 bool result;
44886 PyObject * obj0 = 0 ;
44887 char *kwnames[] = {
44888 (char *) "self", NULL
44889 };
44890
44891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44893 if (SWIG_arg_fail(1)) SWIG_fail;
44894 {
44895 PyThreadState* __tstate = wxPyBeginAllowThreads();
44896 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44897
44898 wxPyEndAllowThreads(__tstate);
44899 if (PyErr_Occurred()) SWIG_fail;
44900 }
44901 {
44902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44903 }
44904 return resultobj;
44905 fail:
44906 return NULL;
44907 }
44908
44909
44910 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44911 PyObject *resultobj;
44912 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44913 bool arg2 ;
44914 PyObject * obj0 = 0 ;
44915 PyObject * obj1 = 0 ;
44916 char *kwnames[] = {
44917 (char *) "self",(char *) "d", NULL
44918 };
44919
44920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) 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 {
44924 arg2 = (bool)(SWIG_As_bool(obj1));
44925 if (SWIG_arg_fail(2)) SWIG_fail;
44926 }
44927 {
44928 PyThreadState* __tstate = wxPyBeginAllowThreads();
44929 (arg1)->SetDone(arg2);
44930
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 Py_INCREF(Py_None); resultobj = Py_None;
44935 return resultobj;
44936 fail:
44937 return NULL;
44938 }
44939
44940
44941 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44942 PyObject *resultobj;
44943 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44944 wxRelationship result;
44945 PyObject * obj0 = 0 ;
44946 char *kwnames[] = {
44947 (char *) "self", NULL
44948 };
44949
44950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44952 if (SWIG_arg_fail(1)) SWIG_fail;
44953 {
44954 PyThreadState* __tstate = wxPyBeginAllowThreads();
44955 result = (wxRelationship)(arg1)->GetRelationship();
44956
44957 wxPyEndAllowThreads(__tstate);
44958 if (PyErr_Occurred()) SWIG_fail;
44959 }
44960 resultobj = SWIG_From_int((result));
44961 return resultobj;
44962 fail:
44963 return NULL;
44964 }
44965
44966
44967 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44968 PyObject *resultobj;
44969 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44970 wxRelationship arg2 ;
44971 PyObject * obj0 = 0 ;
44972 PyObject * obj1 = 0 ;
44973 char *kwnames[] = {
44974 (char *) "self",(char *) "r", NULL
44975 };
44976
44977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44979 if (SWIG_arg_fail(1)) SWIG_fail;
44980 {
44981 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44982 if (SWIG_arg_fail(2)) SWIG_fail;
44983 }
44984 {
44985 PyThreadState* __tstate = wxPyBeginAllowThreads();
44986 (arg1)->SetRelationship((wxRelationship )arg2);
44987
44988 wxPyEndAllowThreads(__tstate);
44989 if (PyErr_Occurred()) SWIG_fail;
44990 }
44991 Py_INCREF(Py_None); resultobj = Py_None;
44992 return resultobj;
44993 fail:
44994 return NULL;
44995 }
44996
44997
44998 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44999 PyObject *resultobj;
45000 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45001 wxWindow *arg2 = (wxWindow *) 0 ;
45002 bool result;
45003 PyObject * obj0 = 0 ;
45004 PyObject * obj1 = 0 ;
45005 char *kwnames[] = {
45006 (char *) "self",(char *) "otherW", NULL
45007 };
45008
45009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45011 if (SWIG_arg_fail(1)) SWIG_fail;
45012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45013 if (SWIG_arg_fail(2)) SWIG_fail;
45014 {
45015 PyThreadState* __tstate = wxPyBeginAllowThreads();
45016 result = (bool)(arg1)->ResetIfWin(arg2);
45017
45018 wxPyEndAllowThreads(__tstate);
45019 if (PyErr_Occurred()) SWIG_fail;
45020 }
45021 {
45022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45023 }
45024 return resultobj;
45025 fail:
45026 return NULL;
45027 }
45028
45029
45030 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45031 PyObject *resultobj;
45032 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45033 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45034 wxWindow *arg3 = (wxWindow *) 0 ;
45035 bool result;
45036 PyObject * obj0 = 0 ;
45037 PyObject * obj1 = 0 ;
45038 PyObject * obj2 = 0 ;
45039 char *kwnames[] = {
45040 (char *) "self",(char *) "constraints",(char *) "win", NULL
45041 };
45042
45043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45045 if (SWIG_arg_fail(1)) SWIG_fail;
45046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45047 if (SWIG_arg_fail(2)) SWIG_fail;
45048 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45049 if (SWIG_arg_fail(3)) SWIG_fail;
45050 {
45051 PyThreadState* __tstate = wxPyBeginAllowThreads();
45052 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45053
45054 wxPyEndAllowThreads(__tstate);
45055 if (PyErr_Occurred()) SWIG_fail;
45056 }
45057 {
45058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45059 }
45060 return resultobj;
45061 fail:
45062 return NULL;
45063 }
45064
45065
45066 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45067 PyObject *resultobj;
45068 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45069 wxEdge arg2 ;
45070 wxWindow *arg3 = (wxWindow *) 0 ;
45071 wxWindow *arg4 = (wxWindow *) 0 ;
45072 int result;
45073 PyObject * obj0 = 0 ;
45074 PyObject * obj1 = 0 ;
45075 PyObject * obj2 = 0 ;
45076 PyObject * obj3 = 0 ;
45077 char *kwnames[] = {
45078 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45079 };
45080
45081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45083 if (SWIG_arg_fail(1)) SWIG_fail;
45084 {
45085 arg2 = (wxEdge)(SWIG_As_int(obj1));
45086 if (SWIG_arg_fail(2)) SWIG_fail;
45087 }
45088 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45089 if (SWIG_arg_fail(3)) SWIG_fail;
45090 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45091 if (SWIG_arg_fail(4)) SWIG_fail;
45092 {
45093 PyThreadState* __tstate = wxPyBeginAllowThreads();
45094 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45095
45096 wxPyEndAllowThreads(__tstate);
45097 if (PyErr_Occurred()) SWIG_fail;
45098 }
45099 {
45100 resultobj = SWIG_From_int((int)(result));
45101 }
45102 return resultobj;
45103 fail:
45104 return NULL;
45105 }
45106
45107
45108 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45109 PyObject *obj;
45110 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45111 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45112 Py_INCREF(obj);
45113 return Py_BuildValue((char *)"");
45114 }
45115 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45116 PyObject *resultobj;
45117 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45118 wxIndividualLayoutConstraint *result;
45119 PyObject * obj0 = 0 ;
45120 char *kwnames[] = {
45121 (char *) "self", NULL
45122 };
45123
45124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45126 if (SWIG_arg_fail(1)) SWIG_fail;
45127 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45128
45129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45130 return resultobj;
45131 fail:
45132 return NULL;
45133 }
45134
45135
45136 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45137 PyObject *resultobj;
45138 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45139 wxIndividualLayoutConstraint *result;
45140 PyObject * obj0 = 0 ;
45141 char *kwnames[] = {
45142 (char *) "self", NULL
45143 };
45144
45145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45147 if (SWIG_arg_fail(1)) SWIG_fail;
45148 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45149
45150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45151 return resultobj;
45152 fail:
45153 return NULL;
45154 }
45155
45156
45157 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45158 PyObject *resultobj;
45159 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45160 wxIndividualLayoutConstraint *result;
45161 PyObject * obj0 = 0 ;
45162 char *kwnames[] = {
45163 (char *) "self", NULL
45164 };
45165
45166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45168 if (SWIG_arg_fail(1)) SWIG_fail;
45169 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45170
45171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45172 return resultobj;
45173 fail:
45174 return NULL;
45175 }
45176
45177
45178 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45179 PyObject *resultobj;
45180 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45181 wxIndividualLayoutConstraint *result;
45182 PyObject * obj0 = 0 ;
45183 char *kwnames[] = {
45184 (char *) "self", NULL
45185 };
45186
45187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45189 if (SWIG_arg_fail(1)) SWIG_fail;
45190 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45191
45192 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45193 return resultobj;
45194 fail:
45195 return NULL;
45196 }
45197
45198
45199 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45200 PyObject *resultobj;
45201 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45202 wxIndividualLayoutConstraint *result;
45203 PyObject * obj0 = 0 ;
45204 char *kwnames[] = {
45205 (char *) "self", NULL
45206 };
45207
45208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45210 if (SWIG_arg_fail(1)) SWIG_fail;
45211 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45212
45213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45214 return resultobj;
45215 fail:
45216 return NULL;
45217 }
45218
45219
45220 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45221 PyObject *resultobj;
45222 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45223 wxIndividualLayoutConstraint *result;
45224 PyObject * obj0 = 0 ;
45225 char *kwnames[] = {
45226 (char *) "self", NULL
45227 };
45228
45229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",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 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45233
45234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45235 return resultobj;
45236 fail:
45237 return NULL;
45238 }
45239
45240
45241 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45242 PyObject *resultobj;
45243 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45244 wxIndividualLayoutConstraint *result;
45245 PyObject * obj0 = 0 ;
45246 char *kwnames[] = {
45247 (char *) "self", NULL
45248 };
45249
45250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45252 if (SWIG_arg_fail(1)) SWIG_fail;
45253 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45254
45255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45256 return resultobj;
45257 fail:
45258 return NULL;
45259 }
45260
45261
45262 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45263 PyObject *resultobj;
45264 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45265 wxIndividualLayoutConstraint *result;
45266 PyObject * obj0 = 0 ;
45267 char *kwnames[] = {
45268 (char *) "self", NULL
45269 };
45270
45271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45273 if (SWIG_arg_fail(1)) SWIG_fail;
45274 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45275
45276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45277 return resultobj;
45278 fail:
45279 return NULL;
45280 }
45281
45282
45283 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45284 PyObject *resultobj;
45285 wxLayoutConstraints *result;
45286 char *kwnames[] = {
45287 NULL
45288 };
45289
45290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45291 {
45292 PyThreadState* __tstate = wxPyBeginAllowThreads();
45293 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45294
45295 wxPyEndAllowThreads(__tstate);
45296 if (PyErr_Occurred()) SWIG_fail;
45297 }
45298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45299 return resultobj;
45300 fail:
45301 return NULL;
45302 }
45303
45304
45305 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45306 PyObject *resultobj;
45307 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45308 wxWindow *arg2 = (wxWindow *) 0 ;
45309 int *arg3 = (int *) 0 ;
45310 bool result;
45311 int temp3 ;
45312 int res3 = 0 ;
45313 PyObject * obj0 = 0 ;
45314 PyObject * obj1 = 0 ;
45315 char *kwnames[] = {
45316 (char *) "self",(char *) "win", NULL
45317 };
45318
45319 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45322 if (SWIG_arg_fail(1)) SWIG_fail;
45323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45324 if (SWIG_arg_fail(2)) SWIG_fail;
45325 {
45326 PyThreadState* __tstate = wxPyBeginAllowThreads();
45327 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45328
45329 wxPyEndAllowThreads(__tstate);
45330 if (PyErr_Occurred()) SWIG_fail;
45331 }
45332 {
45333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45334 }
45335 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45336 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45337 return resultobj;
45338 fail:
45339 return NULL;
45340 }
45341
45342
45343 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45344 PyObject *resultobj;
45345 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45346 bool result;
45347 PyObject * obj0 = 0 ;
45348 char *kwnames[] = {
45349 (char *) "self", NULL
45350 };
45351
45352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45354 if (SWIG_arg_fail(1)) SWIG_fail;
45355 {
45356 PyThreadState* __tstate = wxPyBeginAllowThreads();
45357 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45358
45359 wxPyEndAllowThreads(__tstate);
45360 if (PyErr_Occurred()) SWIG_fail;
45361 }
45362 {
45363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45364 }
45365 return resultobj;
45366 fail:
45367 return NULL;
45368 }
45369
45370
45371 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45372 PyObject *obj;
45373 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45374 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45375 Py_INCREF(obj);
45376 return Py_BuildValue((char *)"");
45377 }
45378 static PyMethodDef SwigMethods[] = {
45379 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45380 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45381 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45384 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45405 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45418 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45433 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45487 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45515 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45534 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45536 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45544 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45545 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45557 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45569 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45573 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45579 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45589 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45599 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45606 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45686 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45688 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45690 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45692 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45694 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45696 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45698 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45700 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45702 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45704 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45706 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45708 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45710 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45724 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45742 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45745 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45748 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45760 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45765 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45771 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45777 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45840 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45847 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45883 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45893 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45899 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45901 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45903 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45906 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45910 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45913 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45916 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45918 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45923 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45931 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45935 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45938 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45940 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45944 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45961 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45963 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45966 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45968 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45972 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45976 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45987 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45990 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45993 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45997 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46004 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46009 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46014 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46018 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46063 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46083 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46090 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46094 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46104 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46277 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46319 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46334 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46337 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46392 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46419 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46463 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46471 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46490 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46491 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46528 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46558 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46561 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46565 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46568 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46578 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46590 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46602 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46612 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46622 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46636 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46643 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46644 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46645 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46646 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46647 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46652 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46679 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46691 { NULL, NULL, 0, NULL }
46692 };
46693
46694
46695 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46696
46697 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46698 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46699 }
46700 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46701 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46702 }
46703 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46704 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46705 }
46706 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46707 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46708 }
46709 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46710 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46711 }
46712 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46713 return (void *)((wxSizer *) ((wxGridSizer *) x));
46714 }
46715 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46716 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46717 }
46718 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46719 return (void *)((wxSizer *) ((wxPySizer *) x));
46720 }
46721 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46722 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46723 }
46724 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46725 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46726 }
46727 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46728 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46729 }
46730 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46731 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46732 }
46733 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46734 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46735 }
46736 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46737 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46738 }
46739 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46740 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46741 }
46742 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46743 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46744 }
46745 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46746 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46747 }
46748 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46749 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46750 }
46751 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46752 return (void *)((wxEvent *) ((wxPyEvent *) x));
46753 }
46754 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46755 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46756 }
46757 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46758 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46759 }
46760 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46761 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46762 }
46763 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46764 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46765 }
46766 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46767 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46768 }
46769 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46770 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46771 }
46772 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46773 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46774 }
46775 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46776 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46777 }
46778 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46779 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46780 }
46781 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46782 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46783 }
46784 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46785 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46786 }
46787 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46788 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46789 }
46790 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46791 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46792 }
46793 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46794 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46795 }
46796 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46797 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46798 }
46799 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46800 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46801 }
46802 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46803 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46804 }
46805 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46806 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46807 }
46808 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46809 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46810 }
46811 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46812 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46813 }
46814 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46815 return (void *)((wxEvent *) ((wxShowEvent *) x));
46816 }
46817 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46818 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46819 }
46820 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46821 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46822 }
46823 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46824 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46825 }
46826 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46827 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46828 }
46829 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46830 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46831 }
46832 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46833 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46834 }
46835 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46836 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46837 }
46838 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46839 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46840 }
46841 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46842 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46843 }
46844 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46845 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46846 }
46847 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46848 return (void *)((wxControl *) ((wxControlWithItems *) x));
46849 }
46850 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46851 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46852 }
46853 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46854 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46855 }
46856 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46857 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46858 }
46859 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46860 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46861 }
46862 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46863 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46864 }
46865 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46866 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46867 }
46868 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46869 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46870 }
46871 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46872 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46873 }
46874 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46875 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46876 }
46877 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46878 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46879 }
46880 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46881 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46882 }
46883 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46884 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46885 }
46886 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46887 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46888 }
46889 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46890 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46891 }
46892 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46893 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46894 }
46895 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46896 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46897 }
46898 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46899 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46900 }
46901 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46902 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46903 }
46904 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46905 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46906 }
46907 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46908 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46909 }
46910 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46911 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46912 }
46913 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46914 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46915 }
46916 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46917 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46918 }
46919 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46920 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46921 }
46922 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46923 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46924 }
46925 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46926 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46927 }
46928 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46929 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46930 }
46931 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46932 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46933 }
46934 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46935 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46936 }
46937 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46938 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46939 }
46940 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46941 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46942 }
46943 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46944 return (void *)((wxObject *) ((wxSizerItem *) x));
46945 }
46946 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46947 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46948 }
46949 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46950 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46951 }
46952 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46953 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46954 }
46955 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46956 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46957 }
46958 static void *_p_wxSizerTo_p_wxObject(void *x) {
46959 return (void *)((wxObject *) ((wxSizer *) x));
46960 }
46961 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46962 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46963 }
46964 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46965 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46966 }
46967 static void *_p_wxEventTo_p_wxObject(void *x) {
46968 return (void *)((wxObject *) ((wxEvent *) x));
46969 }
46970 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46971 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46972 }
46973 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46974 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46975 }
46976 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46977 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46978 }
46979 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46980 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46981 }
46982 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46983 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46984 }
46985 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46986 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46987 }
46988 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46989 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46990 }
46991 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46992 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46993 }
46994 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46995 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46996 }
46997 static void *_p_wxControlTo_p_wxObject(void *x) {
46998 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46999 }
47000 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47001 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47002 }
47003 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47004 return (void *)((wxObject *) ((wxFSFile *) x));
47005 }
47006 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47007 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47008 }
47009 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47010 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47011 }
47012 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47013 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47014 }
47015 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47016 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47017 }
47018 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47019 return (void *)((wxObject *) ((wxMenuItem *) x));
47020 }
47021 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47022 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47023 }
47024 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47025 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47026 }
47027 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47028 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47029 }
47030 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47031 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47032 }
47033 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47034 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47035 }
47036 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47037 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47038 }
47039 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47040 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47041 }
47042 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47043 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47044 }
47045 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47046 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47047 }
47048 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47049 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47050 }
47051 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47052 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47053 }
47054 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47055 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47056 }
47057 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47058 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47059 }
47060 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47061 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47062 }
47063 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47064 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47065 }
47066 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47067 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47068 }
47069 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47070 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47071 }
47072 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47073 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47074 }
47075 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47076 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47077 }
47078 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47079 return (void *)((wxObject *) ((wxImageHandler *) x));
47080 }
47081 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47082 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47083 }
47084 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47085 return (void *)((wxObject *) ((wxEvtHandler *) x));
47086 }
47087 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47088 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47089 }
47090 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47091 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47092 }
47093 static void *_p_wxImageTo_p_wxObject(void *x) {
47094 return (void *)((wxObject *) ((wxImage *) x));
47095 }
47096 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47097 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47098 }
47099 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47100 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47101 }
47102 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47103 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47104 }
47105 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47106 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47107 }
47108 static void *_p_wxWindowTo_p_wxObject(void *x) {
47109 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47110 }
47111 static void *_p_wxMenuTo_p_wxObject(void *x) {
47112 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47113 }
47114 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47115 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47116 }
47117 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47118 return (void *)((wxObject *) ((wxFileSystem *) x));
47119 }
47120 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47121 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47122 }
47123 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47124 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47125 }
47126 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47127 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47128 }
47129 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47130 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47131 }
47132 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47133 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47134 }
47135 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47136 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47137 }
47138 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47139 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47140 }
47141 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47142 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47143 }
47144 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47145 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47146 }
47147 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47148 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47149 }
47150 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47151 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47152 }
47153 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47154 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47155 }
47156 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47157 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47158 }
47159 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47160 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47161 }
47162 static void *_p_wxControlTo_p_wxWindow(void *x) {
47163 return (void *)((wxWindow *) ((wxControl *) x));
47164 }
47165 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47166 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47167 }
47168 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47169 return (void *)((wxWindow *) ((wxMenuBar *) x));
47170 }
47171 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47172 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47173 }
47174 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47175 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47176 }
47177 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47178 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47179 }
47180 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47181 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47182 }
47183 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47184 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47185 }
47186 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47187 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47188 }
47189 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47190 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47191 }
47192 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47193 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47194 }
47195 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47196 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47197 }
47198 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47199 return (void *)((wxValidator *) ((wxPyValidator *) x));
47200 }
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236 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}};
47237 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}};
47238 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}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245 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}};
47246 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}};
47247 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}};
47248 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}};
47249 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}};
47250 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}};
47251 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}};
47252 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}};
47253 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}};
47254 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}};
47255 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}};
47256 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}};
47257 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}};
47258 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}};
47259 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}};
47260 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}};
47261 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}};
47262 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}};
47263 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}};
47264 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}};
47265 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}};
47266 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}};
47267 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}};
47268 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}};
47269 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}};
47270 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}};
47271 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}};
47272 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}};
47273 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}};
47274 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}};
47275 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}};
47276 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}};
47277 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}};
47278 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}};
47279 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}};
47280 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}};
47281 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}};
47282 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}};
47283 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}};
47284 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}};
47285 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}};
47286 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}};
47287 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}};
47288 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}};
47289 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}};
47290 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}};
47291 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}};
47292 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}};
47293 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}};
47294 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}};
47295 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}};
47296 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}};
47297 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}};
47298 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}};
47299 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}};
47300 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}};
47301 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}};
47302 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}};
47303 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}};
47304 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}};
47305 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}};
47306 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}};
47307 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}};
47308 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}};
47309 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}};
47310 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}};
47311 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}};
47312 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}};
47313 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47314 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}};
47315 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}};
47316 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}};
47317 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}};
47318 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}};
47319 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}};
47320 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}};
47321 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}};
47322 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}};
47323 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}};
47324 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}};
47325 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}};
47326 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}};
47327 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}};
47328 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}};
47329
47330 static swig_type_info *swig_types_initial[] = {
47331 _swigt__p_wxLayoutConstraints,
47332 _swigt__p_wxRealPoint,
47333 _swigt__p_wxSizerItem,
47334 _swigt__p_wxGBSizerItem,
47335 _swigt__p_wxScrollEvent,
47336 _swigt__p_wxEventLoop,
47337 _swigt__p_wxIndividualLayoutConstraint,
47338 _swigt__p_wxSizer,
47339 _swigt__p_wxBoxSizer,
47340 _swigt__p_wxStaticBoxSizer,
47341 _swigt__p_wxGridBagSizer,
47342 _swigt__p_wxAcceleratorEntry,
47343 _swigt__p_wxUpdateUIEvent,
47344 _swigt__p_wxEvent,
47345 _swigt__p_buffer,
47346 _swigt__p_wxMenu,
47347 _swigt__p_wxGridSizer,
47348 _swigt__p_wxFlexGridSizer,
47349 _swigt__p_wxInitDialogEvent,
47350 _swigt__p_wxItemContainer,
47351 _swigt__p_wxNcPaintEvent,
47352 _swigt__p_wxPaintEvent,
47353 _swigt__p_wxSysColourChangedEvent,
47354 _swigt__p_wxMouseCaptureChangedEvent,
47355 _swigt__p_wxDisplayChangedEvent,
47356 _swigt__p_wxPaletteChangedEvent,
47357 _swigt__p_wxControl,
47358 _swigt__p_wxFont,
47359 _swigt__p_wxMenuBarBase,
47360 _swigt__p_wxSetCursorEvent,
47361 _swigt__p_wxFSFile,
47362 _swigt__p_wxCaret,
47363 _swigt__ptrdiff_t,
47364 _swigt__std__ptrdiff_t,
47365 _swigt__p_wxRegion,
47366 _swigt__p_wxPoint2D,
47367 _swigt__p_int,
47368 _swigt__p_wxSize,
47369 _swigt__p_wxDC,
47370 _swigt__p_wxPySizer,
47371 _swigt__p_wxVisualAttributes,
47372 _swigt__p_wxNotifyEvent,
47373 _swigt__p_wxPyEvent,
47374 _swigt__p_wxPropagationDisabler,
47375 _swigt__p_form_ops_t,
47376 _swigt__p_wxAppTraits,
47377 _swigt__p_wxArrayString,
47378 _swigt__p_wxShowEvent,
47379 _swigt__p_wxToolTip,
47380 _swigt__p_wxMoveEvent,
47381 _swigt__p_wxSizeEvent,
47382 _swigt__p_wxActivateEvent,
47383 _swigt__p_wxIconizeEvent,
47384 _swigt__p_wxMaximizeEvent,
47385 _swigt__p_wxQueryNewPaletteEvent,
47386 _swigt__p_wxWindowCreateEvent,
47387 _swigt__p_wxIdleEvent,
47388 _swigt__p_wxDateEvent,
47389 _swigt__p_wxMenuItem,
47390 _swigt__p_wxStaticBox,
47391 _swigt__p_long,
47392 _swigt__p_wxDuplexMode,
47393 _swigt__p_wxTIFFHandler,
47394 _swigt__p_wxXPMHandler,
47395 _swigt__p_wxPNMHandler,
47396 _swigt__p_wxJPEGHandler,
47397 _swigt__p_wxPCXHandler,
47398 _swigt__p_wxGIFHandler,
47399 _swigt__p_wxPNGHandler,
47400 _swigt__p_wxANIHandler,
47401 _swigt__p_wxMemoryFSHandler,
47402 _swigt__p_wxZipFSHandler,
47403 _swigt__p_wxInternetFSHandler,
47404 _swigt__p_wxPyFileSystemHandler,
47405 _swigt__p_wxEvtHandler,
47406 _swigt__p_wxCURHandler,
47407 _swigt__p_wxICOHandler,
47408 _swigt__p_wxBMPHandler,
47409 _swigt__p_wxImageHandler,
47410 _swigt__p_wxFileSystemHandler,
47411 _swigt__p_wxRect,
47412 _swigt__p_wxButton,
47413 _swigt__p_wxGBSpan,
47414 _swigt__p_wxPropagateOnce,
47415 _swigt__p_wxAcceleratorTable,
47416 _swigt__p_wxStdDialogButtonSizer,
47417 _swigt__p_char,
47418 _swigt__p_wxGBPosition,
47419 _swigt__p_wxImage,
47420 _swigt__p_wxFrame,
47421 _swigt__p_wxScrollWinEvent,
47422 _swigt__p_wxPaperSize,
47423 _swigt__p_wxImageHistogram,
47424 _swigt__p_wxPoint,
47425 _swigt__p_wxCursor,
47426 _swigt__p_wxObject,
47427 _swigt__p_wxInputStream,
47428 _swigt__p_wxOutputStream,
47429 _swigt__p_wxPyInputStream,
47430 _swigt__p_wxDateTime,
47431 _swigt__p_wxKeyEvent,
47432 _swigt__p_wxNavigationKeyEvent,
47433 _swigt__p_wxWindowDestroyEvent,
47434 _swigt__p_unsigned_long,
47435 _swigt__p_wxWindow,
47436 _swigt__p_wxMenuBar,
47437 _swigt__p_wxFileSystem,
47438 _swigt__p_wxBitmap,
47439 _swigt__unsigned_int,
47440 _swigt__p_unsigned_int,
47441 _swigt__p_wxMenuEvent,
47442 _swigt__p_wxContextMenuEvent,
47443 _swigt__p_unsigned_char,
47444 _swigt__p_wxEraseEvent,
47445 _swigt__p_wxMouseEvent,
47446 _swigt__p_wxCloseEvent,
47447 _swigt__p_wxPyApp,
47448 _swigt__p_wxCommandEvent,
47449 _swigt__p_wxPyCommandEvent,
47450 _swigt__p_wxPyDropTarget,
47451 _swigt__p_wxQuantize,
47452 _swigt__p_wxFocusEvent,
47453 _swigt__p_wxChildFocusEvent,
47454 _swigt__p_wxDropFilesEvent,
47455 _swigt__p_wxControlWithItems,
47456 _swigt__p_wxColour,
47457 _swigt__p_wxValidator,
47458 _swigt__p_wxPyValidator,
47459 0
47460 };
47461
47462
47463 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47464
47465 static swig_const_info swig_const_table[] = {
47466 {0, 0, 0, 0.0, 0, 0}};
47467
47468 #ifdef __cplusplus
47469 }
47470 #endif
47471
47472
47473 #ifdef __cplusplus
47474 extern "C" {
47475 #endif
47476
47477 /* Python-specific SWIG API */
47478 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47479 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47480 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47481
47482 /* -----------------------------------------------------------------------------
47483 * global variable support code.
47484 * ----------------------------------------------------------------------------- */
47485
47486 typedef struct swig_globalvar {
47487 char *name; /* Name of global variable */
47488 PyObject *(*get_attr)(); /* Return the current value */
47489 int (*set_attr)(PyObject *); /* Set the value */
47490 struct swig_globalvar *next;
47491 } swig_globalvar;
47492
47493 typedef struct swig_varlinkobject {
47494 PyObject_HEAD
47495 swig_globalvar *vars;
47496 } swig_varlinkobject;
47497
47498 static PyObject *
47499 swig_varlink_repr(swig_varlinkobject *v) {
47500 v = v;
47501 return PyString_FromString("<Swig global variables>");
47502 }
47503
47504 static int
47505 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47506 swig_globalvar *var;
47507 flags = flags;
47508 fprintf(fp,"Swig global variables { ");
47509 for (var = v->vars; var; var=var->next) {
47510 fprintf(fp,"%s", var->name);
47511 if (var->next) fprintf(fp,", ");
47512 }
47513 fprintf(fp," }\n");
47514 return 0;
47515 }
47516
47517 static PyObject *
47518 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47519 swig_globalvar *var = v->vars;
47520 while (var) {
47521 if (strcmp(var->name,n) == 0) {
47522 return (*var->get_attr)();
47523 }
47524 var = var->next;
47525 }
47526 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47527 return NULL;
47528 }
47529
47530 static int
47531 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47532 swig_globalvar *var = v->vars;
47533 while (var) {
47534 if (strcmp(var->name,n) == 0) {
47535 return (*var->set_attr)(p);
47536 }
47537 var = var->next;
47538 }
47539 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47540 return 1;
47541 }
47542
47543 static PyTypeObject varlinktype = {
47544 PyObject_HEAD_INIT(0)
47545 0, /* Number of items in variable part (ob_size) */
47546 (char *)"swigvarlink", /* Type name (tp_name) */
47547 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47548 0, /* Itemsize (tp_itemsize) */
47549 0, /* Deallocator (tp_dealloc) */
47550 (printfunc) swig_varlink_print, /* Print (tp_print) */
47551 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47552 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47553 0, /* tp_compare */
47554 (reprfunc) swig_varlink_repr, /* tp_repr */
47555 0, /* tp_as_number */
47556 0, /* tp_as_sequence */
47557 0, /* tp_as_mapping */
47558 0, /* tp_hash */
47559 0, /* tp_call */
47560 0, /* tp_str */
47561 0, /* tp_getattro */
47562 0, /* tp_setattro */
47563 0, /* tp_as_buffer */
47564 0, /* tp_flags */
47565 0, /* tp_doc */
47566 #if PY_VERSION_HEX >= 0x02000000
47567 0, /* tp_traverse */
47568 0, /* tp_clear */
47569 #endif
47570 #if PY_VERSION_HEX >= 0x02010000
47571 0, /* tp_richcompare */
47572 0, /* tp_weaklistoffset */
47573 #endif
47574 #if PY_VERSION_HEX >= 0x02020000
47575 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47576 #endif
47577 #if PY_VERSION_HEX >= 0x02030000
47578 0, /* tp_del */
47579 #endif
47580 #ifdef COUNT_ALLOCS
47581 0,0,0,0 /* tp_alloc -> tp_next */
47582 #endif
47583 };
47584
47585 /* Create a variable linking object for use later */
47586 static PyObject *
47587 SWIG_Python_newvarlink(void) {
47588 swig_varlinkobject *result = 0;
47589 result = PyMem_NEW(swig_varlinkobject,1);
47590 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47591 result->ob_type = &varlinktype;
47592 result->vars = 0;
47593 result->ob_refcnt = 0;
47594 Py_XINCREF((PyObject *) result);
47595 return ((PyObject*) result);
47596 }
47597
47598 static void
47599 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47600 swig_varlinkobject *v;
47601 swig_globalvar *gv;
47602 v= (swig_varlinkobject *) p;
47603 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47604 gv->name = (char *) malloc(strlen(name)+1);
47605 strcpy(gv->name,name);
47606 gv->get_attr = get_attr;
47607 gv->set_attr = set_attr;
47608 gv->next = v->vars;
47609 v->vars = gv;
47610 }
47611
47612 /* -----------------------------------------------------------------------------
47613 * constants/methods manipulation
47614 * ----------------------------------------------------------------------------- */
47615
47616 /* Install Constants */
47617 static void
47618 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47619 PyObject *obj = 0;
47620 size_t i;
47621 for (i = 0; constants[i].type; i++) {
47622 switch(constants[i].type) {
47623 case SWIG_PY_INT:
47624 obj = PyInt_FromLong(constants[i].lvalue);
47625 break;
47626 case SWIG_PY_FLOAT:
47627 obj = PyFloat_FromDouble(constants[i].dvalue);
47628 break;
47629 case SWIG_PY_STRING:
47630 if (constants[i].pvalue) {
47631 obj = PyString_FromString((char *) constants[i].pvalue);
47632 } else {
47633 Py_INCREF(Py_None);
47634 obj = Py_None;
47635 }
47636 break;
47637 case SWIG_PY_POINTER:
47638 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47639 break;
47640 case SWIG_PY_BINARY:
47641 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47642 break;
47643 default:
47644 obj = 0;
47645 break;
47646 }
47647 if (obj) {
47648 PyDict_SetItemString(d,constants[i].name,obj);
47649 Py_DECREF(obj);
47650 }
47651 }
47652 }
47653
47654 /* -----------------------------------------------------------------------------*/
47655 /* Fix SwigMethods to carry the callback ptrs when needed */
47656 /* -----------------------------------------------------------------------------*/
47657
47658 static void
47659 SWIG_Python_FixMethods(PyMethodDef *methods,
47660 swig_const_info *const_table,
47661 swig_type_info **types,
47662 swig_type_info **types_initial) {
47663 size_t i;
47664 for (i = 0; methods[i].ml_name; ++i) {
47665 char *c = methods[i].ml_doc;
47666 if (c && (c = strstr(c, "swig_ptr: "))) {
47667 int j;
47668 swig_const_info *ci = 0;
47669 char *name = c + 10;
47670 for (j = 0; const_table[j].type; j++) {
47671 if (strncmp(const_table[j].name, name,
47672 strlen(const_table[j].name)) == 0) {
47673 ci = &(const_table[j]);
47674 break;
47675 }
47676 }
47677 if (ci) {
47678 size_t shift = (ci->ptype) - types;
47679 swig_type_info *ty = types_initial[shift];
47680 size_t ldoc = (c - methods[i].ml_doc);
47681 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47682 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47683 char *buff = ndoc;
47684 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47685 strncpy(buff, methods[i].ml_doc, ldoc);
47686 buff += ldoc;
47687 strncpy(buff, "swig_ptr: ", 10);
47688 buff += 10;
47689 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47690 methods[i].ml_doc = ndoc;
47691 }
47692 }
47693 }
47694 }
47695
47696 /* -----------------------------------------------------------------------------*
47697 * Initialize type list
47698 * -----------------------------------------------------------------------------*/
47699
47700 #if PY_MAJOR_VERSION < 2
47701 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47702 is copied out of Python/modsupport.c in python version 2.3.4 */
47703 static int
47704 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47705 {
47706 PyObject *dict;
47707 if (!PyModule_Check(m)) {
47708 PyErr_SetString(PyExc_TypeError,
47709 "PyModule_AddObject() needs module as first arg");
47710 return -1;
47711 }
47712 if (!o) {
47713 PyErr_SetString(PyExc_TypeError,
47714 "PyModule_AddObject() needs non-NULL value");
47715 return -1;
47716 }
47717
47718 dict = PyModule_GetDict(m);
47719 if (dict == NULL) {
47720 /* Internal error -- modules must have a dict! */
47721 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47722 PyModule_GetName(m));
47723 return -1;
47724 }
47725 if (PyDict_SetItemString(dict, name, o))
47726 return -1;
47727 Py_DECREF(o);
47728 return 0;
47729 }
47730 #endif
47731
47732 static swig_type_info **
47733 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47734 static PyMethodDef swig_empty_runtime_method_table[] = {
47735 {
47736 NULL, NULL, 0, NULL
47737 }
47738 };/* Sentinel */
47739
47740 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47741 swig_empty_runtime_method_table);
47742 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47743 if (pointer && module) {
47744 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47745 }
47746 return type_list_handle;
47747 }
47748
47749 static swig_type_info **
47750 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47751 swig_type_info **type_pointer;
47752
47753 /* first check if module already created */
47754 type_pointer = SWIG_Python_GetTypeListHandle();
47755 if (type_pointer) {
47756 return type_pointer;
47757 } else {
47758 /* create a new module and variable */
47759 return SWIG_Python_SetTypeListHandle(type_list_handle);
47760 }
47761 }
47762
47763 #ifdef __cplusplus
47764 }
47765 #endif
47766
47767 /* -----------------------------------------------------------------------------*
47768 * Partial Init method
47769 * -----------------------------------------------------------------------------*/
47770
47771 #ifdef SWIG_LINK_RUNTIME
47772 #ifdef __cplusplus
47773 extern "C"
47774 #endif
47775 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47776 #endif
47777
47778 #ifdef __cplusplus
47779 extern "C"
47780 #endif
47781 SWIGEXPORT(void) SWIG_init(void) {
47782 static PyObject *SWIG_globals = 0;
47783 static int typeinit = 0;
47784 PyObject *m, *d;
47785 int i;
47786 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47787
47788 /* Fix SwigMethods to carry the callback ptrs when needed */
47789 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47790
47791 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47792 d = PyModule_GetDict(m);
47793
47794 if (!typeinit) {
47795 #ifdef SWIG_LINK_RUNTIME
47796 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47797 #else
47798 # ifndef SWIG_STATIC_RUNTIME
47799 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47800 # endif
47801 #endif
47802 for (i = 0; swig_types_initial[i]; i++) {
47803 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47804 }
47805 typeinit = 1;
47806 }
47807 SWIG_InstallConstants(d,swig_const_table);
47808
47809
47810 #ifndef wxPyUSE_EXPORT
47811 // Make our API structure a CObject so other modules can import it
47812 // from this module.
47813 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47814 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47815 Py_XDECREF(cobj);
47816 #endif
47817
47818 {
47819 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49482 }
49483 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49484 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49485 {
49486 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49553 }
49554 {
49555 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49556 }
49557 {
49558 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49565 }
49566 {
49567 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49568 }
49569 {
49570 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49571 }
49572 {
49573 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49574 }
49575 {
49576 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49577 }
49578 {
49579 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49580 }
49581 {
49582 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49583 }
49584 {
49585 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49586 }
49587 {
49588 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49631 }
49632 {
49633 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49634 }
49635 {
49636 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49637 }
49638 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49639 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49640 {
49641 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49648 }
49649
49650 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49651
49652
49653 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49654
49655 {
49656 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49663 }
49664 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49665 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49666 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49667 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49668 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49669 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49670 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49671 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49672 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49673 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49674 {
49675 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49676 }
49677 {
49678 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49679 }
49680 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49681 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49682 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49683 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49684 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49685 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49686 {
49687 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49688 }
49689 {
49690 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49691 }
49692 {
49693 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49694 }
49695 {
49696 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49697 }
49698 {
49699 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49700 }
49701 {
49702 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49703 }
49704 {
49705 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49706 }
49707 {
49708 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49709 }
49710 {
49711 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49712 }
49713 {
49714 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49715 }
49716 {
49717 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49718 }
49719 {
49720 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49721 }
49722 {
49723 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49724 }
49725 {
49726 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49727 }
49728 {
49729 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49730 }
49731 {
49732 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49733 }
49734 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49735 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49736 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49737 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49738 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49739 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49740 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49741 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49742 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49743 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49744 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49745 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49746 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49747 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49748 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49749 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49750 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49751 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49752 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49753 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49754 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49755 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49756 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49757 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49758 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49759 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49760 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49761 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49762 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49763 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49764 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49765 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49766 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49767 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49768 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49769 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49770 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49771 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49772 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49773 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49774 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49775 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49776 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49777 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49778 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49779 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49780 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49781 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49782 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49783 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49784 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49785 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49786 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49787 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49788 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49789 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49790 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49791 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49792 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49793 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49794 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49795 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49796 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49797 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49798 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49799 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49800 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49801 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49802 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49803 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49804 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49805 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49806 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49807 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49808 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49809 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49810 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49811 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49812 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49813 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49814 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49815 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49816 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49817 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49818 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49819 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49820 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49821 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49822 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49823 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49824 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49825 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49826 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49827 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49828 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49829 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49830 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49831 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49832 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49833 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49834 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49835 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49836 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49837 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49838 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49839 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49840 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49841 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49842 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49843 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49844 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49845 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49846 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49847 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49848 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49849 {
49850 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49887 }
49888 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49889 {
49890 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49891 }
49892 {
49893 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49894 }
49895 {
49896 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49897 }
49898 {
49899 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49900 }
49901 {
49902 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49903 }
49904 {
49905 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49906 }
49907 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49908 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49909 {
49910 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49911 }
49912 {
49913 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49914 }
49915 {
49916 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49917 }
49918 {
49919 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49920 }
49921 {
49922 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49923 }
49924 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49925 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49926 {
49927 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49928 }
49929 {
49930 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49931 }
49932 {
49933 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49934 }
49935 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49936 {
49937 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49938 }
49939 {
49940 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49941 }
49942 {
49943 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49944 }
49945 {
49946 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49947 }
49948 {
49949 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49950 }
49951 {
49952 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49953 }
49954 {
49955 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49956 }
49957 {
49958 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49959 }
49960 {
49961 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49962 }
49963 {
49964 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49965 }
49966 {
49967 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49968 }
49969 {
49970 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49971 }
49972 {
49973 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49974 }
49975 {
49976 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49977 }
49978 {
49979 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49980 }
49981 {
49982 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49983 }
49984 {
49985 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49986 }
49987 {
49988 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49989 }
49990 {
49991 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49992 }
49993
49994 // Initialize threading, some globals and such
49995 __wxPyPreStart(d);
49996
49997
49998 // Although these are defined in __version__ they need to be here too so
49999 // that an assert can be done to ensure that the wxPython and the wxWindows
50000 // versions match.
50001 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
50002 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
50003 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
50004
50005 }
50006
wxWidgets (Impactor)