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


d312b16ddf1cbf4780daa29f6227d7e92c02ee66
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2475 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2476 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2477 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2478 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2479 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2480 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2481
2482 #include <wx/quantize.h>
2483
2484 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2485 return wxQuantize::Quantize(src, dest,
2486 //NULL, // palette
2487 desiredNoColours,
2488 NULL, // eightBitData
2489 flags);
2490 }
2491 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2492 if (PyCallable_Check(func)) {
2493 self->Connect(id, lastId, eventType,
2494 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2495 new wxPyCallback(func));
2496 }
2497 else if (func == Py_None) {
2498 self->Disconnect(id, lastId, eventType,
2499 (wxObjectEventFunction)
2500 &wxPyCallback::EventThunker);
2501 }
2502 else {
2503 wxPyBLOCK_THREADS(
2504 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2505 }
2506 }
2507 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2508 return self->Disconnect(id, lastId, eventType,
2509 (wxObjectEventFunction)
2510 &wxPyCallback::EventThunker);
2511 }
2512 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2513 if (_self && _self != Py_None) {
2514 self->SetClientObject(new wxPyOORClientData(_self, incref));
2515 }
2516 else {
2517 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2518 if (data) {
2519 self->SetClientObject(NULL); // This will delete it too
2520 }
2521 }
2522 }
2523
2524 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2525 #if wxUSE_UNICODE
2526 return self->GetUnicodeKey();
2527 #else
2528 return 0;
2529 #endif
2530 }
2531
2532 #if UINT_MAX < LONG_MAX
2533 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2534 #define SWIG_From_unsigned_SS_int SWIG_From_long
2535 /*@@*/
2536 #else
2537 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2538 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2539 /*@@*/
2540 #endif
2541
2542
2543 #if UINT_MAX != ULONG_MAX
2544 SWIGINTERN int
2545 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2546 {
2547 const char* errmsg = val ? "unsigned int" : (char*)0;
2548 unsigned long v;
2549 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2550 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2551 if (val) *val = (unsigned int)(v);
2552 return 1;
2553 }
2554 } else {
2555 PyErr_Clear();
2556 }
2557 if (val) {
2558 SWIG_type_error(errmsg, obj);
2559 }
2560 return 0;
2561 }
2562 #else
2563 SWIGINTERNSHORT unsigned int
2564 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2565 {
2566 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2567 }
2568 #endif
2569
2570
2571 SWIGINTERNSHORT unsigned int
2572 SWIG_As_unsigned_SS_int(PyObject* obj)
2573 {
2574 unsigned int v;
2575 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2576 /*
2577 this is needed to make valgrind/purify happier.
2578 */
2579 memset((void*)&v, 0, sizeof(unsigned int));
2580 }
2581 return v;
2582 }
2583
2584
2585 SWIGINTERNSHORT int
2586 SWIG_Check_unsigned_SS_int(PyObject* obj)
2587 {
2588 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2589 }
2590
2591 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2592 self->m_size = size;
2593 }
2594 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2595 int count = self->GetNumberOfFiles();
2596 wxString* files = self->GetFiles();
2597 PyObject* list = PyList_New(count);
2598
2599 if (!list) {
2600 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2601 return NULL;
2602 }
2603
2604 for (int i=0; i<count; i++) {
2605 PyList_SetItem(list, i, wx2PyString(files[i]));
2606 }
2607 return list;
2608 }
2609
2610
2611 static wxPyApp *new_wxPyApp(){
2612 wxPythonApp = new wxPyApp();
2613 return wxPythonApp;
2614 }
2615
2616 void wxApp_CleanUp() {
2617 __wxPyCleanup();
2618 }
2619
2620
2621 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2622
2623
2624 SWIGINTERNSHORT int
2625 SWIG_AsCharPtr(PyObject *obj, char **val)
2626 {
2627 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2628 return 1;
2629 }
2630 if (val) {
2631 PyErr_Clear();
2632 SWIG_type_error("char *", obj);
2633 }
2634 return 0;
2635 }
2636
2637
2638 SWIGINTERN PyObject *
2639 SWIG_FromCharPtr(const char* cptr)
2640 {
2641 if (cptr) {
2642 size_t size = strlen(cptr);
2643 if (size > INT_MAX) {
2644 return SWIG_NewPointerObj((char*)(cptr),
2645 SWIG_TypeQuery("char *"), 0);
2646 } else {
2647 if (size != 0) {
2648 return PyString_FromStringAndSize(cptr, size);
2649 } else {
2650 return PyString_FromString(cptr);
2651 }
2652 }
2653 }
2654 Py_INCREF(Py_None);
2655 return Py_None;
2656 }
2657
2658
2659 #ifdef __WXMAC__
2660
2661 // A dummy class that raises an exception if used...
2662 class wxEventLoop
2663 {
2664 public:
2665 wxEventLoop() { wxPyRaiseNotImplemented(); }
2666 int Run() { return 0; }
2667 void Exit(int rc = 0) {}
2668 bool Pending() const { return false; }
2669 bool Dispatch() { return false; }
2670 bool IsRunning() const { return false; }
2671 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2672 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2673 };
2674
2675 #else
2676
2677 #include <wx/evtloop.h>
2678
2679 #endif
2680
2681
2682
2683 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2684 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2685 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2686 static PyObject *wxWindow_GetChildren(wxWindow *self){
2687 wxWindowList& list = self->GetChildren();
2688 return wxPy_ConvertList(&list);
2689 }
2690 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2691 #if wxUSE_HOTKEY
2692 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2693 #else
2694 return false;
2695 #endif
2696 }
2697 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2698
2699
2700
2701 return false;
2702
2703 }
2704 static long wxWindow_GetHandle(wxWindow *self){
2705 return wxPyGetWinHandle(self);
2706 }
2707 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2708 self->AssociateHandle((WXWidget)handle);
2709 }
2710
2711 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2712 return wxWindow::FindWindowById(id, parent);
2713 }
2714
2715 wxWindow* wxFindWindowByName( const wxString& name,
2716 const wxWindow *parent = NULL ) {
2717 return wxWindow::FindWindowByName(name, parent);
2718 }
2719
2720 wxWindow* wxFindWindowByLabel( const wxString& label,
2721 const wxWindow *parent = NULL ) {
2722 return wxWindow::FindWindowByLabel(label, parent);
2723 }
2724
2725
2726 #ifdef __WXMSW__
2727 #include <wx/msw/private.h> // to get wxGetWindowId
2728 #endif
2729
2730
2731 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2732 #ifdef __WXMSW__
2733 WXHWND hWnd = (WXHWND)_hWnd;
2734 long id = wxGetWindowId(hWnd);
2735 wxWindow* win = new wxWindow;
2736 parent->AddChild(win);
2737 win->SetEventHandler(win);
2738 win->SetHWND(hWnd);
2739 win->SetId(id);
2740 win->SubclassWin(hWnd);
2741 win->AdoptAttributesFromHWND();
2742 win->SetupColours();
2743 return win;
2744 #else
2745 wxPyRaiseNotImplemented();
2746 return NULL;
2747 #endif
2748 }
2749
2750
2751 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2752 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2753 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2754
2755 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2756
2757 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2758 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2759 wxMenuItemList& list = self->GetMenuItems();
2760 return wxPy_ConvertList(&list);
2761 }
2762 static const wxString wxPyControlNameStr(wxControlNameStr);
2763 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2764 if (clientData) {
2765 wxPyClientData* data = new wxPyClientData(clientData);
2766 return self->Append(item, data);
2767 } else
2768 return self->Append(item);
2769 }
2770 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2771 if (clientData) {
2772 wxPyClientData* data = new wxPyClientData(clientData);
2773 return self->Insert(item, pos, data);
2774 } else
2775 return self->Insert(item, pos);
2776 }
2777 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2778 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2779 if (data) {
2780 Py_INCREF(data->m_obj);
2781 return data->m_obj;
2782 } else {
2783 Py_INCREF(Py_None);
2784 return Py_None;
2785 }
2786 }
2787 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2788 wxPyClientData* data = new wxPyClientData(clientData);
2789 self->SetClientObject(n, data);
2790 }
2791
2792
2793 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2794 wxPyUserData* data = NULL;
2795 if ( userData ) {
2796 bool blocked = wxPyBeginBlockThreads();
2797 data = new wxPyUserData(userData);
2798 wxPyEndBlockThreads(blocked);
2799 }
2800 return new wxSizerItem(window, proportion, flag, border, data);
2801 }
2802 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2803 wxPyUserData* data = NULL;
2804 if ( userData ) {
2805 bool blocked = wxPyBeginBlockThreads();
2806 data = new wxPyUserData(userData);
2807 wxPyEndBlockThreads(blocked);
2808 }
2809 return new wxSizerItem(width, height, proportion, flag, border, data);
2810 }
2811 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2812 wxPyUserData* data = NULL;
2813 if ( userData ) {
2814 bool blocked = wxPyBeginBlockThreads();
2815 data = new wxPyUserData(userData);
2816 wxPyEndBlockThreads(blocked);
2817 }
2818 return new wxSizerItem(sizer, proportion, flag, border, data);
2819 }
2820
2821 #include <float.h>
2822 SWIGINTERN int
2823 SWIG_CheckDoubleInRange(double value, double min_value,
2824 double max_value, const char* errmsg)
2825 {
2826 if (value < min_value) {
2827 if (errmsg) {
2828 PyErr_Format(PyExc_OverflowError,
2829 "value %g is less than %s minimum %g",
2830 value, errmsg, min_value);
2831 }
2832 return 0;
2833 } else if (value > max_value) {
2834 if (errmsg) {
2835 PyErr_Format(PyExc_OverflowError,
2836 "value %g is greater than %s maximum %g",
2837 value, errmsg, max_value);
2838 }
2839 return 0;
2840 }
2841 return 1;
2842 }
2843
2844
2845 SWIGINTERN int
2846 SWIG_AsVal_float(PyObject *obj, float *val)
2847 {
2848 const char* errmsg = val ? "float" : (char*)0;
2849 double v;
2850 if (SWIG_AsVal_double(obj, &v)) {
2851 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2852 if (val) *val = (float)(v);
2853 return 1;
2854 } else {
2855 return 0;
2856 }
2857 } else {
2858 PyErr_Clear();
2859 }
2860 if (val) {
2861 SWIG_type_error(errmsg, obj);
2862 }
2863 return 0;
2864 }
2865
2866
2867 SWIGINTERNSHORT float
2868 SWIG_As_float(PyObject* obj)
2869 {
2870 float v;
2871 if (!SWIG_AsVal_float(obj, &v)) {
2872 /*
2873 this is needed to make valgrind/purify happier.
2874 */
2875 memset((void*)&v, 0, sizeof(float));
2876 }
2877 return v;
2878 }
2879
2880
2881 SWIGINTERNSHORT int
2882 SWIG_Check_float(PyObject* obj)
2883 {
2884 return SWIG_AsVal_float(obj, (float*)0);
2885 }
2886
2887
2888 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2889 #define SWIG_From_float PyFloat_FromDouble
2890 /*@@*/
2891
2892 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2893 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2894 if (data) {
2895 Py_INCREF(data->m_obj);
2896 return data->m_obj;
2897 } else {
2898 Py_INCREF(Py_None);
2899 return Py_None;
2900 }
2901 }
2902
2903 // Figure out the type of the sizer item
2904
2905 struct wxPySizerItemInfo {
2906 wxPySizerItemInfo()
2907 : window(NULL), sizer(NULL), gotSize(false),
2908 size(wxDefaultSize), gotPos(false), pos(-1)
2909 {}
2910
2911 wxWindow* window;
2912 wxSizer* sizer;
2913 bool gotSize;
2914 wxSize size;
2915 bool gotPos;
2916 int pos;
2917 };
2918
2919 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2920
2921 wxPySizerItemInfo info;
2922 wxSize size;
2923 wxSize* sizePtr = &size;
2924
2925 // Find out what the type of the item is
2926 // try wxWindow
2927 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2928 PyErr_Clear();
2929 info.window = NULL;
2930
2931 // try wxSizer
2932 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2933 PyErr_Clear();
2934 info.sizer = NULL;
2935
2936 // try wxSize or (w,h)
2937 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2938 info.size = *sizePtr;
2939 info.gotSize = true;
2940 }
2941
2942 // or a single int
2943 if (checkIdx && PyInt_Check(item)) {
2944 info.pos = PyInt_AsLong(item);
2945 info.gotPos = true;
2946 }
2947 }
2948 }
2949
2950 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2951 // no expected type, figure out what kind of error message to generate
2952 if ( !checkSize && !checkIdx )
2953 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2954 else if ( checkSize && !checkIdx )
2955 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2956 else if ( !checkSize && checkIdx)
2957 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2958 else
2959 // can this one happen?
2960 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2961 }
2962
2963 return info;
2964 }
2965
2966 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2967 if (!self->GetClientObject())
2968 self->SetClientObject(new wxPyOORClientData(_self));
2969 }
2970 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2971
2972 wxPyUserData* data = NULL;
2973 bool blocked = wxPyBeginBlockThreads();
2974 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2975 if ( userData && (info.window || info.sizer || info.gotSize) )
2976 data = new wxPyUserData(userData);
2977 wxPyEndBlockThreads(blocked);
2978
2979 // Now call the real Add method if a valid item type was found
2980 if ( info.window )
2981 return self->Add(info.window, proportion, flag, border, data);
2982 else if ( info.sizer )
2983 return self->Add(info.sizer, proportion, flag, border, data);
2984 else if (info.gotSize)
2985 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2986 proportion, flag, border, data);
2987 else
2988 return NULL;
2989 }
2990 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2991
2992 wxPyUserData* data = NULL;
2993 bool blocked = wxPyBeginBlockThreads();
2994 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2995 if ( userData && (info.window || info.sizer || info.gotSize) )
2996 data = new wxPyUserData(userData);
2997 wxPyEndBlockThreads(blocked);
2998
2999 // Now call the real Insert method if a valid item type was found
3000 if ( info.window )
3001 return self->Insert(before, info.window, proportion, flag, border, data);
3002 else if ( info.sizer )
3003 return self->Insert(before, info.sizer, proportion, flag, border, data);
3004 else if (info.gotSize)
3005 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3006 proportion, flag, border, data);
3007 else
3008 return NULL;
3009 }
3010 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3011
3012 wxPyUserData* data = NULL;
3013 bool blocked = wxPyBeginBlockThreads();
3014 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3015 if ( userData && (info.window || info.sizer || info.gotSize) )
3016 data = new wxPyUserData(userData);
3017 wxPyEndBlockThreads(blocked);
3018
3019 // Now call the real Prepend method if a valid item type was found
3020 if ( info.window )
3021 return self->Prepend(info.window, proportion, flag, border, data);
3022 else if ( info.sizer )
3023 return self->Prepend(info.sizer, proportion, flag, border, data);
3024 else if (info.gotSize)
3025 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3026 proportion, flag, border, data);
3027 else
3028 return NULL;
3029 }
3030 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3031 bool blocked = wxPyBeginBlockThreads();
3032 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3033 wxPyEndBlockThreads(blocked);
3034 if ( info.window )
3035 return self->Remove(info.window);
3036 else if ( info.sizer )
3037 return self->Remove(info.sizer);
3038 else if ( info.gotPos )
3039 return self->Remove(info.pos);
3040 else
3041 return false;
3042 }
3043 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3044 bool blocked = wxPyBeginBlockThreads();
3045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3046 wxPyEndBlockThreads(blocked);
3047 if ( info.window )
3048 return self->Detach(info.window);
3049 else if ( info.sizer )
3050 return self->Detach(info.sizer);
3051 else if ( info.gotPos )
3052 return self->Detach(info.pos);
3053 else
3054 return false;
3055 }
3056 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3057 bool blocked = wxPyBeginBlockThreads();
3058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3059 wxPyEndBlockThreads(blocked);
3060 if ( info.window )
3061 return self->GetItem(info.window);
3062 else if ( info.sizer )
3063 return self->GetItem(info.sizer);
3064 else if ( info.gotPos )
3065 return self->GetItem(info.pos);
3066 else
3067 return NULL;
3068 }
3069 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3070 bool blocked = wxPyBeginBlockThreads();
3071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3072 wxPyEndBlockThreads(blocked);
3073 if ( info.window )
3074 self->SetItemMinSize(info.window, size);
3075 else if ( info.sizer )
3076 self->SetItemMinSize(info.sizer, size);
3077 else if ( info.gotPos )
3078 self->SetItemMinSize(info.pos, size);
3079 }
3080 static PyObject *wxSizer_GetChildren(wxSizer *self){
3081 wxSizerItemList& list = self->GetChildren();
3082 return wxPy_ConvertList(&list);
3083 }
3084 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3085 bool blocked = wxPyBeginBlockThreads();
3086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3087 wxPyEndBlockThreads(blocked);
3088 if ( info.window )
3089 return self->Show(info.window, show, recursive);
3090 else if ( info.sizer )
3091 return self->Show(info.sizer, show, recursive);
3092 else if ( info.gotPos )
3093 return self->Show(info.pos, show);
3094 else
3095 return false;
3096 }
3097 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3098 bool blocked = wxPyBeginBlockThreads();
3099 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3100 wxPyEndBlockThreads(blocked);
3101 if ( info.window )
3102 return self->IsShown(info.window);
3103 else if ( info.sizer )
3104 return self->IsShown(info.sizer);
3105 else if ( info.gotPos )
3106 return self->IsShown(info.pos);
3107 else
3108 return false;
3109 }
3110
3111 // See pyclasses.h
3112 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3113 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3114 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3115
3116
3117
3118
3119 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3120 {
3121 if (source == Py_None) {
3122 **obj = wxGBPosition(-1,-1);
3123 return true;
3124 }
3125 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3126 }
3127
3128 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3129 {
3130 if (source == Py_None) {
3131 **obj = wxGBSpan(-1,-1);
3132 return true;
3133 }
3134 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3135 }
3136
3137
3138 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3139 self->SetRow(row);
3140 self->SetCol(col);
3141 }
3142 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3143 bool blocked = wxPyBeginBlockThreads();
3144 PyObject* tup = PyTuple_New(2);
3145 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3146 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3147 wxPyEndBlockThreads(blocked);
3148 return tup;
3149 }
3150 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3151 self->SetRowspan(rowspan);
3152 self->SetColspan(colspan);
3153 }
3154 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3155 bool blocked = wxPyBeginBlockThreads();
3156 PyObject* tup = PyTuple_New(2);
3157 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3158 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3159 wxPyEndBlockThreads(blocked);
3160 return tup;
3161 }
3162 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3163 wxPyUserData* data = NULL;
3164 if ( userData ) {
3165 bool blocked = wxPyBeginBlockThreads();
3166 data = new wxPyUserData(userData);
3167 wxPyEndBlockThreads(blocked);
3168 }
3169 return new wxGBSizerItem(window, pos, span, flag, border, data);
3170 }
3171 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3172 wxPyUserData* data = NULL;
3173 if ( userData ) {
3174 bool blocked = wxPyBeginBlockThreads();
3175 data = new wxPyUserData(userData);
3176 wxPyEndBlockThreads(blocked);
3177 }
3178 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3179 }
3180 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3181 wxPyUserData* data = NULL;
3182 if ( userData ) {
3183 bool blocked = wxPyBeginBlockThreads();
3184 data = new wxPyUserData(userData);
3185 wxPyEndBlockThreads(blocked);
3186 }
3187 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3188 }
3189 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3190 int row, col;
3191 self->GetEndPos(row, col);
3192 return wxGBPosition(row, col);
3193 }
3194 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3195
3196 wxPyUserData* data = NULL;
3197 bool blocked = wxPyBeginBlockThreads();
3198 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3199 if ( userData && (info.window || info.sizer || info.gotSize) )
3200 data = new wxPyUserData(userData);
3201 wxPyEndBlockThreads(blocked);
3202
3203 // Now call the real Add method if a valid item type was found
3204 if ( info.window )
3205 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3206 else if ( info.sizer )
3207 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3208 else if (info.gotSize)
3209 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3210 pos, span, flag, border, data);
3211 return NULL;
3212 }
3213
3214
3215 #ifdef __cplusplus
3216 extern "C" {
3217 #endif
3218 static int _wrap_EmptyString_set(PyObject *) {
3219 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3220 return 1;
3221 }
3222
3223
3224 static PyObject *_wrap_EmptyString_get(void) {
3225 PyObject *pyobj;
3226
3227 {
3228 #if wxUSE_UNICODE
3229 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3230 #else
3231 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3232 #endif
3233 }
3234 return pyobj;
3235 }
3236
3237
3238 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3239 PyObject *resultobj;
3240 wxObject *arg1 = (wxObject *) 0 ;
3241 wxString result;
3242 PyObject * obj0 = 0 ;
3243 char *kwnames[] = {
3244 (char *) "self", NULL
3245 };
3246
3247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3249 if (SWIG_arg_fail(1)) SWIG_fail;
3250 {
3251 PyThreadState* __tstate = wxPyBeginAllowThreads();
3252 result = wxObject_GetClassName(arg1);
3253
3254 wxPyEndAllowThreads(__tstate);
3255 if (PyErr_Occurred()) SWIG_fail;
3256 }
3257 {
3258 #if wxUSE_UNICODE
3259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3260 #else
3261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3262 #endif
3263 }
3264 return resultobj;
3265 fail:
3266 return NULL;
3267 }
3268
3269
3270 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3271 PyObject *resultobj;
3272 wxObject *arg1 = (wxObject *) 0 ;
3273 PyObject * obj0 = 0 ;
3274 char *kwnames[] = {
3275 (char *) "self", NULL
3276 };
3277
3278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3280 if (SWIG_arg_fail(1)) SWIG_fail;
3281 {
3282 PyThreadState* __tstate = wxPyBeginAllowThreads();
3283 wxObject_Destroy(arg1);
3284
3285 wxPyEndAllowThreads(__tstate);
3286 if (PyErr_Occurred()) SWIG_fail;
3287 }
3288 Py_INCREF(Py_None); resultobj = Py_None;
3289 return resultobj;
3290 fail:
3291 return NULL;
3292 }
3293
3294
3295 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3296 PyObject *obj;
3297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3298 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3299 Py_INCREF(obj);
3300 return Py_BuildValue((char *)"");
3301 }
3302 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3303 PyObject *resultobj;
3304 wxSize *arg1 = (wxSize *) 0 ;
3305 int arg2 ;
3306 PyObject * obj0 = 0 ;
3307 PyObject * obj1 = 0 ;
3308 char *kwnames[] = {
3309 (char *) "self",(char *) "x", NULL
3310 };
3311
3312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3314 if (SWIG_arg_fail(1)) SWIG_fail;
3315 {
3316 arg2 = (int)(SWIG_As_int(obj1));
3317 if (SWIG_arg_fail(2)) SWIG_fail;
3318 }
3319 if (arg1) (arg1)->x = arg2;
3320
3321 Py_INCREF(Py_None); resultobj = Py_None;
3322 return resultobj;
3323 fail:
3324 return NULL;
3325 }
3326
3327
3328 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3329 PyObject *resultobj;
3330 wxSize *arg1 = (wxSize *) 0 ;
3331 int result;
3332 PyObject * obj0 = 0 ;
3333 char *kwnames[] = {
3334 (char *) "self", NULL
3335 };
3336
3337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3339 if (SWIG_arg_fail(1)) SWIG_fail;
3340 result = (int) ((arg1)->x);
3341
3342 {
3343 resultobj = SWIG_From_int((int)(result));
3344 }
3345 return resultobj;
3346 fail:
3347 return NULL;
3348 }
3349
3350
3351 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3352 PyObject *resultobj;
3353 wxSize *arg1 = (wxSize *) 0 ;
3354 int arg2 ;
3355 PyObject * obj0 = 0 ;
3356 PyObject * obj1 = 0 ;
3357 char *kwnames[] = {
3358 (char *) "self",(char *) "y", NULL
3359 };
3360
3361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3363 if (SWIG_arg_fail(1)) SWIG_fail;
3364 {
3365 arg2 = (int)(SWIG_As_int(obj1));
3366 if (SWIG_arg_fail(2)) SWIG_fail;
3367 }
3368 if (arg1) (arg1)->y = arg2;
3369
3370 Py_INCREF(Py_None); resultobj = Py_None;
3371 return resultobj;
3372 fail:
3373 return NULL;
3374 }
3375
3376
3377 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3378 PyObject *resultobj;
3379 wxSize *arg1 = (wxSize *) 0 ;
3380 int result;
3381 PyObject * obj0 = 0 ;
3382 char *kwnames[] = {
3383 (char *) "self", NULL
3384 };
3385
3386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3388 if (SWIG_arg_fail(1)) SWIG_fail;
3389 result = (int) ((arg1)->y);
3390
3391 {
3392 resultobj = SWIG_From_int((int)(result));
3393 }
3394 return resultobj;
3395 fail:
3396 return NULL;
3397 }
3398
3399
3400 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3401 PyObject *resultobj;
3402 int arg1 = (int) 0 ;
3403 int arg2 = (int) 0 ;
3404 wxSize *result;
3405 PyObject * obj0 = 0 ;
3406 PyObject * obj1 = 0 ;
3407 char *kwnames[] = {
3408 (char *) "w",(char *) "h", NULL
3409 };
3410
3411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3412 if (obj0) {
3413 {
3414 arg1 = (int)(SWIG_As_int(obj0));
3415 if (SWIG_arg_fail(1)) SWIG_fail;
3416 }
3417 }
3418 if (obj1) {
3419 {
3420 arg2 = (int)(SWIG_As_int(obj1));
3421 if (SWIG_arg_fail(2)) SWIG_fail;
3422 }
3423 }
3424 {
3425 PyThreadState* __tstate = wxPyBeginAllowThreads();
3426 result = (wxSize *)new wxSize(arg1,arg2);
3427
3428 wxPyEndAllowThreads(__tstate);
3429 if (PyErr_Occurred()) SWIG_fail;
3430 }
3431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3432 return resultobj;
3433 fail:
3434 return NULL;
3435 }
3436
3437
3438 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3439 PyObject *resultobj;
3440 wxSize *arg1 = (wxSize *) 0 ;
3441 PyObject * obj0 = 0 ;
3442 char *kwnames[] = {
3443 (char *) "self", NULL
3444 };
3445
3446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3448 if (SWIG_arg_fail(1)) SWIG_fail;
3449 {
3450 PyThreadState* __tstate = wxPyBeginAllowThreads();
3451 delete arg1;
3452
3453 wxPyEndAllowThreads(__tstate);
3454 if (PyErr_Occurred()) SWIG_fail;
3455 }
3456 Py_INCREF(Py_None); resultobj = Py_None;
3457 return resultobj;
3458 fail:
3459 return NULL;
3460 }
3461
3462
3463 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3464 PyObject *resultobj;
3465 wxSize *arg1 = (wxSize *) 0 ;
3466 wxSize *arg2 = 0 ;
3467 bool result;
3468 wxSize temp2 ;
3469 PyObject * obj0 = 0 ;
3470 PyObject * obj1 = 0 ;
3471 char *kwnames[] = {
3472 (char *) "self",(char *) "sz", NULL
3473 };
3474
3475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3477 if (SWIG_arg_fail(1)) SWIG_fail;
3478 {
3479 arg2 = &temp2;
3480 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3481 }
3482 {
3483 PyThreadState* __tstate = wxPyBeginAllowThreads();
3484 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3485
3486 wxPyEndAllowThreads(__tstate);
3487 if (PyErr_Occurred()) SWIG_fail;
3488 }
3489 {
3490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3491 }
3492 return resultobj;
3493 fail:
3494 return NULL;
3495 }
3496
3497
3498 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 wxSize *arg1 = (wxSize *) 0 ;
3501 wxSize *arg2 = 0 ;
3502 bool result;
3503 wxSize temp2 ;
3504 PyObject * obj0 = 0 ;
3505 PyObject * obj1 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "self",(char *) "sz", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 {
3514 arg2 = &temp2;
3515 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3516 }
3517 {
3518 PyThreadState* __tstate = wxPyBeginAllowThreads();
3519 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3520
3521 wxPyEndAllowThreads(__tstate);
3522 if (PyErr_Occurred()) SWIG_fail;
3523 }
3524 {
3525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3526 }
3527 return resultobj;
3528 fail:
3529 return NULL;
3530 }
3531
3532
3533 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3534 PyObject *resultobj;
3535 wxSize *arg1 = (wxSize *) 0 ;
3536 wxSize *arg2 = 0 ;
3537 wxSize result;
3538 wxSize temp2 ;
3539 PyObject * obj0 = 0 ;
3540 PyObject * obj1 = 0 ;
3541 char *kwnames[] = {
3542 (char *) "self",(char *) "sz", NULL
3543 };
3544
3545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3547 if (SWIG_arg_fail(1)) SWIG_fail;
3548 {
3549 arg2 = &temp2;
3550 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3551 }
3552 {
3553 PyThreadState* __tstate = wxPyBeginAllowThreads();
3554 result = (arg1)->operator +((wxSize const &)*arg2);
3555
3556 wxPyEndAllowThreads(__tstate);
3557 if (PyErr_Occurred()) SWIG_fail;
3558 }
3559 {
3560 wxSize * resultptr;
3561 resultptr = new wxSize((wxSize &)(result));
3562 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3563 }
3564 return resultobj;
3565 fail:
3566 return NULL;
3567 }
3568
3569
3570 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3571 PyObject *resultobj;
3572 wxSize *arg1 = (wxSize *) 0 ;
3573 wxSize *arg2 = 0 ;
3574 wxSize result;
3575 wxSize temp2 ;
3576 PyObject * obj0 = 0 ;
3577 PyObject * obj1 = 0 ;
3578 char *kwnames[] = {
3579 (char *) "self",(char *) "sz", NULL
3580 };
3581
3582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3584 if (SWIG_arg_fail(1)) SWIG_fail;
3585 {
3586 arg2 = &temp2;
3587 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3588 }
3589 {
3590 PyThreadState* __tstate = wxPyBeginAllowThreads();
3591 result = (arg1)->operator -((wxSize const &)*arg2);
3592
3593 wxPyEndAllowThreads(__tstate);
3594 if (PyErr_Occurred()) SWIG_fail;
3595 }
3596 {
3597 wxSize * resultptr;
3598 resultptr = new wxSize((wxSize &)(result));
3599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3600 }
3601 return resultobj;
3602 fail:
3603 return NULL;
3604 }
3605
3606
3607 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3608 PyObject *resultobj;
3609 wxSize *arg1 = (wxSize *) 0 ;
3610 wxSize *arg2 = 0 ;
3611 wxSize temp2 ;
3612 PyObject * obj0 = 0 ;
3613 PyObject * obj1 = 0 ;
3614 char *kwnames[] = {
3615 (char *) "self",(char *) "sz", NULL
3616 };
3617
3618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3620 if (SWIG_arg_fail(1)) SWIG_fail;
3621 {
3622 arg2 = &temp2;
3623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3624 }
3625 {
3626 PyThreadState* __tstate = wxPyBeginAllowThreads();
3627 (arg1)->IncTo((wxSize const &)*arg2);
3628
3629 wxPyEndAllowThreads(__tstate);
3630 if (PyErr_Occurred()) SWIG_fail;
3631 }
3632 Py_INCREF(Py_None); resultobj = Py_None;
3633 return resultobj;
3634 fail:
3635 return NULL;
3636 }
3637
3638
3639 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3640 PyObject *resultobj;
3641 wxSize *arg1 = (wxSize *) 0 ;
3642 wxSize *arg2 = 0 ;
3643 wxSize temp2 ;
3644 PyObject * obj0 = 0 ;
3645 PyObject * obj1 = 0 ;
3646 char *kwnames[] = {
3647 (char *) "self",(char *) "sz", NULL
3648 };
3649
3650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3652 if (SWIG_arg_fail(1)) SWIG_fail;
3653 {
3654 arg2 = &temp2;
3655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3656 }
3657 {
3658 PyThreadState* __tstate = wxPyBeginAllowThreads();
3659 (arg1)->DecTo((wxSize const &)*arg2);
3660
3661 wxPyEndAllowThreads(__tstate);
3662 if (PyErr_Occurred()) SWIG_fail;
3663 }
3664 Py_INCREF(Py_None); resultobj = Py_None;
3665 return resultobj;
3666 fail:
3667 return NULL;
3668 }
3669
3670
3671 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3672 PyObject *resultobj;
3673 wxSize *arg1 = (wxSize *) 0 ;
3674 int arg2 ;
3675 int arg3 ;
3676 PyObject * obj0 = 0 ;
3677 PyObject * obj1 = 0 ;
3678 PyObject * obj2 = 0 ;
3679 char *kwnames[] = {
3680 (char *) "self",(char *) "w",(char *) "h", NULL
3681 };
3682
3683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3685 if (SWIG_arg_fail(1)) SWIG_fail;
3686 {
3687 arg2 = (int)(SWIG_As_int(obj1));
3688 if (SWIG_arg_fail(2)) SWIG_fail;
3689 }
3690 {
3691 arg3 = (int)(SWIG_As_int(obj2));
3692 if (SWIG_arg_fail(3)) SWIG_fail;
3693 }
3694 {
3695 PyThreadState* __tstate = wxPyBeginAllowThreads();
3696 (arg1)->Set(arg2,arg3);
3697
3698 wxPyEndAllowThreads(__tstate);
3699 if (PyErr_Occurred()) SWIG_fail;
3700 }
3701 Py_INCREF(Py_None); resultobj = Py_None;
3702 return resultobj;
3703 fail:
3704 return NULL;
3705 }
3706
3707
3708 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3709 PyObject *resultobj;
3710 wxSize *arg1 = (wxSize *) 0 ;
3711 int arg2 ;
3712 PyObject * obj0 = 0 ;
3713 PyObject * obj1 = 0 ;
3714 char *kwnames[] = {
3715 (char *) "self",(char *) "w", NULL
3716 };
3717
3718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3720 if (SWIG_arg_fail(1)) SWIG_fail;
3721 {
3722 arg2 = (int)(SWIG_As_int(obj1));
3723 if (SWIG_arg_fail(2)) SWIG_fail;
3724 }
3725 {
3726 PyThreadState* __tstate = wxPyBeginAllowThreads();
3727 (arg1)->SetWidth(arg2);
3728
3729 wxPyEndAllowThreads(__tstate);
3730 if (PyErr_Occurred()) SWIG_fail;
3731 }
3732 Py_INCREF(Py_None); resultobj = Py_None;
3733 return resultobj;
3734 fail:
3735 return NULL;
3736 }
3737
3738
3739 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3740 PyObject *resultobj;
3741 wxSize *arg1 = (wxSize *) 0 ;
3742 int arg2 ;
3743 PyObject * obj0 = 0 ;
3744 PyObject * obj1 = 0 ;
3745 char *kwnames[] = {
3746 (char *) "self",(char *) "h", NULL
3747 };
3748
3749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3751 if (SWIG_arg_fail(1)) SWIG_fail;
3752 {
3753 arg2 = (int)(SWIG_As_int(obj1));
3754 if (SWIG_arg_fail(2)) SWIG_fail;
3755 }
3756 {
3757 PyThreadState* __tstate = wxPyBeginAllowThreads();
3758 (arg1)->SetHeight(arg2);
3759
3760 wxPyEndAllowThreads(__tstate);
3761 if (PyErr_Occurred()) SWIG_fail;
3762 }
3763 Py_INCREF(Py_None); resultobj = Py_None;
3764 return resultobj;
3765 fail:
3766 return NULL;
3767 }
3768
3769
3770 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3771 PyObject *resultobj;
3772 wxSize *arg1 = (wxSize *) 0 ;
3773 int result;
3774 PyObject * obj0 = 0 ;
3775 char *kwnames[] = {
3776 (char *) "self", NULL
3777 };
3778
3779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3781 if (SWIG_arg_fail(1)) SWIG_fail;
3782 {
3783 PyThreadState* __tstate = wxPyBeginAllowThreads();
3784 result = (int)((wxSize const *)arg1)->GetWidth();
3785
3786 wxPyEndAllowThreads(__tstate);
3787 if (PyErr_Occurred()) SWIG_fail;
3788 }
3789 {
3790 resultobj = SWIG_From_int((int)(result));
3791 }
3792 return resultobj;
3793 fail:
3794 return NULL;
3795 }
3796
3797
3798 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3799 PyObject *resultobj;
3800 wxSize *arg1 = (wxSize *) 0 ;
3801 int result;
3802 PyObject * obj0 = 0 ;
3803 char *kwnames[] = {
3804 (char *) "self", NULL
3805 };
3806
3807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3809 if (SWIG_arg_fail(1)) SWIG_fail;
3810 {
3811 PyThreadState* __tstate = wxPyBeginAllowThreads();
3812 result = (int)((wxSize const *)arg1)->GetHeight();
3813
3814 wxPyEndAllowThreads(__tstate);
3815 if (PyErr_Occurred()) SWIG_fail;
3816 }
3817 {
3818 resultobj = SWIG_From_int((int)(result));
3819 }
3820 return resultobj;
3821 fail:
3822 return NULL;
3823 }
3824
3825
3826 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3827 PyObject *resultobj;
3828 wxSize *arg1 = (wxSize *) 0 ;
3829 bool result;
3830 PyObject * obj0 = 0 ;
3831 char *kwnames[] = {
3832 (char *) "self", NULL
3833 };
3834
3835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3837 if (SWIG_arg_fail(1)) SWIG_fail;
3838 {
3839 PyThreadState* __tstate = wxPyBeginAllowThreads();
3840 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3841
3842 wxPyEndAllowThreads(__tstate);
3843 if (PyErr_Occurred()) SWIG_fail;
3844 }
3845 {
3846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3847 }
3848 return resultobj;
3849 fail:
3850 return NULL;
3851 }
3852
3853
3854 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3855 PyObject *resultobj;
3856 wxSize *arg1 = (wxSize *) 0 ;
3857 wxSize *arg2 = 0 ;
3858 wxSize temp2 ;
3859 PyObject * obj0 = 0 ;
3860 PyObject * obj1 = 0 ;
3861 char *kwnames[] = {
3862 (char *) "self",(char *) "size", NULL
3863 };
3864
3865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3867 if (SWIG_arg_fail(1)) SWIG_fail;
3868 {
3869 arg2 = &temp2;
3870 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3871 }
3872 {
3873 PyThreadState* __tstate = wxPyBeginAllowThreads();
3874 (arg1)->SetDefaults((wxSize const &)*arg2);
3875
3876 wxPyEndAllowThreads(__tstate);
3877 if (PyErr_Occurred()) SWIG_fail;
3878 }
3879 Py_INCREF(Py_None); resultobj = Py_None;
3880 return resultobj;
3881 fail:
3882 return NULL;
3883 }
3884
3885
3886 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3887 PyObject *resultobj;
3888 wxSize *arg1 = (wxSize *) 0 ;
3889 PyObject *result;
3890 PyObject * obj0 = 0 ;
3891 char *kwnames[] = {
3892 (char *) "self", NULL
3893 };
3894
3895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3897 if (SWIG_arg_fail(1)) SWIG_fail;
3898 {
3899 PyThreadState* __tstate = wxPyBeginAllowThreads();
3900 result = (PyObject *)wxSize_Get(arg1);
3901
3902 wxPyEndAllowThreads(__tstate);
3903 if (PyErr_Occurred()) SWIG_fail;
3904 }
3905 resultobj = result;
3906 return resultobj;
3907 fail:
3908 return NULL;
3909 }
3910
3911
3912 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3913 PyObject *obj;
3914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3915 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3916 Py_INCREF(obj);
3917 return Py_BuildValue((char *)"");
3918 }
3919 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3920 PyObject *resultobj;
3921 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3922 double arg2 ;
3923 PyObject * obj0 = 0 ;
3924 PyObject * obj1 = 0 ;
3925 char *kwnames[] = {
3926 (char *) "self",(char *) "x", NULL
3927 };
3928
3929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3931 if (SWIG_arg_fail(1)) SWIG_fail;
3932 {
3933 arg2 = (double)(SWIG_As_double(obj1));
3934 if (SWIG_arg_fail(2)) SWIG_fail;
3935 }
3936 if (arg1) (arg1)->x = arg2;
3937
3938 Py_INCREF(Py_None); resultobj = Py_None;
3939 return resultobj;
3940 fail:
3941 return NULL;
3942 }
3943
3944
3945 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3946 PyObject *resultobj;
3947 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3948 double result;
3949 PyObject * obj0 = 0 ;
3950 char *kwnames[] = {
3951 (char *) "self", NULL
3952 };
3953
3954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3956 if (SWIG_arg_fail(1)) SWIG_fail;
3957 result = (double) ((arg1)->x);
3958
3959 {
3960 resultobj = SWIG_From_double((double)(result));
3961 }
3962 return resultobj;
3963 fail:
3964 return NULL;
3965 }
3966
3967
3968 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3969 PyObject *resultobj;
3970 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3971 double arg2 ;
3972 PyObject * obj0 = 0 ;
3973 PyObject * obj1 = 0 ;
3974 char *kwnames[] = {
3975 (char *) "self",(char *) "y", NULL
3976 };
3977
3978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3980 if (SWIG_arg_fail(1)) SWIG_fail;
3981 {
3982 arg2 = (double)(SWIG_As_double(obj1));
3983 if (SWIG_arg_fail(2)) SWIG_fail;
3984 }
3985 if (arg1) (arg1)->y = arg2;
3986
3987 Py_INCREF(Py_None); resultobj = Py_None;
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj;
3996 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3997 double result;
3998 PyObject * obj0 = 0 ;
3999 char *kwnames[] = {
4000 (char *) "self", NULL
4001 };
4002
4003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4005 if (SWIG_arg_fail(1)) SWIG_fail;
4006 result = (double) ((arg1)->y);
4007
4008 {
4009 resultobj = SWIG_From_double((double)(result));
4010 }
4011 return resultobj;
4012 fail:
4013 return NULL;
4014 }
4015
4016
4017 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4018 PyObject *resultobj;
4019 double arg1 = (double) 0.0 ;
4020 double arg2 = (double) 0.0 ;
4021 wxRealPoint *result;
4022 PyObject * obj0 = 0 ;
4023 PyObject * obj1 = 0 ;
4024 char *kwnames[] = {
4025 (char *) "x",(char *) "y", NULL
4026 };
4027
4028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4029 if (obj0) {
4030 {
4031 arg1 = (double)(SWIG_As_double(obj0));
4032 if (SWIG_arg_fail(1)) SWIG_fail;
4033 }
4034 }
4035 if (obj1) {
4036 {
4037 arg2 = (double)(SWIG_As_double(obj1));
4038 if (SWIG_arg_fail(2)) SWIG_fail;
4039 }
4040 }
4041 {
4042 PyThreadState* __tstate = wxPyBeginAllowThreads();
4043 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4044
4045 wxPyEndAllowThreads(__tstate);
4046 if (PyErr_Occurred()) SWIG_fail;
4047 }
4048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4049 return resultobj;
4050 fail:
4051 return NULL;
4052 }
4053
4054
4055 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4056 PyObject *resultobj;
4057 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4058 PyObject * obj0 = 0 ;
4059 char *kwnames[] = {
4060 (char *) "self", NULL
4061 };
4062
4063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4065 if (SWIG_arg_fail(1)) SWIG_fail;
4066 {
4067 PyThreadState* __tstate = wxPyBeginAllowThreads();
4068 delete arg1;
4069
4070 wxPyEndAllowThreads(__tstate);
4071 if (PyErr_Occurred()) SWIG_fail;
4072 }
4073 Py_INCREF(Py_None); resultobj = Py_None;
4074 return resultobj;
4075 fail:
4076 return NULL;
4077 }
4078
4079
4080 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4081 PyObject *resultobj;
4082 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4083 wxRealPoint *arg2 = 0 ;
4084 bool result;
4085 wxRealPoint temp2 ;
4086 PyObject * obj0 = 0 ;
4087 PyObject * obj1 = 0 ;
4088 char *kwnames[] = {
4089 (char *) "self",(char *) "pt", NULL
4090 };
4091
4092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4094 if (SWIG_arg_fail(1)) SWIG_fail;
4095 {
4096 arg2 = &temp2;
4097 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4098 }
4099 {
4100 PyThreadState* __tstate = wxPyBeginAllowThreads();
4101 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4102
4103 wxPyEndAllowThreads(__tstate);
4104 if (PyErr_Occurred()) SWIG_fail;
4105 }
4106 {
4107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4108 }
4109 return resultobj;
4110 fail:
4111 return NULL;
4112 }
4113
4114
4115 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4116 PyObject *resultobj;
4117 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4118 wxRealPoint *arg2 = 0 ;
4119 bool result;
4120 wxRealPoint temp2 ;
4121 PyObject * obj0 = 0 ;
4122 PyObject * obj1 = 0 ;
4123 char *kwnames[] = {
4124 (char *) "self",(char *) "pt", NULL
4125 };
4126
4127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4129 if (SWIG_arg_fail(1)) SWIG_fail;
4130 {
4131 arg2 = &temp2;
4132 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4133 }
4134 {
4135 PyThreadState* __tstate = wxPyBeginAllowThreads();
4136 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4137
4138 wxPyEndAllowThreads(__tstate);
4139 if (PyErr_Occurred()) SWIG_fail;
4140 }
4141 {
4142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4143 }
4144 return resultobj;
4145 fail:
4146 return NULL;
4147 }
4148
4149
4150 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4151 PyObject *resultobj;
4152 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4153 wxRealPoint *arg2 = 0 ;
4154 wxRealPoint result;
4155 wxRealPoint temp2 ;
4156 PyObject * obj0 = 0 ;
4157 PyObject * obj1 = 0 ;
4158 char *kwnames[] = {
4159 (char *) "self",(char *) "pt", NULL
4160 };
4161
4162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4164 if (SWIG_arg_fail(1)) SWIG_fail;
4165 {
4166 arg2 = &temp2;
4167 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4168 }
4169 {
4170 PyThreadState* __tstate = wxPyBeginAllowThreads();
4171 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4172
4173 wxPyEndAllowThreads(__tstate);
4174 if (PyErr_Occurred()) SWIG_fail;
4175 }
4176 {
4177 wxRealPoint * resultptr;
4178 resultptr = new wxRealPoint((wxRealPoint &)(result));
4179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4180 }
4181 return resultobj;
4182 fail:
4183 return NULL;
4184 }
4185
4186
4187 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4188 PyObject *resultobj;
4189 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4190 wxRealPoint *arg2 = 0 ;
4191 wxRealPoint result;
4192 wxRealPoint temp2 ;
4193 PyObject * obj0 = 0 ;
4194 PyObject * obj1 = 0 ;
4195 char *kwnames[] = {
4196 (char *) "self",(char *) "pt", NULL
4197 };
4198
4199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4201 if (SWIG_arg_fail(1)) SWIG_fail;
4202 {
4203 arg2 = &temp2;
4204 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4205 }
4206 {
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4209
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 {
4214 wxRealPoint * resultptr;
4215 resultptr = new wxRealPoint((wxRealPoint &)(result));
4216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4217 }
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4225 PyObject *resultobj;
4226 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4227 double arg2 ;
4228 double arg3 ;
4229 PyObject * obj0 = 0 ;
4230 PyObject * obj1 = 0 ;
4231 PyObject * obj2 = 0 ;
4232 char *kwnames[] = {
4233 (char *) "self",(char *) "x",(char *) "y", NULL
4234 };
4235
4236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4238 if (SWIG_arg_fail(1)) SWIG_fail;
4239 {
4240 arg2 = (double)(SWIG_As_double(obj1));
4241 if (SWIG_arg_fail(2)) SWIG_fail;
4242 }
4243 {
4244 arg3 = (double)(SWIG_As_double(obj2));
4245 if (SWIG_arg_fail(3)) SWIG_fail;
4246 }
4247 {
4248 PyThreadState* __tstate = wxPyBeginAllowThreads();
4249 wxRealPoint_Set(arg1,arg2,arg3);
4250
4251 wxPyEndAllowThreads(__tstate);
4252 if (PyErr_Occurred()) SWIG_fail;
4253 }
4254 Py_INCREF(Py_None); resultobj = Py_None;
4255 return resultobj;
4256 fail:
4257 return NULL;
4258 }
4259
4260
4261 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4262 PyObject *resultobj;
4263 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4264 PyObject *result;
4265 PyObject * obj0 = 0 ;
4266 char *kwnames[] = {
4267 (char *) "self", NULL
4268 };
4269
4270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4272 if (SWIG_arg_fail(1)) SWIG_fail;
4273 {
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 result = (PyObject *)wxRealPoint_Get(arg1);
4276
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 resultobj = result;
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4288 PyObject *obj;
4289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4290 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4291 Py_INCREF(obj);
4292 return Py_BuildValue((char *)"");
4293 }
4294 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4295 PyObject *resultobj;
4296 wxPoint *arg1 = (wxPoint *) 0 ;
4297 int arg2 ;
4298 PyObject * obj0 = 0 ;
4299 PyObject * obj1 = 0 ;
4300 char *kwnames[] = {
4301 (char *) "self",(char *) "x", NULL
4302 };
4303
4304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4306 if (SWIG_arg_fail(1)) SWIG_fail;
4307 {
4308 arg2 = (int)(SWIG_As_int(obj1));
4309 if (SWIG_arg_fail(2)) SWIG_fail;
4310 }
4311 if (arg1) (arg1)->x = arg2;
4312
4313 Py_INCREF(Py_None); resultobj = Py_None;
4314 return resultobj;
4315 fail:
4316 return NULL;
4317 }
4318
4319
4320 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4321 PyObject *resultobj;
4322 wxPoint *arg1 = (wxPoint *) 0 ;
4323 int result;
4324 PyObject * obj0 = 0 ;
4325 char *kwnames[] = {
4326 (char *) "self", NULL
4327 };
4328
4329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4331 if (SWIG_arg_fail(1)) SWIG_fail;
4332 result = (int) ((arg1)->x);
4333
4334 {
4335 resultobj = SWIG_From_int((int)(result));
4336 }
4337 return resultobj;
4338 fail:
4339 return NULL;
4340 }
4341
4342
4343 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4344 PyObject *resultobj;
4345 wxPoint *arg1 = (wxPoint *) 0 ;
4346 int arg2 ;
4347 PyObject * obj0 = 0 ;
4348 PyObject * obj1 = 0 ;
4349 char *kwnames[] = {
4350 (char *) "self",(char *) "y", NULL
4351 };
4352
4353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4355 if (SWIG_arg_fail(1)) SWIG_fail;
4356 {
4357 arg2 = (int)(SWIG_As_int(obj1));
4358 if (SWIG_arg_fail(2)) SWIG_fail;
4359 }
4360 if (arg1) (arg1)->y = arg2;
4361
4362 Py_INCREF(Py_None); resultobj = Py_None;
4363 return resultobj;
4364 fail:
4365 return NULL;
4366 }
4367
4368
4369 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj;
4371 wxPoint *arg1 = (wxPoint *) 0 ;
4372 int result;
4373 PyObject * obj0 = 0 ;
4374 char *kwnames[] = {
4375 (char *) "self", NULL
4376 };
4377
4378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4380 if (SWIG_arg_fail(1)) SWIG_fail;
4381 result = (int) ((arg1)->y);
4382
4383 {
4384 resultobj = SWIG_From_int((int)(result));
4385 }
4386 return resultobj;
4387 fail:
4388 return NULL;
4389 }
4390
4391
4392 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4393 PyObject *resultobj;
4394 int arg1 = (int) 0 ;
4395 int arg2 = (int) 0 ;
4396 wxPoint *result;
4397 PyObject * obj0 = 0 ;
4398 PyObject * obj1 = 0 ;
4399 char *kwnames[] = {
4400 (char *) "x",(char *) "y", NULL
4401 };
4402
4403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4404 if (obj0) {
4405 {
4406 arg1 = (int)(SWIG_As_int(obj0));
4407 if (SWIG_arg_fail(1)) SWIG_fail;
4408 }
4409 }
4410 if (obj1) {
4411 {
4412 arg2 = (int)(SWIG_As_int(obj1));
4413 if (SWIG_arg_fail(2)) SWIG_fail;
4414 }
4415 }
4416 {
4417 PyThreadState* __tstate = wxPyBeginAllowThreads();
4418 result = (wxPoint *)new wxPoint(arg1,arg2);
4419
4420 wxPyEndAllowThreads(__tstate);
4421 if (PyErr_Occurred()) SWIG_fail;
4422 }
4423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4424 return resultobj;
4425 fail:
4426 return NULL;
4427 }
4428
4429
4430 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4431 PyObject *resultobj;
4432 wxPoint *arg1 = (wxPoint *) 0 ;
4433 PyObject * obj0 = 0 ;
4434 char *kwnames[] = {
4435 (char *) "self", NULL
4436 };
4437
4438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4440 if (SWIG_arg_fail(1)) SWIG_fail;
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 delete arg1;
4444
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 Py_INCREF(Py_None); resultobj = Py_None;
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4456 PyObject *resultobj;
4457 wxPoint *arg1 = (wxPoint *) 0 ;
4458 wxPoint *arg2 = 0 ;
4459 bool result;
4460 wxPoint temp2 ;
4461 PyObject * obj0 = 0 ;
4462 PyObject * obj1 = 0 ;
4463 char *kwnames[] = {
4464 (char *) "self",(char *) "pt", NULL
4465 };
4466
4467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4469 if (SWIG_arg_fail(1)) SWIG_fail;
4470 {
4471 arg2 = &temp2;
4472 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4473 }
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 {
4482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4483 }
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4491 PyObject *resultobj;
4492 wxPoint *arg1 = (wxPoint *) 0 ;
4493 wxPoint *arg2 = 0 ;
4494 bool result;
4495 wxPoint temp2 ;
4496 PyObject * obj0 = 0 ;
4497 PyObject * obj1 = 0 ;
4498 char *kwnames[] = {
4499 (char *) "self",(char *) "pt", NULL
4500 };
4501
4502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4504 if (SWIG_arg_fail(1)) SWIG_fail;
4505 {
4506 arg2 = &temp2;
4507 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4508 }
4509 {
4510 PyThreadState* __tstate = wxPyBeginAllowThreads();
4511 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4512
4513 wxPyEndAllowThreads(__tstate);
4514 if (PyErr_Occurred()) SWIG_fail;
4515 }
4516 {
4517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4518 }
4519 return resultobj;
4520 fail:
4521 return NULL;
4522 }
4523
4524
4525 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4526 PyObject *resultobj;
4527 wxPoint *arg1 = (wxPoint *) 0 ;
4528 wxPoint *arg2 = 0 ;
4529 wxPoint result;
4530 wxPoint temp2 ;
4531 PyObject * obj0 = 0 ;
4532 PyObject * obj1 = 0 ;
4533 char *kwnames[] = {
4534 (char *) "self",(char *) "pt", NULL
4535 };
4536
4537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4539 if (SWIG_arg_fail(1)) SWIG_fail;
4540 {
4541 arg2 = &temp2;
4542 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4543 }
4544 {
4545 PyThreadState* __tstate = wxPyBeginAllowThreads();
4546 result = (arg1)->operator +((wxPoint const &)*arg2);
4547
4548 wxPyEndAllowThreads(__tstate);
4549 if (PyErr_Occurred()) SWIG_fail;
4550 }
4551 {
4552 wxPoint * resultptr;
4553 resultptr = new wxPoint((wxPoint &)(result));
4554 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4555 }
4556 return resultobj;
4557 fail:
4558 return NULL;
4559 }
4560
4561
4562 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4563 PyObject *resultobj;
4564 wxPoint *arg1 = (wxPoint *) 0 ;
4565 wxPoint *arg2 = 0 ;
4566 wxPoint result;
4567 wxPoint temp2 ;
4568 PyObject * obj0 = 0 ;
4569 PyObject * obj1 = 0 ;
4570 char *kwnames[] = {
4571 (char *) "self",(char *) "pt", NULL
4572 };
4573
4574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4576 if (SWIG_arg_fail(1)) SWIG_fail;
4577 {
4578 arg2 = &temp2;
4579 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4580 }
4581 {
4582 PyThreadState* __tstate = wxPyBeginAllowThreads();
4583 result = (arg1)->operator -((wxPoint const &)*arg2);
4584
4585 wxPyEndAllowThreads(__tstate);
4586 if (PyErr_Occurred()) SWIG_fail;
4587 }
4588 {
4589 wxPoint * resultptr;
4590 resultptr = new wxPoint((wxPoint &)(result));
4591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4592 }
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4600 PyObject *resultobj;
4601 wxPoint *arg1 = (wxPoint *) 0 ;
4602 wxPoint *arg2 = 0 ;
4603 wxPoint *result;
4604 wxPoint temp2 ;
4605 PyObject * obj0 = 0 ;
4606 PyObject * obj1 = 0 ;
4607 char *kwnames[] = {
4608 (char *) "self",(char *) "pt", NULL
4609 };
4610
4611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4613 if (SWIG_arg_fail(1)) SWIG_fail;
4614 {
4615 arg2 = &temp2;
4616 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4617 }
4618 {
4619 PyThreadState* __tstate = wxPyBeginAllowThreads();
4620 {
4621 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4622 result = (wxPoint *) &_result_ref;
4623 }
4624
4625 wxPyEndAllowThreads(__tstate);
4626 if (PyErr_Occurred()) SWIG_fail;
4627 }
4628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4629 return resultobj;
4630 fail:
4631 return NULL;
4632 }
4633
4634
4635 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4636 PyObject *resultobj;
4637 wxPoint *arg1 = (wxPoint *) 0 ;
4638 wxPoint *arg2 = 0 ;
4639 wxPoint *result;
4640 wxPoint temp2 ;
4641 PyObject * obj0 = 0 ;
4642 PyObject * obj1 = 0 ;
4643 char *kwnames[] = {
4644 (char *) "self",(char *) "pt", NULL
4645 };
4646
4647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4649 if (SWIG_arg_fail(1)) SWIG_fail;
4650 {
4651 arg2 = &temp2;
4652 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4653 }
4654 {
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 {
4657 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4658 result = (wxPoint *) &_result_ref;
4659 }
4660
4661 wxPyEndAllowThreads(__tstate);
4662 if (PyErr_Occurred()) SWIG_fail;
4663 }
4664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj;
4673 wxPoint *arg1 = (wxPoint *) 0 ;
4674 long arg2 ;
4675 long arg3 ;
4676 PyObject * obj0 = 0 ;
4677 PyObject * obj1 = 0 ;
4678 PyObject * obj2 = 0 ;
4679 char *kwnames[] = {
4680 (char *) "self",(char *) "x",(char *) "y", NULL
4681 };
4682
4683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4685 if (SWIG_arg_fail(1)) SWIG_fail;
4686 {
4687 arg2 = (long)(SWIG_As_long(obj1));
4688 if (SWIG_arg_fail(2)) SWIG_fail;
4689 }
4690 {
4691 arg3 = (long)(SWIG_As_long(obj2));
4692 if (SWIG_arg_fail(3)) SWIG_fail;
4693 }
4694 {
4695 PyThreadState* __tstate = wxPyBeginAllowThreads();
4696 wxPoint_Set(arg1,arg2,arg3);
4697
4698 wxPyEndAllowThreads(__tstate);
4699 if (PyErr_Occurred()) SWIG_fail;
4700 }
4701 Py_INCREF(Py_None); resultobj = Py_None;
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj;
4710 wxPoint *arg1 = (wxPoint *) 0 ;
4711 PyObject *result;
4712 PyObject * obj0 = 0 ;
4713 char *kwnames[] = {
4714 (char *) "self", NULL
4715 };
4716
4717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4719 if (SWIG_arg_fail(1)) SWIG_fail;
4720 {
4721 PyThreadState* __tstate = wxPyBeginAllowThreads();
4722 result = (PyObject *)wxPoint_Get(arg1);
4723
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 resultobj = result;
4728 return resultobj;
4729 fail:
4730 return NULL;
4731 }
4732
4733
4734 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4735 PyObject *obj;
4736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4737 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4738 Py_INCREF(obj);
4739 return Py_BuildValue((char *)"");
4740 }
4741 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj;
4743 int arg1 = (int) 0 ;
4744 int arg2 = (int) 0 ;
4745 int arg3 = (int) 0 ;
4746 int arg4 = (int) 0 ;
4747 wxRect *result;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 PyObject * obj2 = 0 ;
4751 PyObject * obj3 = 0 ;
4752 char *kwnames[] = {
4753 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4754 };
4755
4756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4757 if (obj0) {
4758 {
4759 arg1 = (int)(SWIG_As_int(obj0));
4760 if (SWIG_arg_fail(1)) SWIG_fail;
4761 }
4762 }
4763 if (obj1) {
4764 {
4765 arg2 = (int)(SWIG_As_int(obj1));
4766 if (SWIG_arg_fail(2)) SWIG_fail;
4767 }
4768 }
4769 if (obj2) {
4770 {
4771 arg3 = (int)(SWIG_As_int(obj2));
4772 if (SWIG_arg_fail(3)) SWIG_fail;
4773 }
4774 }
4775 if (obj3) {
4776 {
4777 arg4 = (int)(SWIG_As_int(obj3));
4778 if (SWIG_arg_fail(4)) SWIG_fail;
4779 }
4780 }
4781 {
4782 PyThreadState* __tstate = wxPyBeginAllowThreads();
4783 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4784
4785 wxPyEndAllowThreads(__tstate);
4786 if (PyErr_Occurred()) SWIG_fail;
4787 }
4788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4789 return resultobj;
4790 fail:
4791 return NULL;
4792 }
4793
4794
4795 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4796 PyObject *resultobj;
4797 wxPoint *arg1 = 0 ;
4798 wxPoint *arg2 = 0 ;
4799 wxRect *result;
4800 wxPoint temp1 ;
4801 wxPoint temp2 ;
4802 PyObject * obj0 = 0 ;
4803 PyObject * obj1 = 0 ;
4804 char *kwnames[] = {
4805 (char *) "topLeft",(char *) "bottomRight", NULL
4806 };
4807
4808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4809 {
4810 arg1 = &temp1;
4811 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4812 }
4813 {
4814 arg2 = &temp2;
4815 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4816 }
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4820
4821 wxPyEndAllowThreads(__tstate);
4822 if (PyErr_Occurred()) SWIG_fail;
4823 }
4824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4825 return resultobj;
4826 fail:
4827 return NULL;
4828 }
4829
4830
4831 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4832 PyObject *resultobj;
4833 wxPoint *arg1 = 0 ;
4834 wxSize *arg2 = 0 ;
4835 wxRect *result;
4836 wxPoint temp1 ;
4837 wxSize temp2 ;
4838 PyObject * obj0 = 0 ;
4839 PyObject * obj1 = 0 ;
4840 char *kwnames[] = {
4841 (char *) "pos",(char *) "size", NULL
4842 };
4843
4844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4845 {
4846 arg1 = &temp1;
4847 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4848 }
4849 {
4850 arg2 = &temp2;
4851 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4852 }
4853 {
4854 PyThreadState* __tstate = wxPyBeginAllowThreads();
4855 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4856
4857 wxPyEndAllowThreads(__tstate);
4858 if (PyErr_Occurred()) SWIG_fail;
4859 }
4860 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4861 return resultobj;
4862 fail:
4863 return NULL;
4864 }
4865
4866
4867 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4868 PyObject *resultobj;
4869 wxSize *arg1 = 0 ;
4870 wxRect *result;
4871 wxSize temp1 ;
4872 PyObject * obj0 = 0 ;
4873 char *kwnames[] = {
4874 (char *) "size", NULL
4875 };
4876
4877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4878 {
4879 arg1 = &temp1;
4880 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4881 }
4882 {
4883 PyThreadState* __tstate = wxPyBeginAllowThreads();
4884 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4885
4886 wxPyEndAllowThreads(__tstate);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4897 PyObject *resultobj;
4898 wxRect *arg1 = (wxRect *) 0 ;
4899 PyObject * obj0 = 0 ;
4900 char *kwnames[] = {
4901 (char *) "self", NULL
4902 };
4903
4904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4906 if (SWIG_arg_fail(1)) SWIG_fail;
4907 {
4908 PyThreadState* __tstate = wxPyBeginAllowThreads();
4909 delete arg1;
4910
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 Py_INCREF(Py_None); resultobj = Py_None;
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4922 PyObject *resultobj;
4923 wxRect *arg1 = (wxRect *) 0 ;
4924 int result;
4925 PyObject * obj0 = 0 ;
4926 char *kwnames[] = {
4927 (char *) "self", NULL
4928 };
4929
4930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",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 result = (int)((wxRect const *)arg1)->GetX();
4936
4937 wxPyEndAllowThreads(__tstate);
4938 if (PyErr_Occurred()) SWIG_fail;
4939 }
4940 {
4941 resultobj = SWIG_From_int((int)(result));
4942 }
4943 return resultobj;
4944 fail:
4945 return NULL;
4946 }
4947
4948
4949 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4950 PyObject *resultobj;
4951 wxRect *arg1 = (wxRect *) 0 ;
4952 int arg2 ;
4953 PyObject * obj0 = 0 ;
4954 PyObject * obj1 = 0 ;
4955 char *kwnames[] = {
4956 (char *) "self",(char *) "x", NULL
4957 };
4958
4959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4961 if (SWIG_arg_fail(1)) SWIG_fail;
4962 {
4963 arg2 = (int)(SWIG_As_int(obj1));
4964 if (SWIG_arg_fail(2)) SWIG_fail;
4965 }
4966 {
4967 PyThreadState* __tstate = wxPyBeginAllowThreads();
4968 (arg1)->SetX(arg2);
4969
4970 wxPyEndAllowThreads(__tstate);
4971 if (PyErr_Occurred()) SWIG_fail;
4972 }
4973 Py_INCREF(Py_None); resultobj = Py_None;
4974 return resultobj;
4975 fail:
4976 return NULL;
4977 }
4978
4979
4980 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4981 PyObject *resultobj;
4982 wxRect *arg1 = (wxRect *) 0 ;
4983 int result;
4984 PyObject * obj0 = 0 ;
4985 char *kwnames[] = {
4986 (char *) "self", NULL
4987 };
4988
4989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4991 if (SWIG_arg_fail(1)) SWIG_fail;
4992 {
4993 PyThreadState* __tstate = wxPyBeginAllowThreads();
4994 result = (int)(arg1)->GetY();
4995
4996 wxPyEndAllowThreads(__tstate);
4997 if (PyErr_Occurred()) SWIG_fail;
4998 }
4999 {
5000 resultobj = SWIG_From_int((int)(result));
5001 }
5002 return resultobj;
5003 fail:
5004 return NULL;
5005 }
5006
5007
5008 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5009 PyObject *resultobj;
5010 wxRect *arg1 = (wxRect *) 0 ;
5011 int arg2 ;
5012 PyObject * obj0 = 0 ;
5013 PyObject * obj1 = 0 ;
5014 char *kwnames[] = {
5015 (char *) "self",(char *) "y", NULL
5016 };
5017
5018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5020 if (SWIG_arg_fail(1)) SWIG_fail;
5021 {
5022 arg2 = (int)(SWIG_As_int(obj1));
5023 if (SWIG_arg_fail(2)) SWIG_fail;
5024 }
5025 {
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 (arg1)->SetY(arg2);
5028
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 Py_INCREF(Py_None); resultobj = Py_None;
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5040 PyObject *resultobj;
5041 wxRect *arg1 = (wxRect *) 0 ;
5042 int result;
5043 PyObject * obj0 = 0 ;
5044 char *kwnames[] = {
5045 (char *) "self", NULL
5046 };
5047
5048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5050 if (SWIG_arg_fail(1)) SWIG_fail;
5051 {
5052 PyThreadState* __tstate = wxPyBeginAllowThreads();
5053 result = (int)((wxRect const *)arg1)->GetWidth();
5054
5055 wxPyEndAllowThreads(__tstate);
5056 if (PyErr_Occurred()) SWIG_fail;
5057 }
5058 {
5059 resultobj = SWIG_From_int((int)(result));
5060 }
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5068 PyObject *resultobj;
5069 wxRect *arg1 = (wxRect *) 0 ;
5070 int arg2 ;
5071 PyObject * obj0 = 0 ;
5072 PyObject * obj1 = 0 ;
5073 char *kwnames[] = {
5074 (char *) "self",(char *) "w", NULL
5075 };
5076
5077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5079 if (SWIG_arg_fail(1)) SWIG_fail;
5080 {
5081 arg2 = (int)(SWIG_As_int(obj1));
5082 if (SWIG_arg_fail(2)) SWIG_fail;
5083 }
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 (arg1)->SetWidth(arg2);
5087
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 Py_INCREF(Py_None); resultobj = Py_None;
5092 return resultobj;
5093 fail:
5094 return NULL;
5095 }
5096
5097
5098 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5099 PyObject *resultobj;
5100 wxRect *arg1 = (wxRect *) 0 ;
5101 int result;
5102 PyObject * obj0 = 0 ;
5103 char *kwnames[] = {
5104 (char *) "self", NULL
5105 };
5106
5107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5109 if (SWIG_arg_fail(1)) SWIG_fail;
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = (int)((wxRect const *)arg1)->GetHeight();
5113
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 resultobj = SWIG_From_int((int)(result));
5119 }
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj;
5128 wxRect *arg1 = (wxRect *) 0 ;
5129 int arg2 ;
5130 PyObject * obj0 = 0 ;
5131 PyObject * obj1 = 0 ;
5132 char *kwnames[] = {
5133 (char *) "self",(char *) "h", NULL
5134 };
5135
5136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5138 if (SWIG_arg_fail(1)) SWIG_fail;
5139 {
5140 arg2 = (int)(SWIG_As_int(obj1));
5141 if (SWIG_arg_fail(2)) SWIG_fail;
5142 }
5143 {
5144 PyThreadState* __tstate = wxPyBeginAllowThreads();
5145 (arg1)->SetHeight(arg2);
5146
5147 wxPyEndAllowThreads(__tstate);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 Py_INCREF(Py_None); resultobj = Py_None;
5151 return resultobj;
5152 fail:
5153 return NULL;
5154 }
5155
5156
5157 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5158 PyObject *resultobj;
5159 wxRect *arg1 = (wxRect *) 0 ;
5160 wxPoint result;
5161 PyObject * obj0 = 0 ;
5162 char *kwnames[] = {
5163 (char *) "self", NULL
5164 };
5165
5166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5168 if (SWIG_arg_fail(1)) SWIG_fail;
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 result = ((wxRect const *)arg1)->GetPosition();
5172
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 {
5177 wxPoint * resultptr;
5178 resultptr = new wxPoint((wxPoint &)(result));
5179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5180 }
5181 return resultobj;
5182 fail:
5183 return NULL;
5184 }
5185
5186
5187 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5188 PyObject *resultobj;
5189 wxRect *arg1 = (wxRect *) 0 ;
5190 wxPoint *arg2 = 0 ;
5191 wxPoint temp2 ;
5192 PyObject * obj0 = 0 ;
5193 PyObject * obj1 = 0 ;
5194 char *kwnames[] = {
5195 (char *) "self",(char *) "p", NULL
5196 };
5197
5198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5200 if (SWIG_arg_fail(1)) SWIG_fail;
5201 {
5202 arg2 = &temp2;
5203 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5204 }
5205 {
5206 PyThreadState* __tstate = wxPyBeginAllowThreads();
5207 (arg1)->SetPosition((wxPoint const &)*arg2);
5208
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 Py_INCREF(Py_None); resultobj = Py_None;
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5220 PyObject *resultobj;
5221 wxRect *arg1 = (wxRect *) 0 ;
5222 wxSize result;
5223 PyObject * obj0 = 0 ;
5224 char *kwnames[] = {
5225 (char *) "self", NULL
5226 };
5227
5228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5230 if (SWIG_arg_fail(1)) SWIG_fail;
5231 {
5232 PyThreadState* __tstate = wxPyBeginAllowThreads();
5233 result = ((wxRect const *)arg1)->GetSize();
5234
5235 wxPyEndAllowThreads(__tstate);
5236 if (PyErr_Occurred()) SWIG_fail;
5237 }
5238 {
5239 wxSize * resultptr;
5240 resultptr = new wxSize((wxSize &)(result));
5241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5242 }
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5250 PyObject *resultobj;
5251 wxRect *arg1 = (wxRect *) 0 ;
5252 wxSize *arg2 = 0 ;
5253 wxSize temp2 ;
5254 PyObject * obj0 = 0 ;
5255 PyObject * obj1 = 0 ;
5256 char *kwnames[] = {
5257 (char *) "self",(char *) "s", NULL
5258 };
5259
5260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5262 if (SWIG_arg_fail(1)) SWIG_fail;
5263 {
5264 arg2 = &temp2;
5265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5266 }
5267 {
5268 PyThreadState* __tstate = wxPyBeginAllowThreads();
5269 (arg1)->SetSize((wxSize const &)*arg2);
5270
5271 wxPyEndAllowThreads(__tstate);
5272 if (PyErr_Occurred()) SWIG_fail;
5273 }
5274 Py_INCREF(Py_None); resultobj = Py_None;
5275 return resultobj;
5276 fail:
5277 return NULL;
5278 }
5279
5280
5281 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5282 PyObject *resultobj;
5283 wxRect *arg1 = (wxRect *) 0 ;
5284 wxPoint result;
5285 PyObject * obj0 = 0 ;
5286 char *kwnames[] = {
5287 (char *) "self", NULL
5288 };
5289
5290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5292 if (SWIG_arg_fail(1)) SWIG_fail;
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 result = ((wxRect const *)arg1)->GetTopLeft();
5296
5297 wxPyEndAllowThreads(__tstate);
5298 if (PyErr_Occurred()) SWIG_fail;
5299 }
5300 {
5301 wxPoint * resultptr;
5302 resultptr = new wxPoint((wxPoint &)(result));
5303 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5304 }
5305 return resultobj;
5306 fail:
5307 return NULL;
5308 }
5309
5310
5311 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5312 PyObject *resultobj;
5313 wxRect *arg1 = (wxRect *) 0 ;
5314 wxPoint *arg2 = 0 ;
5315 wxPoint temp2 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char *kwnames[] = {
5319 (char *) "self",(char *) "p", NULL
5320 };
5321
5322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5324 if (SWIG_arg_fail(1)) SWIG_fail;
5325 {
5326 arg2 = &temp2;
5327 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5328 }
5329 {
5330 PyThreadState* __tstate = wxPyBeginAllowThreads();
5331 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5332
5333 wxPyEndAllowThreads(__tstate);
5334 if (PyErr_Occurred()) SWIG_fail;
5335 }
5336 Py_INCREF(Py_None); resultobj = Py_None;
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5344 PyObject *resultobj;
5345 wxRect *arg1 = (wxRect *) 0 ;
5346 wxPoint result;
5347 PyObject * obj0 = 0 ;
5348 char *kwnames[] = {
5349 (char *) "self", NULL
5350 };
5351
5352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5354 if (SWIG_arg_fail(1)) SWIG_fail;
5355 {
5356 PyThreadState* __tstate = wxPyBeginAllowThreads();
5357 result = ((wxRect const *)arg1)->GetBottomRight();
5358
5359 wxPyEndAllowThreads(__tstate);
5360 if (PyErr_Occurred()) SWIG_fail;
5361 }
5362 {
5363 wxPoint * resultptr;
5364 resultptr = new wxPoint((wxPoint &)(result));
5365 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5366 }
5367 return resultobj;
5368 fail:
5369 return NULL;
5370 }
5371
5372
5373 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5374 PyObject *resultobj;
5375 wxRect *arg1 = (wxRect *) 0 ;
5376 wxPoint *arg2 = 0 ;
5377 wxPoint temp2 ;
5378 PyObject * obj0 = 0 ;
5379 PyObject * obj1 = 0 ;
5380 char *kwnames[] = {
5381 (char *) "self",(char *) "p", NULL
5382 };
5383
5384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5386 if (SWIG_arg_fail(1)) SWIG_fail;
5387 {
5388 arg2 = &temp2;
5389 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5390 }
5391 {
5392 PyThreadState* __tstate = wxPyBeginAllowThreads();
5393 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5394
5395 wxPyEndAllowThreads(__tstate);
5396 if (PyErr_Occurred()) SWIG_fail;
5397 }
5398 Py_INCREF(Py_None); resultobj = Py_None;
5399 return resultobj;
5400 fail:
5401 return NULL;
5402 }
5403
5404
5405 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5406 PyObject *resultobj;
5407 wxRect *arg1 = (wxRect *) 0 ;
5408 int result;
5409 PyObject * obj0 = 0 ;
5410 char *kwnames[] = {
5411 (char *) "self", NULL
5412 };
5413
5414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5416 if (SWIG_arg_fail(1)) SWIG_fail;
5417 {
5418 PyThreadState* __tstate = wxPyBeginAllowThreads();
5419 result = (int)((wxRect const *)arg1)->GetLeft();
5420
5421 wxPyEndAllowThreads(__tstate);
5422 if (PyErr_Occurred()) SWIG_fail;
5423 }
5424 {
5425 resultobj = SWIG_From_int((int)(result));
5426 }
5427 return resultobj;
5428 fail:
5429 return NULL;
5430 }
5431
5432
5433 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5434 PyObject *resultobj;
5435 wxRect *arg1 = (wxRect *) 0 ;
5436 int result;
5437 PyObject * obj0 = 0 ;
5438 char *kwnames[] = {
5439 (char *) "self", NULL
5440 };
5441
5442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5444 if (SWIG_arg_fail(1)) SWIG_fail;
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 result = (int)((wxRect const *)arg1)->GetTop();
5448
5449 wxPyEndAllowThreads(__tstate);
5450 if (PyErr_Occurred()) SWIG_fail;
5451 }
5452 {
5453 resultobj = SWIG_From_int((int)(result));
5454 }
5455 return resultobj;
5456 fail:
5457 return NULL;
5458 }
5459
5460
5461 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5462 PyObject *resultobj;
5463 wxRect *arg1 = (wxRect *) 0 ;
5464 int result;
5465 PyObject * obj0 = 0 ;
5466 char *kwnames[] = {
5467 (char *) "self", NULL
5468 };
5469
5470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5472 if (SWIG_arg_fail(1)) SWIG_fail;
5473 {
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 result = (int)((wxRect const *)arg1)->GetBottom();
5476
5477 wxPyEndAllowThreads(__tstate);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 {
5481 resultobj = SWIG_From_int((int)(result));
5482 }
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5490 PyObject *resultobj;
5491 wxRect *arg1 = (wxRect *) 0 ;
5492 int result;
5493 PyObject * obj0 = 0 ;
5494 char *kwnames[] = {
5495 (char *) "self", NULL
5496 };
5497
5498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5500 if (SWIG_arg_fail(1)) SWIG_fail;
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = (int)((wxRect const *)arg1)->GetRight();
5504
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 {
5509 resultobj = SWIG_From_int((int)(result));
5510 }
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj;
5519 wxRect *arg1 = (wxRect *) 0 ;
5520 int arg2 ;
5521 PyObject * obj0 = 0 ;
5522 PyObject * obj1 = 0 ;
5523 char *kwnames[] = {
5524 (char *) "self",(char *) "left", NULL
5525 };
5526
5527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5529 if (SWIG_arg_fail(1)) SWIG_fail;
5530 {
5531 arg2 = (int)(SWIG_As_int(obj1));
5532 if (SWIG_arg_fail(2)) SWIG_fail;
5533 }
5534 {
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 (arg1)->SetLeft(arg2);
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 Py_INCREF(Py_None); resultobj = Py_None;
5542 return resultobj;
5543 fail:
5544 return NULL;
5545 }
5546
5547
5548 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5549 PyObject *resultobj;
5550 wxRect *arg1 = (wxRect *) 0 ;
5551 int arg2 ;
5552 PyObject * obj0 = 0 ;
5553 PyObject * obj1 = 0 ;
5554 char *kwnames[] = {
5555 (char *) "self",(char *) "right", NULL
5556 };
5557
5558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5560 if (SWIG_arg_fail(1)) SWIG_fail;
5561 {
5562 arg2 = (int)(SWIG_As_int(obj1));
5563 if (SWIG_arg_fail(2)) SWIG_fail;
5564 }
5565 {
5566 PyThreadState* __tstate = wxPyBeginAllowThreads();
5567 (arg1)->SetRight(arg2);
5568
5569 wxPyEndAllowThreads(__tstate);
5570 if (PyErr_Occurred()) SWIG_fail;
5571 }
5572 Py_INCREF(Py_None); resultobj = Py_None;
5573 return resultobj;
5574 fail:
5575 return NULL;
5576 }
5577
5578
5579 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5580 PyObject *resultobj;
5581 wxRect *arg1 = (wxRect *) 0 ;
5582 int arg2 ;
5583 PyObject * obj0 = 0 ;
5584 PyObject * obj1 = 0 ;
5585 char *kwnames[] = {
5586 (char *) "self",(char *) "top", NULL
5587 };
5588
5589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5591 if (SWIG_arg_fail(1)) SWIG_fail;
5592 {
5593 arg2 = (int)(SWIG_As_int(obj1));
5594 if (SWIG_arg_fail(2)) SWIG_fail;
5595 }
5596 {
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 (arg1)->SetTop(arg2);
5599
5600 wxPyEndAllowThreads(__tstate);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 Py_INCREF(Py_None); resultobj = Py_None;
5604 return resultobj;
5605 fail:
5606 return NULL;
5607 }
5608
5609
5610 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5611 PyObject *resultobj;
5612 wxRect *arg1 = (wxRect *) 0 ;
5613 int arg2 ;
5614 PyObject * obj0 = 0 ;
5615 PyObject * obj1 = 0 ;
5616 char *kwnames[] = {
5617 (char *) "self",(char *) "bottom", NULL
5618 };
5619
5620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5622 if (SWIG_arg_fail(1)) SWIG_fail;
5623 {
5624 arg2 = (int)(SWIG_As_int(obj1));
5625 if (SWIG_arg_fail(2)) SWIG_fail;
5626 }
5627 {
5628 PyThreadState* __tstate = wxPyBeginAllowThreads();
5629 (arg1)->SetBottom(arg2);
5630
5631 wxPyEndAllowThreads(__tstate);
5632 if (PyErr_Occurred()) SWIG_fail;
5633 }
5634 Py_INCREF(Py_None); resultobj = Py_None;
5635 return resultobj;
5636 fail:
5637 return NULL;
5638 }
5639
5640
5641 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5642 PyObject *resultobj;
5643 wxRect *arg1 = (wxRect *) 0 ;
5644 int arg2 ;
5645 int arg3 ;
5646 wxRect *result;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 PyObject * obj2 = 0 ;
5650 char *kwnames[] = {
5651 (char *) "self",(char *) "dx",(char *) "dy", NULL
5652 };
5653
5654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5656 if (SWIG_arg_fail(1)) SWIG_fail;
5657 {
5658 arg2 = (int)(SWIG_As_int(obj1));
5659 if (SWIG_arg_fail(2)) SWIG_fail;
5660 }
5661 {
5662 arg3 = (int)(SWIG_As_int(obj2));
5663 if (SWIG_arg_fail(3)) SWIG_fail;
5664 }
5665 {
5666 PyThreadState* __tstate = wxPyBeginAllowThreads();
5667 {
5668 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5669 result = (wxRect *) &_result_ref;
5670 }
5671
5672 wxPyEndAllowThreads(__tstate);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5676 return resultobj;
5677 fail:
5678 return NULL;
5679 }
5680
5681
5682 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5683 PyObject *resultobj;
5684 wxRect *arg1 = (wxRect *) 0 ;
5685 int arg2 ;
5686 int arg3 ;
5687 wxRect *result;
5688 PyObject * obj0 = 0 ;
5689 PyObject * obj1 = 0 ;
5690 PyObject * obj2 = 0 ;
5691 char *kwnames[] = {
5692 (char *) "self",(char *) "dx",(char *) "dy", NULL
5693 };
5694
5695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5697 if (SWIG_arg_fail(1)) SWIG_fail;
5698 {
5699 arg2 = (int)(SWIG_As_int(obj1));
5700 if (SWIG_arg_fail(2)) SWIG_fail;
5701 }
5702 {
5703 arg3 = (int)(SWIG_As_int(obj2));
5704 if (SWIG_arg_fail(3)) SWIG_fail;
5705 }
5706 {
5707 PyThreadState* __tstate = wxPyBeginAllowThreads();
5708 {
5709 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5710 result = (wxRect *) &_result_ref;
5711 }
5712
5713 wxPyEndAllowThreads(__tstate);
5714 if (PyErr_Occurred()) SWIG_fail;
5715 }
5716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5717 return resultobj;
5718 fail:
5719 return NULL;
5720 }
5721
5722
5723 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5724 PyObject *resultobj;
5725 wxRect *arg1 = (wxRect *) 0 ;
5726 int arg2 ;
5727 int arg3 ;
5728 PyObject * obj0 = 0 ;
5729 PyObject * obj1 = 0 ;
5730 PyObject * obj2 = 0 ;
5731 char *kwnames[] = {
5732 (char *) "self",(char *) "dx",(char *) "dy", NULL
5733 };
5734
5735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5737 if (SWIG_arg_fail(1)) SWIG_fail;
5738 {
5739 arg2 = (int)(SWIG_As_int(obj1));
5740 if (SWIG_arg_fail(2)) SWIG_fail;
5741 }
5742 {
5743 arg3 = (int)(SWIG_As_int(obj2));
5744 if (SWIG_arg_fail(3)) SWIG_fail;
5745 }
5746 {
5747 PyThreadState* __tstate = wxPyBeginAllowThreads();
5748 (arg1)->Offset(arg2,arg3);
5749
5750 wxPyEndAllowThreads(__tstate);
5751 if (PyErr_Occurred()) SWIG_fail;
5752 }
5753 Py_INCREF(Py_None); resultobj = Py_None;
5754 return resultobj;
5755 fail:
5756 return NULL;
5757 }
5758
5759
5760 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5761 PyObject *resultobj;
5762 wxRect *arg1 = (wxRect *) 0 ;
5763 wxPoint *arg2 = 0 ;
5764 wxPoint temp2 ;
5765 PyObject * obj0 = 0 ;
5766 PyObject * obj1 = 0 ;
5767 char *kwnames[] = {
5768 (char *) "self",(char *) "pt", NULL
5769 };
5770
5771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5773 if (SWIG_arg_fail(1)) SWIG_fail;
5774 {
5775 arg2 = &temp2;
5776 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5777 }
5778 {
5779 PyThreadState* __tstate = wxPyBeginAllowThreads();
5780 (arg1)->Offset((wxPoint const &)*arg2);
5781
5782 wxPyEndAllowThreads(__tstate);
5783 if (PyErr_Occurred()) SWIG_fail;
5784 }
5785 Py_INCREF(Py_None); resultobj = Py_None;
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5793 PyObject *resultobj;
5794 wxRect *arg1 = (wxRect *) 0 ;
5795 wxRect *arg2 = 0 ;
5796 wxRect result;
5797 wxRect temp2 ;
5798 PyObject * obj0 = 0 ;
5799 PyObject * obj1 = 0 ;
5800 char *kwnames[] = {
5801 (char *) "self",(char *) "rect", NULL
5802 };
5803
5804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5806 if (SWIG_arg_fail(1)) SWIG_fail;
5807 {
5808 arg2 = &temp2;
5809 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5810 }
5811 {
5812 PyThreadState* __tstate = wxPyBeginAllowThreads();
5813 result = (arg1)->Intersect((wxRect const &)*arg2);
5814
5815 wxPyEndAllowThreads(__tstate);
5816 if (PyErr_Occurred()) SWIG_fail;
5817 }
5818 {
5819 wxRect * resultptr;
5820 resultptr = new wxRect((wxRect &)(result));
5821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5822 }
5823 return resultobj;
5824 fail:
5825 return NULL;
5826 }
5827
5828
5829 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5830 PyObject *resultobj;
5831 wxRect *arg1 = (wxRect *) 0 ;
5832 wxRect *arg2 = 0 ;
5833 wxRect result;
5834 wxRect temp2 ;
5835 PyObject * obj0 = 0 ;
5836 PyObject * obj1 = 0 ;
5837 char *kwnames[] = {
5838 (char *) "self",(char *) "rect", NULL
5839 };
5840
5841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5843 if (SWIG_arg_fail(1)) SWIG_fail;
5844 {
5845 arg2 = &temp2;
5846 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5847 }
5848 {
5849 PyThreadState* __tstate = wxPyBeginAllowThreads();
5850 result = (arg1)->Union((wxRect const &)*arg2);
5851
5852 wxPyEndAllowThreads(__tstate);
5853 if (PyErr_Occurred()) SWIG_fail;
5854 }
5855 {
5856 wxRect * resultptr;
5857 resultptr = new wxRect((wxRect &)(result));
5858 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5859 }
5860 return resultobj;
5861 fail:
5862 return NULL;
5863 }
5864
5865
5866 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5867 PyObject *resultobj;
5868 wxRect *arg1 = (wxRect *) 0 ;
5869 wxRect *arg2 = 0 ;
5870 wxRect result;
5871 wxRect temp2 ;
5872 PyObject * obj0 = 0 ;
5873 PyObject * obj1 = 0 ;
5874 char *kwnames[] = {
5875 (char *) "self",(char *) "rect", NULL
5876 };
5877
5878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5880 if (SWIG_arg_fail(1)) SWIG_fail;
5881 {
5882 arg2 = &temp2;
5883 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5884 }
5885 {
5886 PyThreadState* __tstate = wxPyBeginAllowThreads();
5887 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5888
5889 wxPyEndAllowThreads(__tstate);
5890 if (PyErr_Occurred()) SWIG_fail;
5891 }
5892 {
5893 wxRect * resultptr;
5894 resultptr = new wxRect((wxRect &)(result));
5895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5896 }
5897 return resultobj;
5898 fail:
5899 return NULL;
5900 }
5901
5902
5903 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5904 PyObject *resultobj;
5905 wxRect *arg1 = (wxRect *) 0 ;
5906 wxRect *arg2 = 0 ;
5907 wxRect *result;
5908 wxRect temp2 ;
5909 PyObject * obj0 = 0 ;
5910 PyObject * obj1 = 0 ;
5911 char *kwnames[] = {
5912 (char *) "self",(char *) "rect", NULL
5913 };
5914
5915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5917 if (SWIG_arg_fail(1)) SWIG_fail;
5918 {
5919 arg2 = &temp2;
5920 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5921 }
5922 {
5923 PyThreadState* __tstate = wxPyBeginAllowThreads();
5924 {
5925 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5926 result = (wxRect *) &_result_ref;
5927 }
5928
5929 wxPyEndAllowThreads(__tstate);
5930 if (PyErr_Occurred()) SWIG_fail;
5931 }
5932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5933 return resultobj;
5934 fail:
5935 return NULL;
5936 }
5937
5938
5939 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5940 PyObject *resultobj;
5941 wxRect *arg1 = (wxRect *) 0 ;
5942 wxRect *arg2 = 0 ;
5943 bool result;
5944 wxRect temp2 ;
5945 PyObject * obj0 = 0 ;
5946 PyObject * obj1 = 0 ;
5947 char *kwnames[] = {
5948 (char *) "self",(char *) "rect", NULL
5949 };
5950
5951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5953 if (SWIG_arg_fail(1)) SWIG_fail;
5954 {
5955 arg2 = &temp2;
5956 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5957 }
5958 {
5959 PyThreadState* __tstate = wxPyBeginAllowThreads();
5960 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5961
5962 wxPyEndAllowThreads(__tstate);
5963 if (PyErr_Occurred()) SWIG_fail;
5964 }
5965 {
5966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5967 }
5968 return resultobj;
5969 fail:
5970 return NULL;
5971 }
5972
5973
5974 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5975 PyObject *resultobj;
5976 wxRect *arg1 = (wxRect *) 0 ;
5977 wxRect *arg2 = 0 ;
5978 bool result;
5979 wxRect temp2 ;
5980 PyObject * obj0 = 0 ;
5981 PyObject * obj1 = 0 ;
5982 char *kwnames[] = {
5983 (char *) "self",(char *) "rect", NULL
5984 };
5985
5986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5988 if (SWIG_arg_fail(1)) SWIG_fail;
5989 {
5990 arg2 = &temp2;
5991 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5992 }
5993 {
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5996
5997 wxPyEndAllowThreads(__tstate);
5998 if (PyErr_Occurred()) SWIG_fail;
5999 }
6000 {
6001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6002 }
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj;
6011 wxRect *arg1 = (wxRect *) 0 ;
6012 int arg2 ;
6013 int arg3 ;
6014 bool result;
6015 PyObject * obj0 = 0 ;
6016 PyObject * obj1 = 0 ;
6017 PyObject * obj2 = 0 ;
6018 char *kwnames[] = {
6019 (char *) "self",(char *) "x",(char *) "y", NULL
6020 };
6021
6022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6024 if (SWIG_arg_fail(1)) SWIG_fail;
6025 {
6026 arg2 = (int)(SWIG_As_int(obj1));
6027 if (SWIG_arg_fail(2)) SWIG_fail;
6028 }
6029 {
6030 arg3 = (int)(SWIG_As_int(obj2));
6031 if (SWIG_arg_fail(3)) SWIG_fail;
6032 }
6033 {
6034 PyThreadState* __tstate = wxPyBeginAllowThreads();
6035 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6036
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 {
6041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6042 }
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj;
6051 wxRect *arg1 = (wxRect *) 0 ;
6052 wxPoint *arg2 = 0 ;
6053 bool result;
6054 wxPoint temp2 ;
6055 PyObject * obj0 = 0 ;
6056 PyObject * obj1 = 0 ;
6057 char *kwnames[] = {
6058 (char *) "self",(char *) "pt", NULL
6059 };
6060
6061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6063 if (SWIG_arg_fail(1)) SWIG_fail;
6064 {
6065 arg2 = &temp2;
6066 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6067 }
6068 {
6069 PyThreadState* __tstate = wxPyBeginAllowThreads();
6070 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6071
6072 wxPyEndAllowThreads(__tstate);
6073 if (PyErr_Occurred()) SWIG_fail;
6074 }
6075 {
6076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6077 }
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj;
6086 wxRect *arg1 = (wxRect *) 0 ;
6087 wxRect *arg2 = 0 ;
6088 bool result;
6089 wxRect temp2 ;
6090 PyObject * obj0 = 0 ;
6091 PyObject * obj1 = 0 ;
6092 char *kwnames[] = {
6093 (char *) "self",(char *) "rect", NULL
6094 };
6095
6096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6098 if (SWIG_arg_fail(1)) SWIG_fail;
6099 {
6100 arg2 = &temp2;
6101 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6102 }
6103 {
6104 PyThreadState* __tstate = wxPyBeginAllowThreads();
6105 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6106
6107 wxPyEndAllowThreads(__tstate);
6108 if (PyErr_Occurred()) SWIG_fail;
6109 }
6110 {
6111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6112 }
6113 return resultobj;
6114 fail:
6115 return NULL;
6116 }
6117
6118
6119 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6120 PyObject *resultobj;
6121 wxRect *arg1 = (wxRect *) 0 ;
6122 int arg2 ;
6123 PyObject * obj0 = 0 ;
6124 PyObject * obj1 = 0 ;
6125 char *kwnames[] = {
6126 (char *) "self",(char *) "x", NULL
6127 };
6128
6129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6131 if (SWIG_arg_fail(1)) SWIG_fail;
6132 {
6133 arg2 = (int)(SWIG_As_int(obj1));
6134 if (SWIG_arg_fail(2)) SWIG_fail;
6135 }
6136 if (arg1) (arg1)->x = arg2;
6137
6138 Py_INCREF(Py_None); resultobj = Py_None;
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj;
6147 wxRect *arg1 = (wxRect *) 0 ;
6148 int result;
6149 PyObject * obj0 = 0 ;
6150 char *kwnames[] = {
6151 (char *) "self", NULL
6152 };
6153
6154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6156 if (SWIG_arg_fail(1)) SWIG_fail;
6157 result = (int) ((arg1)->x);
6158
6159 {
6160 resultobj = SWIG_From_int((int)(result));
6161 }
6162 return resultobj;
6163 fail:
6164 return NULL;
6165 }
6166
6167
6168 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj;
6170 wxRect *arg1 = (wxRect *) 0 ;
6171 int arg2 ;
6172 PyObject * obj0 = 0 ;
6173 PyObject * obj1 = 0 ;
6174 char *kwnames[] = {
6175 (char *) "self",(char *) "y", NULL
6176 };
6177
6178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6180 if (SWIG_arg_fail(1)) SWIG_fail;
6181 {
6182 arg2 = (int)(SWIG_As_int(obj1));
6183 if (SWIG_arg_fail(2)) SWIG_fail;
6184 }
6185 if (arg1) (arg1)->y = arg2;
6186
6187 Py_INCREF(Py_None); resultobj = Py_None;
6188 return resultobj;
6189 fail:
6190 return NULL;
6191 }
6192
6193
6194 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6195 PyObject *resultobj;
6196 wxRect *arg1 = (wxRect *) 0 ;
6197 int result;
6198 PyObject * obj0 = 0 ;
6199 char *kwnames[] = {
6200 (char *) "self", NULL
6201 };
6202
6203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6205 if (SWIG_arg_fail(1)) SWIG_fail;
6206 result = (int) ((arg1)->y);
6207
6208 {
6209 resultobj = SWIG_From_int((int)(result));
6210 }
6211 return resultobj;
6212 fail:
6213 return NULL;
6214 }
6215
6216
6217 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6218 PyObject *resultobj;
6219 wxRect *arg1 = (wxRect *) 0 ;
6220 int arg2 ;
6221 PyObject * obj0 = 0 ;
6222 PyObject * obj1 = 0 ;
6223 char *kwnames[] = {
6224 (char *) "self",(char *) "width", NULL
6225 };
6226
6227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6229 if (SWIG_arg_fail(1)) SWIG_fail;
6230 {
6231 arg2 = (int)(SWIG_As_int(obj1));
6232 if (SWIG_arg_fail(2)) SWIG_fail;
6233 }
6234 if (arg1) (arg1)->width = arg2;
6235
6236 Py_INCREF(Py_None); resultobj = Py_None;
6237 return resultobj;
6238 fail:
6239 return NULL;
6240 }
6241
6242
6243 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6244 PyObject *resultobj;
6245 wxRect *arg1 = (wxRect *) 0 ;
6246 int result;
6247 PyObject * obj0 = 0 ;
6248 char *kwnames[] = {
6249 (char *) "self", NULL
6250 };
6251
6252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6254 if (SWIG_arg_fail(1)) SWIG_fail;
6255 result = (int) ((arg1)->width);
6256
6257 {
6258 resultobj = SWIG_From_int((int)(result));
6259 }
6260 return resultobj;
6261 fail:
6262 return NULL;
6263 }
6264
6265
6266 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6267 PyObject *resultobj;
6268 wxRect *arg1 = (wxRect *) 0 ;
6269 int arg2 ;
6270 PyObject * obj0 = 0 ;
6271 PyObject * obj1 = 0 ;
6272 char *kwnames[] = {
6273 (char *) "self",(char *) "height", NULL
6274 };
6275
6276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6278 if (SWIG_arg_fail(1)) SWIG_fail;
6279 {
6280 arg2 = (int)(SWIG_As_int(obj1));
6281 if (SWIG_arg_fail(2)) SWIG_fail;
6282 }
6283 if (arg1) (arg1)->height = arg2;
6284
6285 Py_INCREF(Py_None); resultobj = Py_None;
6286 return resultobj;
6287 fail:
6288 return NULL;
6289 }
6290
6291
6292 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6293 PyObject *resultobj;
6294 wxRect *arg1 = (wxRect *) 0 ;
6295 int result;
6296 PyObject * obj0 = 0 ;
6297 char *kwnames[] = {
6298 (char *) "self", NULL
6299 };
6300
6301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6303 if (SWIG_arg_fail(1)) SWIG_fail;
6304 result = (int) ((arg1)->height);
6305
6306 {
6307 resultobj = SWIG_From_int((int)(result));
6308 }
6309 return resultobj;
6310 fail:
6311 return NULL;
6312 }
6313
6314
6315 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6316 PyObject *resultobj;
6317 wxRect *arg1 = (wxRect *) 0 ;
6318 int arg2 = (int) 0 ;
6319 int arg3 = (int) 0 ;
6320 int arg4 = (int) 0 ;
6321 int arg5 = (int) 0 ;
6322 PyObject * obj0 = 0 ;
6323 PyObject * obj1 = 0 ;
6324 PyObject * obj2 = 0 ;
6325 PyObject * obj3 = 0 ;
6326 PyObject * obj4 = 0 ;
6327 char *kwnames[] = {
6328 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6329 };
6330
6331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6333 if (SWIG_arg_fail(1)) SWIG_fail;
6334 if (obj1) {
6335 {
6336 arg2 = (int)(SWIG_As_int(obj1));
6337 if (SWIG_arg_fail(2)) SWIG_fail;
6338 }
6339 }
6340 if (obj2) {
6341 {
6342 arg3 = (int)(SWIG_As_int(obj2));
6343 if (SWIG_arg_fail(3)) SWIG_fail;
6344 }
6345 }
6346 if (obj3) {
6347 {
6348 arg4 = (int)(SWIG_As_int(obj3));
6349 if (SWIG_arg_fail(4)) SWIG_fail;
6350 }
6351 }
6352 if (obj4) {
6353 {
6354 arg5 = (int)(SWIG_As_int(obj4));
6355 if (SWIG_arg_fail(5)) SWIG_fail;
6356 }
6357 }
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6361
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 Py_INCREF(Py_None); resultobj = Py_None;
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 PyObject *result;
6376 PyObject * obj0 = 0 ;
6377 char *kwnames[] = {
6378 (char *) "self", NULL
6379 };
6380
6381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6383 if (SWIG_arg_fail(1)) SWIG_fail;
6384 {
6385 PyThreadState* __tstate = wxPyBeginAllowThreads();
6386 result = (PyObject *)wxRect_Get(arg1);
6387
6388 wxPyEndAllowThreads(__tstate);
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 resultobj = result;
6392 return resultobj;
6393 fail:
6394 return NULL;
6395 }
6396
6397
6398 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6399 PyObject *obj;
6400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6401 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6402 Py_INCREF(obj);
6403 return Py_BuildValue((char *)"");
6404 }
6405 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6406 PyObject *resultobj;
6407 wxRect *arg1 = (wxRect *) 0 ;
6408 wxRect *arg2 = (wxRect *) 0 ;
6409 PyObject *result;
6410 PyObject * obj0 = 0 ;
6411 PyObject * obj1 = 0 ;
6412 char *kwnames[] = {
6413 (char *) "r1",(char *) "r2", NULL
6414 };
6415
6416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6418 if (SWIG_arg_fail(1)) SWIG_fail;
6419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6420 if (SWIG_arg_fail(2)) SWIG_fail;
6421 {
6422 if (!wxPyCheckForApp()) SWIG_fail;
6423 PyThreadState* __tstate = wxPyBeginAllowThreads();
6424 result = (PyObject *)wxIntersectRect(arg1,arg2);
6425
6426 wxPyEndAllowThreads(__tstate);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 resultobj = result;
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
6436 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6437 PyObject *resultobj;
6438 double arg1 = (double) 0.0 ;
6439 double arg2 = (double) 0.0 ;
6440 wxPoint2D *result;
6441 PyObject * obj0 = 0 ;
6442 PyObject * obj1 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "x",(char *) "y", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6448 if (obj0) {
6449 {
6450 arg1 = (double)(SWIG_As_double(obj0));
6451 if (SWIG_arg_fail(1)) SWIG_fail;
6452 }
6453 }
6454 if (obj1) {
6455 {
6456 arg2 = (double)(SWIG_As_double(obj1));
6457 if (SWIG_arg_fail(2)) SWIG_fail;
6458 }
6459 }
6460 {
6461 PyThreadState* __tstate = wxPyBeginAllowThreads();
6462 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6463
6464 wxPyEndAllowThreads(__tstate);
6465 if (PyErr_Occurred()) SWIG_fail;
6466 }
6467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6468 return resultobj;
6469 fail:
6470 return NULL;
6471 }
6472
6473
6474 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6475 PyObject *resultobj;
6476 wxPoint2D *arg1 = 0 ;
6477 wxPoint2D *result;
6478 wxPoint2D temp1 ;
6479 PyObject * obj0 = 0 ;
6480 char *kwnames[] = {
6481 (char *) "pt", NULL
6482 };
6483
6484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6485 {
6486 arg1 = &temp1;
6487 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6488 }
6489 {
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6492
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj;
6505 wxPoint *arg1 = 0 ;
6506 wxPoint2D *result;
6507 wxPoint temp1 ;
6508 PyObject * obj0 = 0 ;
6509 char *kwnames[] = {
6510 (char *) "pt", NULL
6511 };
6512
6513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6514 {
6515 arg1 = &temp1;
6516 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6517 }
6518 {
6519 PyThreadState* __tstate = wxPyBeginAllowThreads();
6520 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6521
6522 wxPyEndAllowThreads(__tstate);
6523 if (PyErr_Occurred()) SWIG_fail;
6524 }
6525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6526 return resultobj;
6527 fail:
6528 return NULL;
6529 }
6530
6531
6532 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6533 PyObject *resultobj;
6534 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6535 int *arg2 = (int *) 0 ;
6536 int *arg3 = (int *) 0 ;
6537 int temp2 ;
6538 int res2 = 0 ;
6539 int temp3 ;
6540 int res3 = 0 ;
6541 PyObject * obj0 = 0 ;
6542 char *kwnames[] = {
6543 (char *) "self", NULL
6544 };
6545
6546 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6547 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6550 if (SWIG_arg_fail(1)) SWIG_fail;
6551 {
6552 PyThreadState* __tstate = wxPyBeginAllowThreads();
6553 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6554
6555 wxPyEndAllowThreads(__tstate);
6556 if (PyErr_Occurred()) SWIG_fail;
6557 }
6558 Py_INCREF(Py_None); resultobj = Py_None;
6559 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6560 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6561 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6562 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj;
6571 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6572 int *arg2 = (int *) 0 ;
6573 int *arg3 = (int *) 0 ;
6574 int temp2 ;
6575 int res2 = 0 ;
6576 int temp3 ;
6577 int res3 = 0 ;
6578 PyObject * obj0 = 0 ;
6579 char *kwnames[] = {
6580 (char *) "self", NULL
6581 };
6582
6583 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6584 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6587 if (SWIG_arg_fail(1)) SWIG_fail;
6588 {
6589 PyThreadState* __tstate = wxPyBeginAllowThreads();
6590 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6591
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 Py_INCREF(Py_None); resultobj = Py_None;
6596 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6597 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6598 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6599 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6607 PyObject *resultobj;
6608 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6609 double result;
6610 PyObject * obj0 = 0 ;
6611 char *kwnames[] = {
6612 (char *) "self", NULL
6613 };
6614
6615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6617 if (SWIG_arg_fail(1)) SWIG_fail;
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6621
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 {
6626 resultobj = SWIG_From_double((double)(result));
6627 }
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj;
6636 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6637 double result;
6638 PyObject * obj0 = 0 ;
6639 char *kwnames[] = {
6640 (char *) "self", NULL
6641 };
6642
6643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6645 if (SWIG_arg_fail(1)) SWIG_fail;
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6649
6650 wxPyEndAllowThreads(__tstate);
6651 if (PyErr_Occurred()) SWIG_fail;
6652 }
6653 {
6654 resultobj = SWIG_From_double((double)(result));
6655 }
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6663 PyObject *resultobj;
6664 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6665 double arg2 ;
6666 PyObject * obj0 = 0 ;
6667 PyObject * obj1 = 0 ;
6668 char *kwnames[] = {
6669 (char *) "self",(char *) "length", NULL
6670 };
6671
6672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6674 if (SWIG_arg_fail(1)) SWIG_fail;
6675 {
6676 arg2 = (double)(SWIG_As_double(obj1));
6677 if (SWIG_arg_fail(2)) SWIG_fail;
6678 }
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 (arg1)->SetVectorLength(arg2);
6682
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 Py_INCREF(Py_None); resultobj = Py_None;
6687 return resultobj;
6688 fail:
6689 return NULL;
6690 }
6691
6692
6693 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6694 PyObject *resultobj;
6695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6696 double arg2 ;
6697 PyObject * obj0 = 0 ;
6698 PyObject * obj1 = 0 ;
6699 char *kwnames[] = {
6700 (char *) "self",(char *) "degrees", NULL
6701 };
6702
6703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6705 if (SWIG_arg_fail(1)) SWIG_fail;
6706 {
6707 arg2 = (double)(SWIG_As_double(obj1));
6708 if (SWIG_arg_fail(2)) SWIG_fail;
6709 }
6710 {
6711 PyThreadState* __tstate = wxPyBeginAllowThreads();
6712 (arg1)->SetVectorAngle(arg2);
6713
6714 wxPyEndAllowThreads(__tstate);
6715 if (PyErr_Occurred()) SWIG_fail;
6716 }
6717 Py_INCREF(Py_None); resultobj = Py_None;
6718 return resultobj;
6719 fail:
6720 return NULL;
6721 }
6722
6723
6724 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6725 PyObject *resultobj;
6726 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6727 wxPoint2D *arg2 = 0 ;
6728 double result;
6729 wxPoint2D temp2 ;
6730 PyObject * obj0 = 0 ;
6731 PyObject * obj1 = 0 ;
6732 char *kwnames[] = {
6733 (char *) "self",(char *) "pt", NULL
6734 };
6735
6736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6738 if (SWIG_arg_fail(1)) SWIG_fail;
6739 {
6740 arg2 = &temp2;
6741 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6742 }
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6746
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 {
6751 resultobj = SWIG_From_double((double)(result));
6752 }
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6760 PyObject *resultobj;
6761 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6762 wxPoint2D *arg2 = 0 ;
6763 double result;
6764 wxPoint2D temp2 ;
6765 PyObject * obj0 = 0 ;
6766 PyObject * obj1 = 0 ;
6767 char *kwnames[] = {
6768 (char *) "self",(char *) "pt", NULL
6769 };
6770
6771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6773 if (SWIG_arg_fail(1)) SWIG_fail;
6774 {
6775 arg2 = &temp2;
6776 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6777 }
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6781
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 {
6786 resultobj = SWIG_From_double((double)(result));
6787 }
6788 return resultobj;
6789 fail:
6790 return NULL;
6791 }
6792
6793
6794 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6795 PyObject *resultobj;
6796 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6797 wxPoint2D *arg2 = 0 ;
6798 double result;
6799 wxPoint2D temp2 ;
6800 PyObject * obj0 = 0 ;
6801 PyObject * obj1 = 0 ;
6802 char *kwnames[] = {
6803 (char *) "self",(char *) "vec", NULL
6804 };
6805
6806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6808 if (SWIG_arg_fail(1)) SWIG_fail;
6809 {
6810 arg2 = &temp2;
6811 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6812 }
6813 {
6814 PyThreadState* __tstate = wxPyBeginAllowThreads();
6815 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6816
6817 wxPyEndAllowThreads(__tstate);
6818 if (PyErr_Occurred()) SWIG_fail;
6819 }
6820 {
6821 resultobj = SWIG_From_double((double)(result));
6822 }
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6830 PyObject *resultobj;
6831 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6832 wxPoint2D *arg2 = 0 ;
6833 double result;
6834 wxPoint2D temp2 ;
6835 PyObject * obj0 = 0 ;
6836 PyObject * obj1 = 0 ;
6837 char *kwnames[] = {
6838 (char *) "self",(char *) "vec", NULL
6839 };
6840
6841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6843 if (SWIG_arg_fail(1)) SWIG_fail;
6844 {
6845 arg2 = &temp2;
6846 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6847 }
6848 {
6849 PyThreadState* __tstate = wxPyBeginAllowThreads();
6850 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6851
6852 wxPyEndAllowThreads(__tstate);
6853 if (PyErr_Occurred()) SWIG_fail;
6854 }
6855 {
6856 resultobj = SWIG_From_double((double)(result));
6857 }
6858 return resultobj;
6859 fail:
6860 return NULL;
6861 }
6862
6863
6864 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6865 PyObject *resultobj;
6866 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6867 wxPoint2D result;
6868 PyObject * obj0 = 0 ;
6869 char *kwnames[] = {
6870 (char *) "self", NULL
6871 };
6872
6873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6875 if (SWIG_arg_fail(1)) SWIG_fail;
6876 {
6877 PyThreadState* __tstate = wxPyBeginAllowThreads();
6878 result = (arg1)->operator -();
6879
6880 wxPyEndAllowThreads(__tstate);
6881 if (PyErr_Occurred()) SWIG_fail;
6882 }
6883 {
6884 wxPoint2D * resultptr;
6885 resultptr = new wxPoint2D((wxPoint2D &)(result));
6886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6887 }
6888 return resultobj;
6889 fail:
6890 return NULL;
6891 }
6892
6893
6894 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6895 PyObject *resultobj;
6896 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6897 wxPoint2D *arg2 = 0 ;
6898 wxPoint2D *result;
6899 wxPoint2D temp2 ;
6900 PyObject * obj0 = 0 ;
6901 PyObject * obj1 = 0 ;
6902 char *kwnames[] = {
6903 (char *) "self",(char *) "pt", NULL
6904 };
6905
6906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6908 if (SWIG_arg_fail(1)) SWIG_fail;
6909 {
6910 arg2 = &temp2;
6911 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6912 }
6913 {
6914 PyThreadState* __tstate = wxPyBeginAllowThreads();
6915 {
6916 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6917 result = (wxPoint2D *) &_result_ref;
6918 }
6919
6920 wxPyEndAllowThreads(__tstate);
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj;
6932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6933 wxPoint2D *arg2 = 0 ;
6934 wxPoint2D *result;
6935 wxPoint2D temp2 ;
6936 PyObject * obj0 = 0 ;
6937 PyObject * obj1 = 0 ;
6938 char *kwnames[] = {
6939 (char *) "self",(char *) "pt", NULL
6940 };
6941
6942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6944 if (SWIG_arg_fail(1)) SWIG_fail;
6945 {
6946 arg2 = &temp2;
6947 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6948 }
6949 {
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 {
6952 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6953 result = (wxPoint2D *) &_result_ref;
6954 }
6955
6956 wxPyEndAllowThreads(__tstate);
6957 if (PyErr_Occurred()) SWIG_fail;
6958 }
6959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6960 return resultobj;
6961 fail:
6962 return NULL;
6963 }
6964
6965
6966 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6967 PyObject *resultobj;
6968 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6969 wxPoint2D *arg2 = 0 ;
6970 wxPoint2D *result;
6971 wxPoint2D temp2 ;
6972 PyObject * obj0 = 0 ;
6973 PyObject * obj1 = 0 ;
6974 char *kwnames[] = {
6975 (char *) "self",(char *) "pt", NULL
6976 };
6977
6978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6980 if (SWIG_arg_fail(1)) SWIG_fail;
6981 {
6982 arg2 = &temp2;
6983 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6984 }
6985 {
6986 PyThreadState* __tstate = wxPyBeginAllowThreads();
6987 {
6988 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6989 result = (wxPoint2D *) &_result_ref;
6990 }
6991
6992 wxPyEndAllowThreads(__tstate);
6993 if (PyErr_Occurred()) SWIG_fail;
6994 }
6995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6996 return resultobj;
6997 fail:
6998 return NULL;
6999 }
7000
7001
7002 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7003 PyObject *resultobj;
7004 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7005 wxPoint2D *arg2 = 0 ;
7006 wxPoint2D *result;
7007 wxPoint2D temp2 ;
7008 PyObject * obj0 = 0 ;
7009 PyObject * obj1 = 0 ;
7010 char *kwnames[] = {
7011 (char *) "self",(char *) "pt", NULL
7012 };
7013
7014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7016 if (SWIG_arg_fail(1)) SWIG_fail;
7017 {
7018 arg2 = &temp2;
7019 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7020 }
7021 {
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 {
7024 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7025 result = (wxPoint2D *) &_result_ref;
7026 }
7027
7028 wxPyEndAllowThreads(__tstate);
7029 if (PyErr_Occurred()) SWIG_fail;
7030 }
7031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7039 PyObject *resultobj;
7040 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7041 wxPoint2D *arg2 = 0 ;
7042 bool result;
7043 wxPoint2D temp2 ;
7044 PyObject * obj0 = 0 ;
7045 PyObject * obj1 = 0 ;
7046 char *kwnames[] = {
7047 (char *) "self",(char *) "pt", NULL
7048 };
7049
7050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7052 if (SWIG_arg_fail(1)) SWIG_fail;
7053 {
7054 arg2 = &temp2;
7055 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7056 }
7057 {
7058 PyThreadState* __tstate = wxPyBeginAllowThreads();
7059 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7060
7061 wxPyEndAllowThreads(__tstate);
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 {
7065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7066 }
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj;
7075 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7076 wxPoint2D *arg2 = 0 ;
7077 bool result;
7078 wxPoint2D temp2 ;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 char *kwnames[] = {
7082 (char *) "self",(char *) "pt", NULL
7083 };
7084
7085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7087 if (SWIG_arg_fail(1)) SWIG_fail;
7088 {
7089 arg2 = &temp2;
7090 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7091 }
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7095
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 {
7100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7101 }
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj;
7110 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7111 double arg2 ;
7112 PyObject * obj0 = 0 ;
7113 PyObject * obj1 = 0 ;
7114 char *kwnames[] = {
7115 (char *) "self",(char *) "m_x", NULL
7116 };
7117
7118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7120 if (SWIG_arg_fail(1)) SWIG_fail;
7121 {
7122 arg2 = (double)(SWIG_As_double(obj1));
7123 if (SWIG_arg_fail(2)) SWIG_fail;
7124 }
7125 if (arg1) (arg1)->m_x = arg2;
7126
7127 Py_INCREF(Py_None); resultobj = Py_None;
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj;
7136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7137 double result;
7138 PyObject * obj0 = 0 ;
7139 char *kwnames[] = {
7140 (char *) "self", NULL
7141 };
7142
7143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7145 if (SWIG_arg_fail(1)) SWIG_fail;
7146 result = (double) ((arg1)->m_x);
7147
7148 {
7149 resultobj = SWIG_From_double((double)(result));
7150 }
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj;
7159 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7160 double arg2 ;
7161 PyObject * obj0 = 0 ;
7162 PyObject * obj1 = 0 ;
7163 char *kwnames[] = {
7164 (char *) "self",(char *) "m_y", NULL
7165 };
7166
7167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7169 if (SWIG_arg_fail(1)) SWIG_fail;
7170 {
7171 arg2 = (double)(SWIG_As_double(obj1));
7172 if (SWIG_arg_fail(2)) SWIG_fail;
7173 }
7174 if (arg1) (arg1)->m_y = arg2;
7175
7176 Py_INCREF(Py_None); resultobj = Py_None;
7177 return resultobj;
7178 fail:
7179 return NULL;
7180 }
7181
7182
7183 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7184 PyObject *resultobj;
7185 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7186 double result;
7187 PyObject * obj0 = 0 ;
7188 char *kwnames[] = {
7189 (char *) "self", NULL
7190 };
7191
7192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7194 if (SWIG_arg_fail(1)) SWIG_fail;
7195 result = (double) ((arg1)->m_y);
7196
7197 {
7198 resultobj = SWIG_From_double((double)(result));
7199 }
7200 return resultobj;
7201 fail:
7202 return NULL;
7203 }
7204
7205
7206 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7207 PyObject *resultobj;
7208 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7209 double arg2 = (double) 0 ;
7210 double arg3 = (double) 0 ;
7211 PyObject * obj0 = 0 ;
7212 PyObject * obj1 = 0 ;
7213 PyObject * obj2 = 0 ;
7214 char *kwnames[] = {
7215 (char *) "self",(char *) "x",(char *) "y", NULL
7216 };
7217
7218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7220 if (SWIG_arg_fail(1)) SWIG_fail;
7221 if (obj1) {
7222 {
7223 arg2 = (double)(SWIG_As_double(obj1));
7224 if (SWIG_arg_fail(2)) SWIG_fail;
7225 }
7226 }
7227 if (obj2) {
7228 {
7229 arg3 = (double)(SWIG_As_double(obj2));
7230 if (SWIG_arg_fail(3)) SWIG_fail;
7231 }
7232 }
7233 {
7234 PyThreadState* __tstate = wxPyBeginAllowThreads();
7235 wxPoint2D_Set(arg1,arg2,arg3);
7236
7237 wxPyEndAllowThreads(__tstate);
7238 if (PyErr_Occurred()) SWIG_fail;
7239 }
7240 Py_INCREF(Py_None); resultobj = Py_None;
7241 return resultobj;
7242 fail:
7243 return NULL;
7244 }
7245
7246
7247 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7248 PyObject *resultobj;
7249 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7250 PyObject *result;
7251 PyObject * obj0 = 0 ;
7252 char *kwnames[] = {
7253 (char *) "self", NULL
7254 };
7255
7256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7258 if (SWIG_arg_fail(1)) SWIG_fail;
7259 {
7260 PyThreadState* __tstate = wxPyBeginAllowThreads();
7261 result = (PyObject *)wxPoint2D_Get(arg1);
7262
7263 wxPyEndAllowThreads(__tstate);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = result;
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7274 PyObject *obj;
7275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7276 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7277 Py_INCREF(obj);
7278 return Py_BuildValue((char *)"");
7279 }
7280 static int _wrap_DefaultPosition_set(PyObject *) {
7281 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7282 return 1;
7283 }
7284
7285
7286 static PyObject *_wrap_DefaultPosition_get(void) {
7287 PyObject *pyobj;
7288
7289 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7290 return pyobj;
7291 }
7292
7293
7294 static int _wrap_DefaultSize_set(PyObject *) {
7295 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7296 return 1;
7297 }
7298
7299
7300 static PyObject *_wrap_DefaultSize_get(void) {
7301 PyObject *pyobj;
7302
7303 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7304 return pyobj;
7305 }
7306
7307
7308 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj;
7310 PyObject *arg1 = (PyObject *) 0 ;
7311 wxPyInputStream *result;
7312 PyObject * obj0 = 0 ;
7313 char *kwnames[] = {
7314 (char *) "p", NULL
7315 };
7316
7317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7318 arg1 = obj0;
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7322
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7334 PyObject *resultobj;
7335 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7336 PyObject * obj0 = 0 ;
7337 char *kwnames[] = {
7338 (char *) "self", NULL
7339 };
7340
7341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7343 if (SWIG_arg_fail(1)) SWIG_fail;
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 delete arg1;
7347
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 Py_INCREF(Py_None); resultobj = Py_None;
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7359 PyObject *resultobj;
7360 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7361 PyObject * obj0 = 0 ;
7362 char *kwnames[] = {
7363 (char *) "self", NULL
7364 };
7365
7366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7368 if (SWIG_arg_fail(1)) SWIG_fail;
7369 {
7370 PyThreadState* __tstate = wxPyBeginAllowThreads();
7371 (arg1)->close();
7372
7373 wxPyEndAllowThreads(__tstate);
7374 if (PyErr_Occurred()) SWIG_fail;
7375 }
7376 Py_INCREF(Py_None); resultobj = Py_None;
7377 return resultobj;
7378 fail:
7379 return NULL;
7380 }
7381
7382
7383 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7384 PyObject *resultobj;
7385 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7386 PyObject * obj0 = 0 ;
7387 char *kwnames[] = {
7388 (char *) "self", NULL
7389 };
7390
7391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7393 if (SWIG_arg_fail(1)) SWIG_fail;
7394 {
7395 PyThreadState* __tstate = wxPyBeginAllowThreads();
7396 (arg1)->flush();
7397
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 Py_INCREF(Py_None); resultobj = Py_None;
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7409 PyObject *resultobj;
7410 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7411 bool result;
7412 PyObject * obj0 = 0 ;
7413 char *kwnames[] = {
7414 (char *) "self", NULL
7415 };
7416
7417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7419 if (SWIG_arg_fail(1)) SWIG_fail;
7420 {
7421 PyThreadState* __tstate = wxPyBeginAllowThreads();
7422 result = (bool)(arg1)->eof();
7423
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 {
7428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7429 }
7430 return resultobj;
7431 fail:
7432 return NULL;
7433 }
7434
7435
7436 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7437 PyObject *resultobj;
7438 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7439 int arg2 = (int) -1 ;
7440 PyObject *result;
7441 PyObject * obj0 = 0 ;
7442 PyObject * obj1 = 0 ;
7443 char *kwnames[] = {
7444 (char *) "self",(char *) "size", NULL
7445 };
7446
7447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7449 if (SWIG_arg_fail(1)) SWIG_fail;
7450 if (obj1) {
7451 {
7452 arg2 = (int)(SWIG_As_int(obj1));
7453 if (SWIG_arg_fail(2)) SWIG_fail;
7454 }
7455 }
7456 {
7457 PyThreadState* __tstate = wxPyBeginAllowThreads();
7458 result = (PyObject *)(arg1)->read(arg2);
7459
7460 wxPyEndAllowThreads(__tstate);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 resultobj = result;
7464 return resultobj;
7465 fail:
7466 return NULL;
7467 }
7468
7469
7470 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7471 PyObject *resultobj;
7472 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7473 int arg2 = (int) -1 ;
7474 PyObject *result;
7475 PyObject * obj0 = 0 ;
7476 PyObject * obj1 = 0 ;
7477 char *kwnames[] = {
7478 (char *) "self",(char *) "size", NULL
7479 };
7480
7481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7483 if (SWIG_arg_fail(1)) SWIG_fail;
7484 if (obj1) {
7485 {
7486 arg2 = (int)(SWIG_As_int(obj1));
7487 if (SWIG_arg_fail(2)) SWIG_fail;
7488 }
7489 }
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 result = (PyObject *)(arg1)->readline(arg2);
7493
7494 wxPyEndAllowThreads(__tstate);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 resultobj = result;
7498 return resultobj;
7499 fail:
7500 return NULL;
7501 }
7502
7503
7504 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7505 PyObject *resultobj;
7506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7507 int arg2 = (int) -1 ;
7508 PyObject *result;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 char *kwnames[] = {
7512 (char *) "self",(char *) "sizehint", NULL
7513 };
7514
7515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7517 if (SWIG_arg_fail(1)) SWIG_fail;
7518 if (obj1) {
7519 {
7520 arg2 = (int)(SWIG_As_int(obj1));
7521 if (SWIG_arg_fail(2)) SWIG_fail;
7522 }
7523 }
7524 {
7525 PyThreadState* __tstate = wxPyBeginAllowThreads();
7526 result = (PyObject *)(arg1)->readlines(arg2);
7527
7528 wxPyEndAllowThreads(__tstate);
7529 if (PyErr_Occurred()) SWIG_fail;
7530 }
7531 resultobj = result;
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj;
7540 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7541 int arg2 ;
7542 int arg3 = (int) 0 ;
7543 PyObject * obj0 = 0 ;
7544 PyObject * obj1 = 0 ;
7545 PyObject * obj2 = 0 ;
7546 char *kwnames[] = {
7547 (char *) "self",(char *) "offset",(char *) "whence", NULL
7548 };
7549
7550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7552 if (SWIG_arg_fail(1)) SWIG_fail;
7553 {
7554 arg2 = (int)(SWIG_As_int(obj1));
7555 if (SWIG_arg_fail(2)) SWIG_fail;
7556 }
7557 if (obj2) {
7558 {
7559 arg3 = (int)(SWIG_As_int(obj2));
7560 if (SWIG_arg_fail(3)) SWIG_fail;
7561 }
7562 }
7563 {
7564 PyThreadState* __tstate = wxPyBeginAllowThreads();
7565 (arg1)->seek(arg2,arg3);
7566
7567 wxPyEndAllowThreads(__tstate);
7568 if (PyErr_Occurred()) SWIG_fail;
7569 }
7570 Py_INCREF(Py_None); resultobj = Py_None;
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7578 PyObject *resultobj;
7579 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7580 int result;
7581 PyObject * obj0 = 0 ;
7582 char *kwnames[] = {
7583 (char *) "self", NULL
7584 };
7585
7586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7588 if (SWIG_arg_fail(1)) SWIG_fail;
7589 {
7590 PyThreadState* __tstate = wxPyBeginAllowThreads();
7591 result = (int)(arg1)->tell();
7592
7593 wxPyEndAllowThreads(__tstate);
7594 if (PyErr_Occurred()) SWIG_fail;
7595 }
7596 {
7597 resultobj = SWIG_From_int((int)(result));
7598 }
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7606 PyObject *resultobj;
7607 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7608 char result;
7609 PyObject * obj0 = 0 ;
7610 char *kwnames[] = {
7611 (char *) "self", NULL
7612 };
7613
7614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7616 if (SWIG_arg_fail(1)) SWIG_fail;
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 result = (char)(arg1)->Peek();
7620
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 {
7625 resultobj = SWIG_From_char((char)(result));
7626 }
7627 return resultobj;
7628 fail:
7629 return NULL;
7630 }
7631
7632
7633 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7634 PyObject *resultobj;
7635 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7636 char result;
7637 PyObject * obj0 = 0 ;
7638 char *kwnames[] = {
7639 (char *) "self", NULL
7640 };
7641
7642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7644 if (SWIG_arg_fail(1)) SWIG_fail;
7645 {
7646 PyThreadState* __tstate = wxPyBeginAllowThreads();
7647 result = (char)(arg1)->GetC();
7648
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 {
7653 resultobj = SWIG_From_char((char)(result));
7654 }
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj;
7663 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7664 size_t result;
7665 PyObject * obj0 = 0 ;
7666 char *kwnames[] = {
7667 (char *) "self", NULL
7668 };
7669
7670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7672 if (SWIG_arg_fail(1)) SWIG_fail;
7673 {
7674 PyThreadState* __tstate = wxPyBeginAllowThreads();
7675 result = (size_t)(arg1)->LastRead();
7676
7677 wxPyEndAllowThreads(__tstate);
7678 if (PyErr_Occurred()) SWIG_fail;
7679 }
7680 {
7681 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7682 }
7683 return resultobj;
7684 fail:
7685 return NULL;
7686 }
7687
7688
7689 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7690 PyObject *resultobj;
7691 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7692 bool result;
7693 PyObject * obj0 = 0 ;
7694 char *kwnames[] = {
7695 (char *) "self", NULL
7696 };
7697
7698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7700 if (SWIG_arg_fail(1)) SWIG_fail;
7701 {
7702 PyThreadState* __tstate = wxPyBeginAllowThreads();
7703 result = (bool)(arg1)->CanRead();
7704
7705 wxPyEndAllowThreads(__tstate);
7706 if (PyErr_Occurred()) SWIG_fail;
7707 }
7708 {
7709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7710 }
7711 return resultobj;
7712 fail:
7713 return NULL;
7714 }
7715
7716
7717 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7718 PyObject *resultobj;
7719 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7720 bool result;
7721 PyObject * obj0 = 0 ;
7722 char *kwnames[] = {
7723 (char *) "self", NULL
7724 };
7725
7726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7728 if (SWIG_arg_fail(1)) SWIG_fail;
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 result = (bool)(arg1)->Eof();
7732
7733 wxPyEndAllowThreads(__tstate);
7734 if (PyErr_Occurred()) SWIG_fail;
7735 }
7736 {
7737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7738 }
7739 return resultobj;
7740 fail:
7741 return NULL;
7742 }
7743
7744
7745 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7746 PyObject *resultobj;
7747 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7748 char arg2 ;
7749 bool result;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char *kwnames[] = {
7753 (char *) "self",(char *) "c", NULL
7754 };
7755
7756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7758 if (SWIG_arg_fail(1)) SWIG_fail;
7759 {
7760 arg2 = (char)(SWIG_As_char(obj1));
7761 if (SWIG_arg_fail(2)) SWIG_fail;
7762 }
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 result = (bool)(arg1)->Ungetch(arg2);
7766
7767 wxPyEndAllowThreads(__tstate);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 {
7771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7772 }
7773 return resultobj;
7774 fail:
7775 return NULL;
7776 }
7777
7778
7779 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7780 PyObject *resultobj;
7781 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7782 long arg2 ;
7783 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7784 long result;
7785 PyObject * obj0 = 0 ;
7786 PyObject * obj1 = 0 ;
7787 PyObject * obj2 = 0 ;
7788 char *kwnames[] = {
7789 (char *) "self",(char *) "pos",(char *) "mode", NULL
7790 };
7791
7792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7794 if (SWIG_arg_fail(1)) SWIG_fail;
7795 {
7796 arg2 = (long)(SWIG_As_long(obj1));
7797 if (SWIG_arg_fail(2)) SWIG_fail;
7798 }
7799 if (obj2) {
7800 {
7801 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7802 if (SWIG_arg_fail(3)) SWIG_fail;
7803 }
7804 }
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7808
7809 wxPyEndAllowThreads(__tstate);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 {
7813 resultobj = SWIG_From_long((long)(result));
7814 }
7815 return resultobj;
7816 fail:
7817 return NULL;
7818 }
7819
7820
7821 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7822 PyObject *resultobj;
7823 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7824 long result;
7825 PyObject * obj0 = 0 ;
7826 char *kwnames[] = {
7827 (char *) "self", NULL
7828 };
7829
7830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7832 if (SWIG_arg_fail(1)) SWIG_fail;
7833 {
7834 PyThreadState* __tstate = wxPyBeginAllowThreads();
7835 result = (long)(arg1)->TellI();
7836
7837 wxPyEndAllowThreads(__tstate);
7838 if (PyErr_Occurred()) SWIG_fail;
7839 }
7840 {
7841 resultobj = SWIG_From_long((long)(result));
7842 }
7843 return resultobj;
7844 fail:
7845 return NULL;
7846 }
7847
7848
7849 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7850 PyObject *obj;
7851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7852 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7853 Py_INCREF(obj);
7854 return Py_BuildValue((char *)"");
7855 }
7856 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7857 PyObject *resultobj;
7858 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7859 PyObject *arg2 = (PyObject *) 0 ;
7860 PyObject * obj0 = 0 ;
7861 PyObject * obj1 = 0 ;
7862 char *kwnames[] = {
7863 (char *) "self",(char *) "obj", NULL
7864 };
7865
7866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7868 if (SWIG_arg_fail(1)) SWIG_fail;
7869 arg2 = obj1;
7870 {
7871 PyThreadState* __tstate = wxPyBeginAllowThreads();
7872 wxOutputStream_write(arg1,arg2);
7873
7874 wxPyEndAllowThreads(__tstate);
7875 if (PyErr_Occurred()) SWIG_fail;
7876 }
7877 Py_INCREF(Py_None); resultobj = Py_None;
7878 return resultobj;
7879 fail:
7880 return NULL;
7881 }
7882
7883
7884 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7885 PyObject *obj;
7886 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7887 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7888 Py_INCREF(obj);
7889 return Py_BuildValue((char *)"");
7890 }
7891 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7892 PyObject *resultobj;
7893 wxInputStream *arg1 = (wxInputStream *) 0 ;
7894 wxString *arg2 = 0 ;
7895 wxString *arg3 = 0 ;
7896 wxString *arg4 = 0 ;
7897 wxDateTime arg5 ;
7898 wxFSFile *result;
7899 wxPyInputStream *temp1 ;
7900 bool created1 ;
7901 bool temp2 = false ;
7902 bool temp3 = false ;
7903 bool temp4 = false ;
7904 PyObject * obj0 = 0 ;
7905 PyObject * obj1 = 0 ;
7906 PyObject * obj2 = 0 ;
7907 PyObject * obj3 = 0 ;
7908 PyObject * obj4 = 0 ;
7909 char *kwnames[] = {
7910 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7911 };
7912
7913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7914 {
7915 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7916 arg1 = temp1->m_wxis;
7917 created1 = false;
7918 } else {
7919 PyErr_Clear(); // clear the failure of the wxPyConvert above
7920 arg1 = wxPyCBInputStream_create(obj0, false);
7921 if (arg1 == NULL) {
7922 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7923 SWIG_fail;
7924 }
7925 created1 = true;
7926 }
7927 }
7928 {
7929 arg2 = wxString_in_helper(obj1);
7930 if (arg2 == NULL) SWIG_fail;
7931 temp2 = true;
7932 }
7933 {
7934 arg3 = wxString_in_helper(obj2);
7935 if (arg3 == NULL) SWIG_fail;
7936 temp3 = true;
7937 }
7938 {
7939 arg4 = wxString_in_helper(obj3);
7940 if (arg4 == NULL) SWIG_fail;
7941 temp4 = true;
7942 }
7943 {
7944 wxDateTime * argp;
7945 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7946 if (SWIG_arg_fail(5)) SWIG_fail;
7947 if (argp == NULL) {
7948 SWIG_null_ref("wxDateTime");
7949 }
7950 if (SWIG_arg_fail(5)) SWIG_fail;
7951 arg5 = *argp;
7952 }
7953 {
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7956
7957 wxPyEndAllowThreads(__tstate);
7958 if (PyErr_Occurred()) SWIG_fail;
7959 }
7960 {
7961 resultobj = wxPyMake_wxObject(result, 1);
7962 }
7963 {
7964 if (created1)
7965 delete arg1;
7966 }
7967 {
7968 if (temp2)
7969 delete arg2;
7970 }
7971 {
7972 if (temp3)
7973 delete arg3;
7974 }
7975 {
7976 if (temp4)
7977 delete arg4;
7978 }
7979 return resultobj;
7980 fail:
7981 {
7982 if (created1)
7983 delete arg1;
7984 }
7985 {
7986 if (temp2)
7987 delete arg2;
7988 }
7989 {
7990 if (temp3)
7991 delete arg3;
7992 }
7993 {
7994 if (temp4)
7995 delete arg4;
7996 }
7997 return NULL;
7998 }
7999
8000
8001 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8002 PyObject *resultobj;
8003 wxFSFile *arg1 = (wxFSFile *) 0 ;
8004 PyObject * obj0 = 0 ;
8005 char *kwnames[] = {
8006 (char *) "self", NULL
8007 };
8008
8009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8011 if (SWIG_arg_fail(1)) SWIG_fail;
8012 {
8013 PyThreadState* __tstate = wxPyBeginAllowThreads();
8014 delete arg1;
8015
8016 wxPyEndAllowThreads(__tstate);
8017 if (PyErr_Occurred()) SWIG_fail;
8018 }
8019 Py_INCREF(Py_None); resultobj = Py_None;
8020 return resultobj;
8021 fail:
8022 return NULL;
8023 }
8024
8025
8026 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8027 PyObject *resultobj;
8028 wxFSFile *arg1 = (wxFSFile *) 0 ;
8029 wxInputStream *result;
8030 PyObject * obj0 = 0 ;
8031 char *kwnames[] = {
8032 (char *) "self", NULL
8033 };
8034
8035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8037 if (SWIG_arg_fail(1)) SWIG_fail;
8038 {
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 result = (wxInputStream *)(arg1)->GetStream();
8041
8042 wxPyEndAllowThreads(__tstate);
8043 if (PyErr_Occurred()) SWIG_fail;
8044 }
8045 {
8046 wxPyInputStream * _ptr = NULL;
8047
8048 if (result) {
8049 _ptr = new wxPyInputStream(result);
8050 }
8051 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8052 }
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj;
8061 wxFSFile *arg1 = (wxFSFile *) 0 ;
8062 wxString *result;
8063 PyObject * obj0 = 0 ;
8064 char *kwnames[] = {
8065 (char *) "self", NULL
8066 };
8067
8068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8070 if (SWIG_arg_fail(1)) SWIG_fail;
8071 {
8072 PyThreadState* __tstate = wxPyBeginAllowThreads();
8073 {
8074 wxString const &_result_ref = (arg1)->GetMimeType();
8075 result = (wxString *) &_result_ref;
8076 }
8077
8078 wxPyEndAllowThreads(__tstate);
8079 if (PyErr_Occurred()) SWIG_fail;
8080 }
8081 {
8082 #if wxUSE_UNICODE
8083 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8084 #else
8085 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8086 #endif
8087 }
8088 return resultobj;
8089 fail:
8090 return NULL;
8091 }
8092
8093
8094 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8095 PyObject *resultobj;
8096 wxFSFile *arg1 = (wxFSFile *) 0 ;
8097 wxString *result;
8098 PyObject * obj0 = 0 ;
8099 char *kwnames[] = {
8100 (char *) "self", NULL
8101 };
8102
8103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8105 if (SWIG_arg_fail(1)) SWIG_fail;
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 {
8109 wxString const &_result_ref = (arg1)->GetLocation();
8110 result = (wxString *) &_result_ref;
8111 }
8112
8113 wxPyEndAllowThreads(__tstate);
8114 if (PyErr_Occurred()) SWIG_fail;
8115 }
8116 {
8117 #if wxUSE_UNICODE
8118 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8119 #else
8120 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8121 #endif
8122 }
8123 return resultobj;
8124 fail:
8125 return NULL;
8126 }
8127
8128
8129 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8130 PyObject *resultobj;
8131 wxFSFile *arg1 = (wxFSFile *) 0 ;
8132 wxString *result;
8133 PyObject * obj0 = 0 ;
8134 char *kwnames[] = {
8135 (char *) "self", NULL
8136 };
8137
8138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8140 if (SWIG_arg_fail(1)) SWIG_fail;
8141 {
8142 PyThreadState* __tstate = wxPyBeginAllowThreads();
8143 {
8144 wxString const &_result_ref = (arg1)->GetAnchor();
8145 result = (wxString *) &_result_ref;
8146 }
8147
8148 wxPyEndAllowThreads(__tstate);
8149 if (PyErr_Occurred()) SWIG_fail;
8150 }
8151 {
8152 #if wxUSE_UNICODE
8153 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8154 #else
8155 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8156 #endif
8157 }
8158 return resultobj;
8159 fail:
8160 return NULL;
8161 }
8162
8163
8164 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8165 PyObject *resultobj;
8166 wxFSFile *arg1 = (wxFSFile *) 0 ;
8167 wxDateTime result;
8168 PyObject * obj0 = 0 ;
8169 char *kwnames[] = {
8170 (char *) "self", NULL
8171 };
8172
8173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8175 if (SWIG_arg_fail(1)) SWIG_fail;
8176 {
8177 PyThreadState* __tstate = wxPyBeginAllowThreads();
8178 result = (arg1)->GetModificationTime();
8179
8180 wxPyEndAllowThreads(__tstate);
8181 if (PyErr_Occurred()) SWIG_fail;
8182 }
8183 {
8184 wxDateTime * resultptr;
8185 resultptr = new wxDateTime((wxDateTime &)(result));
8186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8187 }
8188 return resultobj;
8189 fail:
8190 return NULL;
8191 }
8192
8193
8194 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8195 PyObject *obj;
8196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8197 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8198 Py_INCREF(obj);
8199 return Py_BuildValue((char *)"");
8200 }
8201 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8202 PyObject *obj;
8203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8204 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8205 Py_INCREF(obj);
8206 return Py_BuildValue((char *)"");
8207 }
8208 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8209 PyObject *resultobj;
8210 wxPyFileSystemHandler *result;
8211 char *kwnames[] = {
8212 NULL
8213 };
8214
8215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8216 {
8217 PyThreadState* __tstate = wxPyBeginAllowThreads();
8218 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8219
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8224 return resultobj;
8225 fail:
8226 return NULL;
8227 }
8228
8229
8230 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8231 PyObject *resultobj;
8232 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8233 PyObject *arg2 = (PyObject *) 0 ;
8234 PyObject *arg3 = (PyObject *) 0 ;
8235 PyObject * obj0 = 0 ;
8236 PyObject * obj1 = 0 ;
8237 PyObject * obj2 = 0 ;
8238 char *kwnames[] = {
8239 (char *) "self",(char *) "self",(char *) "_class", NULL
8240 };
8241
8242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8244 if (SWIG_arg_fail(1)) SWIG_fail;
8245 arg2 = obj1;
8246 arg3 = obj2;
8247 {
8248 PyThreadState* __tstate = wxPyBeginAllowThreads();
8249 (arg1)->_setCallbackInfo(arg2,arg3);
8250
8251 wxPyEndAllowThreads(__tstate);
8252 if (PyErr_Occurred()) SWIG_fail;
8253 }
8254 Py_INCREF(Py_None); resultobj = Py_None;
8255 return resultobj;
8256 fail:
8257 return NULL;
8258 }
8259
8260
8261 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8262 PyObject *resultobj;
8263 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8264 wxString *arg2 = 0 ;
8265 bool result;
8266 bool temp2 = false ;
8267 PyObject * obj0 = 0 ;
8268 PyObject * obj1 = 0 ;
8269 char *kwnames[] = {
8270 (char *) "self",(char *) "location", NULL
8271 };
8272
8273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8275 if (SWIG_arg_fail(1)) SWIG_fail;
8276 {
8277 arg2 = wxString_in_helper(obj1);
8278 if (arg2 == NULL) SWIG_fail;
8279 temp2 = true;
8280 }
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 {
8289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8290 }
8291 {
8292 if (temp2)
8293 delete arg2;
8294 }
8295 return resultobj;
8296 fail:
8297 {
8298 if (temp2)
8299 delete arg2;
8300 }
8301 return NULL;
8302 }
8303
8304
8305 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8306 PyObject *resultobj;
8307 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8308 wxFileSystem *arg2 = 0 ;
8309 wxString *arg3 = 0 ;
8310 wxFSFile *result;
8311 bool temp3 = false ;
8312 PyObject * obj0 = 0 ;
8313 PyObject * obj1 = 0 ;
8314 PyObject * obj2 = 0 ;
8315 char *kwnames[] = {
8316 (char *) "self",(char *) "fs",(char *) "location", NULL
8317 };
8318
8319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8321 if (SWIG_arg_fail(1)) SWIG_fail;
8322 {
8323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8324 if (SWIG_arg_fail(2)) SWIG_fail;
8325 if (arg2 == NULL) {
8326 SWIG_null_ref("wxFileSystem");
8327 }
8328 if (SWIG_arg_fail(2)) SWIG_fail;
8329 }
8330 {
8331 arg3 = wxString_in_helper(obj2);
8332 if (arg3 == NULL) SWIG_fail;
8333 temp3 = true;
8334 }
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8338
8339 wxPyEndAllowThreads(__tstate);
8340 if (PyErr_Occurred()) SWIG_fail;
8341 }
8342 {
8343 resultobj = wxPyMake_wxObject(result, 1);
8344 }
8345 {
8346 if (temp3)
8347 delete arg3;
8348 }
8349 return resultobj;
8350 fail:
8351 {
8352 if (temp3)
8353 delete arg3;
8354 }
8355 return NULL;
8356 }
8357
8358
8359 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8360 PyObject *resultobj;
8361 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8362 wxString *arg2 = 0 ;
8363 int arg3 = (int) 0 ;
8364 wxString result;
8365 bool temp2 = false ;
8366 PyObject * obj0 = 0 ;
8367 PyObject * obj1 = 0 ;
8368 PyObject * obj2 = 0 ;
8369 char *kwnames[] = {
8370 (char *) "self",(char *) "spec",(char *) "flags", NULL
8371 };
8372
8373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8375 if (SWIG_arg_fail(1)) SWIG_fail;
8376 {
8377 arg2 = wxString_in_helper(obj1);
8378 if (arg2 == NULL) SWIG_fail;
8379 temp2 = true;
8380 }
8381 if (obj2) {
8382 {
8383 arg3 = (int)(SWIG_As_int(obj2));
8384 if (SWIG_arg_fail(3)) SWIG_fail;
8385 }
8386 }
8387 {
8388 PyThreadState* __tstate = wxPyBeginAllowThreads();
8389 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8390
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 {
8395 #if wxUSE_UNICODE
8396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8397 #else
8398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8399 #endif
8400 }
8401 {
8402 if (temp2)
8403 delete arg2;
8404 }
8405 return resultobj;
8406 fail:
8407 {
8408 if (temp2)
8409 delete arg2;
8410 }
8411 return NULL;
8412 }
8413
8414
8415 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8416 PyObject *resultobj;
8417 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8418 wxString result;
8419 PyObject * obj0 = 0 ;
8420 char *kwnames[] = {
8421 (char *) "self", NULL
8422 };
8423
8424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8426 if (SWIG_arg_fail(1)) SWIG_fail;
8427 {
8428 PyThreadState* __tstate = wxPyBeginAllowThreads();
8429 result = (arg1)->FindNext();
8430
8431 wxPyEndAllowThreads(__tstate);
8432 if (PyErr_Occurred()) SWIG_fail;
8433 }
8434 {
8435 #if wxUSE_UNICODE
8436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8437 #else
8438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8439 #endif
8440 }
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8448 PyObject *resultobj;
8449 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8450 wxString *arg2 = 0 ;
8451 wxString result;
8452 bool temp2 = false ;
8453 PyObject * obj0 = 0 ;
8454 PyObject * obj1 = 0 ;
8455 char *kwnames[] = {
8456 (char *) "self",(char *) "location", NULL
8457 };
8458
8459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8461 if (SWIG_arg_fail(1)) SWIG_fail;
8462 {
8463 arg2 = wxString_in_helper(obj1);
8464 if (arg2 == NULL) SWIG_fail;
8465 temp2 = true;
8466 }
8467 {
8468 PyThreadState* __tstate = wxPyBeginAllowThreads();
8469 result = (arg1)->GetProtocol((wxString const &)*arg2);
8470
8471 wxPyEndAllowThreads(__tstate);
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 {
8475 #if wxUSE_UNICODE
8476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8477 #else
8478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8479 #endif
8480 }
8481 {
8482 if (temp2)
8483 delete arg2;
8484 }
8485 return resultobj;
8486 fail:
8487 {
8488 if (temp2)
8489 delete arg2;
8490 }
8491 return NULL;
8492 }
8493
8494
8495 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8496 PyObject *resultobj;
8497 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8498 wxString *arg2 = 0 ;
8499 wxString result;
8500 bool temp2 = false ;
8501 PyObject * obj0 = 0 ;
8502 PyObject * obj1 = 0 ;
8503 char *kwnames[] = {
8504 (char *) "self",(char *) "location", NULL
8505 };
8506
8507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8509 if (SWIG_arg_fail(1)) SWIG_fail;
8510 {
8511 arg2 = wxString_in_helper(obj1);
8512 if (arg2 == NULL) SWIG_fail;
8513 temp2 = true;
8514 }
8515 {
8516 PyThreadState* __tstate = wxPyBeginAllowThreads();
8517 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8518
8519 wxPyEndAllowThreads(__tstate);
8520 if (PyErr_Occurred()) SWIG_fail;
8521 }
8522 {
8523 #if wxUSE_UNICODE
8524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8525 #else
8526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8527 #endif
8528 }
8529 {
8530 if (temp2)
8531 delete arg2;
8532 }
8533 return resultobj;
8534 fail:
8535 {
8536 if (temp2)
8537 delete arg2;
8538 }
8539 return NULL;
8540 }
8541
8542
8543 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj;
8545 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8546 wxString *arg2 = 0 ;
8547 wxString result;
8548 bool temp2 = false ;
8549 PyObject * obj0 = 0 ;
8550 PyObject * obj1 = 0 ;
8551 char *kwnames[] = {
8552 (char *) "self",(char *) "location", NULL
8553 };
8554
8555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8557 if (SWIG_arg_fail(1)) SWIG_fail;
8558 {
8559 arg2 = wxString_in_helper(obj1);
8560 if (arg2 == NULL) SWIG_fail;
8561 temp2 = true;
8562 }
8563 {
8564 PyThreadState* __tstate = wxPyBeginAllowThreads();
8565 result = (arg1)->GetAnchor((wxString const &)*arg2);
8566
8567 wxPyEndAllowThreads(__tstate);
8568 if (PyErr_Occurred()) SWIG_fail;
8569 }
8570 {
8571 #if wxUSE_UNICODE
8572 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8573 #else
8574 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8575 #endif
8576 }
8577 {
8578 if (temp2)
8579 delete arg2;
8580 }
8581 return resultobj;
8582 fail:
8583 {
8584 if (temp2)
8585 delete arg2;
8586 }
8587 return NULL;
8588 }
8589
8590
8591 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8592 PyObject *resultobj;
8593 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8594 wxString *arg2 = 0 ;
8595 wxString result;
8596 bool temp2 = false ;
8597 PyObject * obj0 = 0 ;
8598 PyObject * obj1 = 0 ;
8599 char *kwnames[] = {
8600 (char *) "self",(char *) "location", NULL
8601 };
8602
8603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8605 if (SWIG_arg_fail(1)) SWIG_fail;
8606 {
8607 arg2 = wxString_in_helper(obj1);
8608 if (arg2 == NULL) SWIG_fail;
8609 temp2 = true;
8610 }
8611 {
8612 PyThreadState* __tstate = wxPyBeginAllowThreads();
8613 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8614
8615 wxPyEndAllowThreads(__tstate);
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 {
8619 #if wxUSE_UNICODE
8620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8621 #else
8622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8623 #endif
8624 }
8625 {
8626 if (temp2)
8627 delete arg2;
8628 }
8629 return resultobj;
8630 fail:
8631 {
8632 if (temp2)
8633 delete arg2;
8634 }
8635 return NULL;
8636 }
8637
8638
8639 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8640 PyObject *resultobj;
8641 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8642 wxString *arg2 = 0 ;
8643 wxString result;
8644 bool temp2 = false ;
8645 PyObject * obj0 = 0 ;
8646 PyObject * obj1 = 0 ;
8647 char *kwnames[] = {
8648 (char *) "self",(char *) "location", NULL
8649 };
8650
8651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8653 if (SWIG_arg_fail(1)) SWIG_fail;
8654 {
8655 arg2 = wxString_in_helper(obj1);
8656 if (arg2 == NULL) SWIG_fail;
8657 temp2 = true;
8658 }
8659 {
8660 PyThreadState* __tstate = wxPyBeginAllowThreads();
8661 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8662
8663 wxPyEndAllowThreads(__tstate);
8664 if (PyErr_Occurred()) SWIG_fail;
8665 }
8666 {
8667 #if wxUSE_UNICODE
8668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8669 #else
8670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8671 #endif
8672 }
8673 {
8674 if (temp2)
8675 delete arg2;
8676 }
8677 return resultobj;
8678 fail:
8679 {
8680 if (temp2)
8681 delete arg2;
8682 }
8683 return NULL;
8684 }
8685
8686
8687 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8688 PyObject *obj;
8689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8690 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8691 Py_INCREF(obj);
8692 return Py_BuildValue((char *)"");
8693 }
8694 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj;
8696 wxFileSystem *result;
8697 char *kwnames[] = {
8698 NULL
8699 };
8700
8701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8702 {
8703 PyThreadState* __tstate = wxPyBeginAllowThreads();
8704 result = (wxFileSystem *)new wxFileSystem();
8705
8706 wxPyEndAllowThreads(__tstate);
8707 if (PyErr_Occurred()) SWIG_fail;
8708 }
8709 {
8710 resultobj = wxPyMake_wxObject(result, 1);
8711 }
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj;
8720 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8721 PyObject * obj0 = 0 ;
8722 char *kwnames[] = {
8723 (char *) "self", NULL
8724 };
8725
8726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8728 if (SWIG_arg_fail(1)) SWIG_fail;
8729 {
8730 PyThreadState* __tstate = wxPyBeginAllowThreads();
8731 delete arg1;
8732
8733 wxPyEndAllowThreads(__tstate);
8734 if (PyErr_Occurred()) SWIG_fail;
8735 }
8736 Py_INCREF(Py_None); resultobj = Py_None;
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8744 PyObject *resultobj;
8745 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8746 wxString *arg2 = 0 ;
8747 bool arg3 = (bool) false ;
8748 bool temp2 = false ;
8749 PyObject * obj0 = 0 ;
8750 PyObject * obj1 = 0 ;
8751 PyObject * obj2 = 0 ;
8752 char *kwnames[] = {
8753 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8754 };
8755
8756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8758 if (SWIG_arg_fail(1)) SWIG_fail;
8759 {
8760 arg2 = wxString_in_helper(obj1);
8761 if (arg2 == NULL) SWIG_fail;
8762 temp2 = true;
8763 }
8764 if (obj2) {
8765 {
8766 arg3 = (bool)(SWIG_As_bool(obj2));
8767 if (SWIG_arg_fail(3)) SWIG_fail;
8768 }
8769 }
8770 {
8771 PyThreadState* __tstate = wxPyBeginAllowThreads();
8772 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8773
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 Py_INCREF(Py_None); resultobj = Py_None;
8778 {
8779 if (temp2)
8780 delete arg2;
8781 }
8782 return resultobj;
8783 fail:
8784 {
8785 if (temp2)
8786 delete arg2;
8787 }
8788 return NULL;
8789 }
8790
8791
8792 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8793 PyObject *resultobj;
8794 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8795 wxString result;
8796 PyObject * obj0 = 0 ;
8797 char *kwnames[] = {
8798 (char *) "self", NULL
8799 };
8800
8801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8803 if (SWIG_arg_fail(1)) SWIG_fail;
8804 {
8805 PyThreadState* __tstate = wxPyBeginAllowThreads();
8806 result = (arg1)->GetPath();
8807
8808 wxPyEndAllowThreads(__tstate);
8809 if (PyErr_Occurred()) SWIG_fail;
8810 }
8811 {
8812 #if wxUSE_UNICODE
8813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8814 #else
8815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8816 #endif
8817 }
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8825 PyObject *resultobj;
8826 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8827 wxString *arg2 = 0 ;
8828 wxFSFile *result;
8829 bool temp2 = false ;
8830 PyObject * obj0 = 0 ;
8831 PyObject * obj1 = 0 ;
8832 char *kwnames[] = {
8833 (char *) "self",(char *) "location", NULL
8834 };
8835
8836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8838 if (SWIG_arg_fail(1)) SWIG_fail;
8839 {
8840 arg2 = wxString_in_helper(obj1);
8841 if (arg2 == NULL) SWIG_fail;
8842 temp2 = true;
8843 }
8844 {
8845 PyThreadState* __tstate = wxPyBeginAllowThreads();
8846 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8847
8848 wxPyEndAllowThreads(__tstate);
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 {
8852 resultobj = wxPyMake_wxObject(result, 1);
8853 }
8854 {
8855 if (temp2)
8856 delete arg2;
8857 }
8858 return resultobj;
8859 fail:
8860 {
8861 if (temp2)
8862 delete arg2;
8863 }
8864 return NULL;
8865 }
8866
8867
8868 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8869 PyObject *resultobj;
8870 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8871 wxString *arg2 = 0 ;
8872 int arg3 = (int) 0 ;
8873 wxString result;
8874 bool temp2 = false ;
8875 PyObject * obj0 = 0 ;
8876 PyObject * obj1 = 0 ;
8877 PyObject * obj2 = 0 ;
8878 char *kwnames[] = {
8879 (char *) "self",(char *) "spec",(char *) "flags", NULL
8880 };
8881
8882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8884 if (SWIG_arg_fail(1)) SWIG_fail;
8885 {
8886 arg2 = wxString_in_helper(obj1);
8887 if (arg2 == NULL) SWIG_fail;
8888 temp2 = true;
8889 }
8890 if (obj2) {
8891 {
8892 arg3 = (int)(SWIG_As_int(obj2));
8893 if (SWIG_arg_fail(3)) SWIG_fail;
8894 }
8895 }
8896 {
8897 PyThreadState* __tstate = wxPyBeginAllowThreads();
8898 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8899
8900 wxPyEndAllowThreads(__tstate);
8901 if (PyErr_Occurred()) SWIG_fail;
8902 }
8903 {
8904 #if wxUSE_UNICODE
8905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8906 #else
8907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8908 #endif
8909 }
8910 {
8911 if (temp2)
8912 delete arg2;
8913 }
8914 return resultobj;
8915 fail:
8916 {
8917 if (temp2)
8918 delete arg2;
8919 }
8920 return NULL;
8921 }
8922
8923
8924 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj;
8926 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8927 wxString result;
8928 PyObject * obj0 = 0 ;
8929 char *kwnames[] = {
8930 (char *) "self", NULL
8931 };
8932
8933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8935 if (SWIG_arg_fail(1)) SWIG_fail;
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 result = (arg1)->FindNext();
8939
8940 wxPyEndAllowThreads(__tstate);
8941 if (PyErr_Occurred()) SWIG_fail;
8942 }
8943 {
8944 #if wxUSE_UNICODE
8945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8946 #else
8947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8948 #endif
8949 }
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj;
8958 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8959 PyObject * obj0 = 0 ;
8960 char *kwnames[] = {
8961 (char *) "handler", NULL
8962 };
8963
8964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8966 if (SWIG_arg_fail(1)) SWIG_fail;
8967 {
8968 PyThreadState* __tstate = wxPyBeginAllowThreads();
8969 wxFileSystem::AddHandler(arg1);
8970
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 Py_INCREF(Py_None); resultobj = Py_None;
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8982 PyObject *resultobj;
8983 char *kwnames[] = {
8984 NULL
8985 };
8986
8987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 wxFileSystem::CleanUpHandlers();
8991
8992 wxPyEndAllowThreads(__tstate);
8993 if (PyErr_Occurred()) SWIG_fail;
8994 }
8995 Py_INCREF(Py_None); resultobj = Py_None;
8996 return resultobj;
8997 fail:
8998 return NULL;
8999 }
9000
9001
9002 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9003 PyObject *resultobj;
9004 wxString *arg1 = 0 ;
9005 wxString result;
9006 bool temp1 = false ;
9007 PyObject * obj0 = 0 ;
9008 char *kwnames[] = {
9009 (char *) "filename", NULL
9010 };
9011
9012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9013 {
9014 arg1 = wxString_in_helper(obj0);
9015 if (arg1 == NULL) SWIG_fail;
9016 temp1 = true;
9017 }
9018 {
9019 PyThreadState* __tstate = wxPyBeginAllowThreads();
9020 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9021
9022 wxPyEndAllowThreads(__tstate);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 {
9026 #if wxUSE_UNICODE
9027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9028 #else
9029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9030 #endif
9031 }
9032 {
9033 if (temp1)
9034 delete arg1;
9035 }
9036 return resultobj;
9037 fail:
9038 {
9039 if (temp1)
9040 delete arg1;
9041 }
9042 return NULL;
9043 }
9044
9045
9046 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj;
9048 wxString *arg1 = 0 ;
9049 wxString result;
9050 bool temp1 = false ;
9051 PyObject * obj0 = 0 ;
9052 char *kwnames[] = {
9053 (char *) "url", NULL
9054 };
9055
9056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9057 {
9058 arg1 = wxString_in_helper(obj0);
9059 if (arg1 == NULL) SWIG_fail;
9060 temp1 = true;
9061 }
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 result = FileSystem_URLToFileName((wxString const &)*arg1);
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 {
9070 #if wxUSE_UNICODE
9071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9072 #else
9073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9074 #endif
9075 }
9076 {
9077 if (temp1)
9078 delete arg1;
9079 }
9080 return resultobj;
9081 fail:
9082 {
9083 if (temp1)
9084 delete arg1;
9085 }
9086 return NULL;
9087 }
9088
9089
9090 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9091 PyObject *obj;
9092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9093 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9094 Py_INCREF(obj);
9095 return Py_BuildValue((char *)"");
9096 }
9097 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9098 PyObject *resultobj;
9099 wxInternetFSHandler *result;
9100 char *kwnames[] = {
9101 NULL
9102 };
9103
9104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9105 {
9106 PyThreadState* __tstate = wxPyBeginAllowThreads();
9107 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9108
9109 wxPyEndAllowThreads(__tstate);
9110 if (PyErr_Occurred()) SWIG_fail;
9111 }
9112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9113 return resultobj;
9114 fail:
9115 return NULL;
9116 }
9117
9118
9119 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9120 PyObject *resultobj;
9121 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9122 wxString *arg2 = 0 ;
9123 bool result;
9124 bool temp2 = false ;
9125 PyObject * obj0 = 0 ;
9126 PyObject * obj1 = 0 ;
9127 char *kwnames[] = {
9128 (char *) "self",(char *) "location", NULL
9129 };
9130
9131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9133 if (SWIG_arg_fail(1)) SWIG_fail;
9134 {
9135 arg2 = wxString_in_helper(obj1);
9136 if (arg2 == NULL) SWIG_fail;
9137 temp2 = true;
9138 }
9139 {
9140 PyThreadState* __tstate = wxPyBeginAllowThreads();
9141 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9142
9143 wxPyEndAllowThreads(__tstate);
9144 if (PyErr_Occurred()) SWIG_fail;
9145 }
9146 {
9147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9148 }
9149 {
9150 if (temp2)
9151 delete arg2;
9152 }
9153 return resultobj;
9154 fail:
9155 {
9156 if (temp2)
9157 delete arg2;
9158 }
9159 return NULL;
9160 }
9161
9162
9163 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9164 PyObject *resultobj;
9165 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9166 wxFileSystem *arg2 = 0 ;
9167 wxString *arg3 = 0 ;
9168 wxFSFile *result;
9169 bool temp3 = false ;
9170 PyObject * obj0 = 0 ;
9171 PyObject * obj1 = 0 ;
9172 PyObject * obj2 = 0 ;
9173 char *kwnames[] = {
9174 (char *) "self",(char *) "fs",(char *) "location", NULL
9175 };
9176
9177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9179 if (SWIG_arg_fail(1)) SWIG_fail;
9180 {
9181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9182 if (SWIG_arg_fail(2)) SWIG_fail;
9183 if (arg2 == NULL) {
9184 SWIG_null_ref("wxFileSystem");
9185 }
9186 if (SWIG_arg_fail(2)) SWIG_fail;
9187 }
9188 {
9189 arg3 = wxString_in_helper(obj2);
9190 if (arg3 == NULL) SWIG_fail;
9191 temp3 = true;
9192 }
9193 {
9194 PyThreadState* __tstate = wxPyBeginAllowThreads();
9195 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9196
9197 wxPyEndAllowThreads(__tstate);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 {
9201 resultobj = wxPyMake_wxObject(result, 1);
9202 }
9203 {
9204 if (temp3)
9205 delete arg3;
9206 }
9207 return resultobj;
9208 fail:
9209 {
9210 if (temp3)
9211 delete arg3;
9212 }
9213 return NULL;
9214 }
9215
9216
9217 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9218 PyObject *obj;
9219 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9220 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9221 Py_INCREF(obj);
9222 return Py_BuildValue((char *)"");
9223 }
9224 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj;
9226 wxZipFSHandler *result;
9227 char *kwnames[] = {
9228 NULL
9229 };
9230
9231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9232 {
9233 PyThreadState* __tstate = wxPyBeginAllowThreads();
9234 result = (wxZipFSHandler *)new wxZipFSHandler();
9235
9236 wxPyEndAllowThreads(__tstate);
9237 if (PyErr_Occurred()) SWIG_fail;
9238 }
9239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9240 return resultobj;
9241 fail:
9242 return NULL;
9243 }
9244
9245
9246 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9247 PyObject *resultobj;
9248 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9249 wxString *arg2 = 0 ;
9250 bool result;
9251 bool temp2 = false ;
9252 PyObject * obj0 = 0 ;
9253 PyObject * obj1 = 0 ;
9254 char *kwnames[] = {
9255 (char *) "self",(char *) "location", NULL
9256 };
9257
9258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9260 if (SWIG_arg_fail(1)) SWIG_fail;
9261 {
9262 arg2 = wxString_in_helper(obj1);
9263 if (arg2 == NULL) SWIG_fail;
9264 temp2 = true;
9265 }
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 {
9274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9275 }
9276 {
9277 if (temp2)
9278 delete arg2;
9279 }
9280 return resultobj;
9281 fail:
9282 {
9283 if (temp2)
9284 delete arg2;
9285 }
9286 return NULL;
9287 }
9288
9289
9290 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9291 PyObject *resultobj;
9292 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9293 wxFileSystem *arg2 = 0 ;
9294 wxString *arg3 = 0 ;
9295 wxFSFile *result;
9296 bool temp3 = false ;
9297 PyObject * obj0 = 0 ;
9298 PyObject * obj1 = 0 ;
9299 PyObject * obj2 = 0 ;
9300 char *kwnames[] = {
9301 (char *) "self",(char *) "fs",(char *) "location", NULL
9302 };
9303
9304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9306 if (SWIG_arg_fail(1)) SWIG_fail;
9307 {
9308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9309 if (SWIG_arg_fail(2)) SWIG_fail;
9310 if (arg2 == NULL) {
9311 SWIG_null_ref("wxFileSystem");
9312 }
9313 if (SWIG_arg_fail(2)) SWIG_fail;
9314 }
9315 {
9316 arg3 = wxString_in_helper(obj2);
9317 if (arg3 == NULL) SWIG_fail;
9318 temp3 = true;
9319 }
9320 {
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9323
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 {
9328 resultobj = wxPyMake_wxObject(result, 1);
9329 }
9330 {
9331 if (temp3)
9332 delete arg3;
9333 }
9334 return resultobj;
9335 fail:
9336 {
9337 if (temp3)
9338 delete arg3;
9339 }
9340 return NULL;
9341 }
9342
9343
9344 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9345 PyObject *resultobj;
9346 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9347 wxString *arg2 = 0 ;
9348 int arg3 = (int) 0 ;
9349 wxString result;
9350 bool temp2 = false ;
9351 PyObject * obj0 = 0 ;
9352 PyObject * obj1 = 0 ;
9353 PyObject * obj2 = 0 ;
9354 char *kwnames[] = {
9355 (char *) "self",(char *) "spec",(char *) "flags", NULL
9356 };
9357
9358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9360 if (SWIG_arg_fail(1)) SWIG_fail;
9361 {
9362 arg2 = wxString_in_helper(obj1);
9363 if (arg2 == NULL) SWIG_fail;
9364 temp2 = true;
9365 }
9366 if (obj2) {
9367 {
9368 arg3 = (int)(SWIG_As_int(obj2));
9369 if (SWIG_arg_fail(3)) SWIG_fail;
9370 }
9371 }
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9375
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 {
9380 #if wxUSE_UNICODE
9381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9382 #else
9383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9384 #endif
9385 }
9386 {
9387 if (temp2)
9388 delete arg2;
9389 }
9390 return resultobj;
9391 fail:
9392 {
9393 if (temp2)
9394 delete arg2;
9395 }
9396 return NULL;
9397 }
9398
9399
9400 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9401 PyObject *resultobj;
9402 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9403 wxString result;
9404 PyObject * obj0 = 0 ;
9405 char *kwnames[] = {
9406 (char *) "self", NULL
9407 };
9408
9409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9411 if (SWIG_arg_fail(1)) SWIG_fail;
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = (arg1)->FindNext();
9415
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 {
9420 #if wxUSE_UNICODE
9421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9422 #else
9423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9424 #endif
9425 }
9426 return resultobj;
9427 fail:
9428 return NULL;
9429 }
9430
9431
9432 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9433 PyObject *obj;
9434 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9435 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9436 Py_INCREF(obj);
9437 return Py_BuildValue((char *)"");
9438 }
9439 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj;
9441 wxString *arg1 = 0 ;
9442 wxImage *arg2 = 0 ;
9443 long arg3 ;
9444 bool temp1 = false ;
9445 PyObject * obj0 = 0 ;
9446 PyObject * obj1 = 0 ;
9447 PyObject * obj2 = 0 ;
9448 char *kwnames[] = {
9449 (char *) "filename",(char *) "image",(char *) "type", NULL
9450 };
9451
9452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9453 {
9454 arg1 = wxString_in_helper(obj0);
9455 if (arg1 == NULL) SWIG_fail;
9456 temp1 = true;
9457 }
9458 {
9459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9460 if (SWIG_arg_fail(2)) SWIG_fail;
9461 if (arg2 == NULL) {
9462 SWIG_null_ref("wxImage");
9463 }
9464 if (SWIG_arg_fail(2)) SWIG_fail;
9465 }
9466 {
9467 arg3 = (long)(SWIG_As_long(obj2));
9468 if (SWIG_arg_fail(3)) SWIG_fail;
9469 }
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9473
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 Py_INCREF(Py_None); resultobj = Py_None;
9478 {
9479 if (temp1)
9480 delete arg1;
9481 }
9482 return resultobj;
9483 fail:
9484 {
9485 if (temp1)
9486 delete arg1;
9487 }
9488 return NULL;
9489 }
9490
9491
9492 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9493 PyObject *resultobj;
9494 wxString *arg1 = 0 ;
9495 wxBitmap *arg2 = 0 ;
9496 long arg3 ;
9497 bool temp1 = false ;
9498 PyObject * obj0 = 0 ;
9499 PyObject * obj1 = 0 ;
9500 PyObject * obj2 = 0 ;
9501 char *kwnames[] = {
9502 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9503 };
9504
9505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9506 {
9507 arg1 = wxString_in_helper(obj0);
9508 if (arg1 == NULL) SWIG_fail;
9509 temp1 = true;
9510 }
9511 {
9512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9513 if (SWIG_arg_fail(2)) SWIG_fail;
9514 if (arg2 == NULL) {
9515 SWIG_null_ref("wxBitmap");
9516 }
9517 if (SWIG_arg_fail(2)) SWIG_fail;
9518 }
9519 {
9520 arg3 = (long)(SWIG_As_long(obj2));
9521 if (SWIG_arg_fail(3)) SWIG_fail;
9522 }
9523 {
9524 PyThreadState* __tstate = wxPyBeginAllowThreads();
9525 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9526
9527 wxPyEndAllowThreads(__tstate);
9528 if (PyErr_Occurred()) SWIG_fail;
9529 }
9530 Py_INCREF(Py_None); resultobj = Py_None;
9531 {
9532 if (temp1)
9533 delete arg1;
9534 }
9535 return resultobj;
9536 fail:
9537 {
9538 if (temp1)
9539 delete arg1;
9540 }
9541 return NULL;
9542 }
9543
9544
9545 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9546 PyObject *resultobj;
9547 wxString *arg1 = 0 ;
9548 PyObject *arg2 = (PyObject *) 0 ;
9549 bool temp1 = false ;
9550 PyObject * obj0 = 0 ;
9551 PyObject * obj1 = 0 ;
9552 char *kwnames[] = {
9553 (char *) "filename",(char *) "data", NULL
9554 };
9555
9556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9557 {
9558 arg1 = wxString_in_helper(obj0);
9559 if (arg1 == NULL) SWIG_fail;
9560 temp1 = true;
9561 }
9562 arg2 = obj1;
9563 {
9564 PyThreadState* __tstate = wxPyBeginAllowThreads();
9565 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9566
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 Py_INCREF(Py_None); resultobj = Py_None;
9571 {
9572 if (temp1)
9573 delete arg1;
9574 }
9575 return resultobj;
9576 fail:
9577 {
9578 if (temp1)
9579 delete arg1;
9580 }
9581 return NULL;
9582 }
9583
9584
9585 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9586 PyObject *resultobj;
9587 wxMemoryFSHandler *result;
9588 char *kwnames[] = {
9589 NULL
9590 };
9591
9592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9593 {
9594 PyThreadState* __tstate = wxPyBeginAllowThreads();
9595 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9596
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9608 PyObject *resultobj;
9609 wxString *arg1 = 0 ;
9610 bool temp1 = false ;
9611 PyObject * obj0 = 0 ;
9612 char *kwnames[] = {
9613 (char *) "filename", NULL
9614 };
9615
9616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9617 {
9618 arg1 = wxString_in_helper(obj0);
9619 if (arg1 == NULL) SWIG_fail;
9620 temp1 = true;
9621 }
9622 {
9623 PyThreadState* __tstate = wxPyBeginAllowThreads();
9624 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9625
9626 wxPyEndAllowThreads(__tstate);
9627 if (PyErr_Occurred()) SWIG_fail;
9628 }
9629 Py_INCREF(Py_None); resultobj = Py_None;
9630 {
9631 if (temp1)
9632 delete arg1;
9633 }
9634 return resultobj;
9635 fail:
9636 {
9637 if (temp1)
9638 delete arg1;
9639 }
9640 return NULL;
9641 }
9642
9643
9644 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9645 PyObject *resultobj;
9646 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9647 wxString *arg2 = 0 ;
9648 bool result;
9649 bool temp2 = false ;
9650 PyObject * obj0 = 0 ;
9651 PyObject * obj1 = 0 ;
9652 char *kwnames[] = {
9653 (char *) "self",(char *) "location", NULL
9654 };
9655
9656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9658 if (SWIG_arg_fail(1)) SWIG_fail;
9659 {
9660 arg2 = wxString_in_helper(obj1);
9661 if (arg2 == NULL) SWIG_fail;
9662 temp2 = true;
9663 }
9664 {
9665 PyThreadState* __tstate = wxPyBeginAllowThreads();
9666 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9667
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 {
9672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9673 }
9674 {
9675 if (temp2)
9676 delete arg2;
9677 }
9678 return resultobj;
9679 fail:
9680 {
9681 if (temp2)
9682 delete arg2;
9683 }
9684 return NULL;
9685 }
9686
9687
9688 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9689 PyObject *resultobj;
9690 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9691 wxFileSystem *arg2 = 0 ;
9692 wxString *arg3 = 0 ;
9693 wxFSFile *result;
9694 bool temp3 = false ;
9695 PyObject * obj0 = 0 ;
9696 PyObject * obj1 = 0 ;
9697 PyObject * obj2 = 0 ;
9698 char *kwnames[] = {
9699 (char *) "self",(char *) "fs",(char *) "location", NULL
9700 };
9701
9702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9704 if (SWIG_arg_fail(1)) SWIG_fail;
9705 {
9706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9707 if (SWIG_arg_fail(2)) SWIG_fail;
9708 if (arg2 == NULL) {
9709 SWIG_null_ref("wxFileSystem");
9710 }
9711 if (SWIG_arg_fail(2)) SWIG_fail;
9712 }
9713 {
9714 arg3 = wxString_in_helper(obj2);
9715 if (arg3 == NULL) SWIG_fail;
9716 temp3 = true;
9717 }
9718 {
9719 PyThreadState* __tstate = wxPyBeginAllowThreads();
9720 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9721
9722 wxPyEndAllowThreads(__tstate);
9723 if (PyErr_Occurred()) SWIG_fail;
9724 }
9725 {
9726 resultobj = wxPyMake_wxObject(result, 1);
9727 }
9728 {
9729 if (temp3)
9730 delete arg3;
9731 }
9732 return resultobj;
9733 fail:
9734 {
9735 if (temp3)
9736 delete arg3;
9737 }
9738 return NULL;
9739 }
9740
9741
9742 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9743 PyObject *resultobj;
9744 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9745 wxString *arg2 = 0 ;
9746 int arg3 = (int) 0 ;
9747 wxString result;
9748 bool temp2 = false ;
9749 PyObject * obj0 = 0 ;
9750 PyObject * obj1 = 0 ;
9751 PyObject * obj2 = 0 ;
9752 char *kwnames[] = {
9753 (char *) "self",(char *) "spec",(char *) "flags", NULL
9754 };
9755
9756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9758 if (SWIG_arg_fail(1)) SWIG_fail;
9759 {
9760 arg2 = wxString_in_helper(obj1);
9761 if (arg2 == NULL) SWIG_fail;
9762 temp2 = true;
9763 }
9764 if (obj2) {
9765 {
9766 arg3 = (int)(SWIG_As_int(obj2));
9767 if (SWIG_arg_fail(3)) SWIG_fail;
9768 }
9769 }
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9773
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 {
9778 #if wxUSE_UNICODE
9779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9780 #else
9781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9782 #endif
9783 }
9784 {
9785 if (temp2)
9786 delete arg2;
9787 }
9788 return resultobj;
9789 fail:
9790 {
9791 if (temp2)
9792 delete arg2;
9793 }
9794 return NULL;
9795 }
9796
9797
9798 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9799 PyObject *resultobj;
9800 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9801 wxString result;
9802 PyObject * obj0 = 0 ;
9803 char *kwnames[] = {
9804 (char *) "self", NULL
9805 };
9806
9807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9809 if (SWIG_arg_fail(1)) SWIG_fail;
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 result = (arg1)->FindNext();
9813
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 {
9818 #if wxUSE_UNICODE
9819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9820 #else
9821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9822 #endif
9823 }
9824 return resultobj;
9825 fail:
9826 return NULL;
9827 }
9828
9829
9830 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9831 PyObject *obj;
9832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9833 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9834 Py_INCREF(obj);
9835 return Py_BuildValue((char *)"");
9836 }
9837 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9838 PyObject *resultobj;
9839 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9840 wxString result;
9841 PyObject * obj0 = 0 ;
9842 char *kwnames[] = {
9843 (char *) "self", NULL
9844 };
9845
9846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9848 if (SWIG_arg_fail(1)) SWIG_fail;
9849 {
9850 PyThreadState* __tstate = wxPyBeginAllowThreads();
9851 result = (arg1)->GetName();
9852
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 {
9857 #if wxUSE_UNICODE
9858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9859 #else
9860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9861 #endif
9862 }
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj;
9871 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9872 wxString result;
9873 PyObject * obj0 = 0 ;
9874 char *kwnames[] = {
9875 (char *) "self", NULL
9876 };
9877
9878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9880 if (SWIG_arg_fail(1)) SWIG_fail;
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (arg1)->GetExtension();
9884
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 #if wxUSE_UNICODE
9890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9891 #else
9892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9893 #endif
9894 }
9895 return resultobj;
9896 fail:
9897 return NULL;
9898 }
9899
9900
9901 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9902 PyObject *resultobj;
9903 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9904 long result;
9905 PyObject * obj0 = 0 ;
9906 char *kwnames[] = {
9907 (char *) "self", NULL
9908 };
9909
9910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9912 if (SWIG_arg_fail(1)) SWIG_fail;
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 result = (long)(arg1)->GetType();
9916
9917 wxPyEndAllowThreads(__tstate);
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 {
9921 resultobj = SWIG_From_long((long)(result));
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9932 wxString result;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "self", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(1)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = (arg1)->GetMimeType();
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 {
9949 #if wxUSE_UNICODE
9950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9951 #else
9952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9953 #endif
9954 }
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9964 wxString *arg2 = 0 ;
9965 bool result;
9966 bool temp2 = false ;
9967 PyObject * obj0 = 0 ;
9968 PyObject * obj1 = 0 ;
9969 char *kwnames[] = {
9970 (char *) "self",(char *) "name", NULL
9971 };
9972
9973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9975 if (SWIG_arg_fail(1)) SWIG_fail;
9976 {
9977 arg2 = wxString_in_helper(obj1);
9978 if (arg2 == NULL) SWIG_fail;
9979 temp2 = true;
9980 }
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9984
9985 wxPyEndAllowThreads(__tstate);
9986 if (PyErr_Occurred()) SWIG_fail;
9987 }
9988 {
9989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9990 }
9991 {
9992 if (temp2)
9993 delete arg2;
9994 }
9995 return resultobj;
9996 fail:
9997 {
9998 if (temp2)
9999 delete arg2;
10000 }
10001 return NULL;
10002 }
10003
10004
10005 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj;
10007 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10008 wxString *arg2 = 0 ;
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_SetName",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 (arg1)->SetName((wxString const &)*arg2);
10027
10028 wxPyEndAllowThreads(__tstate);
10029 if (PyErr_Occurred()) SWIG_fail;
10030 }
10031 Py_INCREF(Py_None); resultobj = Py_None;
10032 {
10033 if (temp2)
10034 delete arg2;
10035 }
10036 return resultobj;
10037 fail:
10038 {
10039 if (temp2)
10040 delete arg2;
10041 }
10042 return NULL;
10043 }
10044
10045
10046 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10047 PyObject *resultobj;
10048 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10049 wxString *arg2 = 0 ;
10050 bool temp2 = false ;
10051 PyObject * obj0 = 0 ;
10052 PyObject * obj1 = 0 ;
10053 char *kwnames[] = {
10054 (char *) "self",(char *) "extension", NULL
10055 };
10056
10057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10059 if (SWIG_arg_fail(1)) SWIG_fail;
10060 {
10061 arg2 = wxString_in_helper(obj1);
10062 if (arg2 == NULL) SWIG_fail;
10063 temp2 = true;
10064 }
10065 {
10066 PyThreadState* __tstate = wxPyBeginAllowThreads();
10067 (arg1)->SetExtension((wxString const &)*arg2);
10068
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 Py_INCREF(Py_None); resultobj = Py_None;
10073 {
10074 if (temp2)
10075 delete arg2;
10076 }
10077 return resultobj;
10078 fail:
10079 {
10080 if (temp2)
10081 delete arg2;
10082 }
10083 return NULL;
10084 }
10085
10086
10087 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj;
10089 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10090 long arg2 ;
10091 PyObject * obj0 = 0 ;
10092 PyObject * obj1 = 0 ;
10093 char *kwnames[] = {
10094 (char *) "self",(char *) "type", NULL
10095 };
10096
10097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10099 if (SWIG_arg_fail(1)) SWIG_fail;
10100 {
10101 arg2 = (long)(SWIG_As_long(obj1));
10102 if (SWIG_arg_fail(2)) SWIG_fail;
10103 }
10104 {
10105 PyThreadState* __tstate = wxPyBeginAllowThreads();
10106 (arg1)->SetType(arg2);
10107
10108 wxPyEndAllowThreads(__tstate);
10109 if (PyErr_Occurred()) SWIG_fail;
10110 }
10111 Py_INCREF(Py_None); resultobj = Py_None;
10112 return resultobj;
10113 fail:
10114 return NULL;
10115 }
10116
10117
10118 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10119 PyObject *resultobj;
10120 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10121 wxString *arg2 = 0 ;
10122 bool temp2 = false ;
10123 PyObject * obj0 = 0 ;
10124 PyObject * obj1 = 0 ;
10125 char *kwnames[] = {
10126 (char *) "self",(char *) "mimetype", NULL
10127 };
10128
10129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10131 if (SWIG_arg_fail(1)) SWIG_fail;
10132 {
10133 arg2 = wxString_in_helper(obj1);
10134 if (arg2 == NULL) SWIG_fail;
10135 temp2 = true;
10136 }
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 (arg1)->SetMimeType((wxString const &)*arg2);
10140
10141 wxPyEndAllowThreads(__tstate);
10142 if (PyErr_Occurred()) SWIG_fail;
10143 }
10144 Py_INCREF(Py_None); resultobj = Py_None;
10145 {
10146 if (temp2)
10147 delete arg2;
10148 }
10149 return resultobj;
10150 fail:
10151 {
10152 if (temp2)
10153 delete arg2;
10154 }
10155 return NULL;
10156 }
10157
10158
10159 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10160 PyObject *obj;
10161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10162 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10163 Py_INCREF(obj);
10164 return Py_BuildValue((char *)"");
10165 }
10166 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10167 PyObject *resultobj;
10168 wxImageHistogram *result;
10169 char *kwnames[] = {
10170 NULL
10171 };
10172
10173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10174 {
10175 PyThreadState* __tstate = wxPyBeginAllowThreads();
10176 result = (wxImageHistogram *)new wxImageHistogram();
10177
10178 wxPyEndAllowThreads(__tstate);
10179 if (PyErr_Occurred()) SWIG_fail;
10180 }
10181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10182 return resultobj;
10183 fail:
10184 return NULL;
10185 }
10186
10187
10188 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10189 PyObject *resultobj;
10190 unsigned char arg1 ;
10191 unsigned char arg2 ;
10192 unsigned char arg3 ;
10193 unsigned long result;
10194 PyObject * obj0 = 0 ;
10195 PyObject * obj1 = 0 ;
10196 PyObject * obj2 = 0 ;
10197 char *kwnames[] = {
10198 (char *) "r",(char *) "g",(char *) "b", NULL
10199 };
10200
10201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10202 {
10203 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10204 if (SWIG_arg_fail(1)) SWIG_fail;
10205 }
10206 {
10207 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10208 if (SWIG_arg_fail(2)) SWIG_fail;
10209 }
10210 {
10211 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10212 if (SWIG_arg_fail(3)) SWIG_fail;
10213 }
10214 {
10215 PyThreadState* __tstate = wxPyBeginAllowThreads();
10216 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10217
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 {
10222 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10223 }
10224 return resultobj;
10225 fail:
10226 return NULL;
10227 }
10228
10229
10230 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10231 PyObject *resultobj;
10232 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10233 unsigned char *arg2 = (unsigned char *) 0 ;
10234 unsigned char *arg3 = (unsigned char *) 0 ;
10235 unsigned char *arg4 = (unsigned char *) 0 ;
10236 unsigned char arg5 = (unsigned char) 1 ;
10237 unsigned char arg6 = (unsigned char) 0 ;
10238 unsigned char arg7 = (unsigned char) 0 ;
10239 bool result;
10240 unsigned char temp2 ;
10241 int res2 = 0 ;
10242 unsigned char temp3 ;
10243 int res3 = 0 ;
10244 unsigned char temp4 ;
10245 int res4 = 0 ;
10246 PyObject * obj0 = 0 ;
10247 PyObject * obj1 = 0 ;
10248 PyObject * obj2 = 0 ;
10249 PyObject * obj3 = 0 ;
10250 char *kwnames[] = {
10251 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10252 };
10253
10254 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10255 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10256 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10259 if (SWIG_arg_fail(1)) SWIG_fail;
10260 if (obj1) {
10261 {
10262 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10263 if (SWIG_arg_fail(5)) SWIG_fail;
10264 }
10265 }
10266 if (obj2) {
10267 {
10268 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10269 if (SWIG_arg_fail(6)) SWIG_fail;
10270 }
10271 }
10272 if (obj3) {
10273 {
10274 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10275 if (SWIG_arg_fail(7)) SWIG_fail;
10276 }
10277 }
10278 {
10279 PyThreadState* __tstate = wxPyBeginAllowThreads();
10280 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10281
10282 wxPyEndAllowThreads(__tstate);
10283 if (PyErr_Occurred()) SWIG_fail;
10284 }
10285 {
10286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10287 }
10288 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10289 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10290 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10291 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10292 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10293 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10294 return resultobj;
10295 fail:
10296 return NULL;
10297 }
10298
10299
10300 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10301 PyObject *obj;
10302 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10303 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10304 Py_INCREF(obj);
10305 return Py_BuildValue((char *)"");
10306 }
10307 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj;
10309 wxString *arg1 = 0 ;
10310 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10311 int arg3 = (int) -1 ;
10312 wxImage *result;
10313 bool temp1 = false ;
10314 PyObject * obj0 = 0 ;
10315 PyObject * obj1 = 0 ;
10316 PyObject * obj2 = 0 ;
10317 char *kwnames[] = {
10318 (char *) "name",(char *) "type",(char *) "index", NULL
10319 };
10320
10321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10322 {
10323 arg1 = wxString_in_helper(obj0);
10324 if (arg1 == NULL) SWIG_fail;
10325 temp1 = true;
10326 }
10327 if (obj1) {
10328 {
10329 arg2 = (long)(SWIG_As_long(obj1));
10330 if (SWIG_arg_fail(2)) SWIG_fail;
10331 }
10332 }
10333 if (obj2) {
10334 {
10335 arg3 = (int)(SWIG_As_int(obj2));
10336 if (SWIG_arg_fail(3)) SWIG_fail;
10337 }
10338 }
10339 {
10340 PyThreadState* __tstate = wxPyBeginAllowThreads();
10341 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10342
10343 wxPyEndAllowThreads(__tstate);
10344 if (PyErr_Occurred()) SWIG_fail;
10345 }
10346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10347 {
10348 if (temp1)
10349 delete arg1;
10350 }
10351 return resultobj;
10352 fail:
10353 {
10354 if (temp1)
10355 delete arg1;
10356 }
10357 return NULL;
10358 }
10359
10360
10361 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10362 PyObject *resultobj;
10363 wxImage *arg1 = (wxImage *) 0 ;
10364 PyObject * obj0 = 0 ;
10365 char *kwnames[] = {
10366 (char *) "self", NULL
10367 };
10368
10369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10371 if (SWIG_arg_fail(1)) SWIG_fail;
10372 {
10373 PyThreadState* __tstate = wxPyBeginAllowThreads();
10374 delete arg1;
10375
10376 wxPyEndAllowThreads(__tstate);
10377 if (PyErr_Occurred()) SWIG_fail;
10378 }
10379 Py_INCREF(Py_None); resultobj = Py_None;
10380 return resultobj;
10381 fail:
10382 return NULL;
10383 }
10384
10385
10386 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10387 PyObject *resultobj;
10388 wxString *arg1 = 0 ;
10389 wxString *arg2 = 0 ;
10390 int arg3 = (int) -1 ;
10391 wxImage *result;
10392 bool temp1 = false ;
10393 bool temp2 = false ;
10394 PyObject * obj0 = 0 ;
10395 PyObject * obj1 = 0 ;
10396 PyObject * obj2 = 0 ;
10397 char *kwnames[] = {
10398 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10399 };
10400
10401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10402 {
10403 arg1 = wxString_in_helper(obj0);
10404 if (arg1 == NULL) SWIG_fail;
10405 temp1 = true;
10406 }
10407 {
10408 arg2 = wxString_in_helper(obj1);
10409 if (arg2 == NULL) SWIG_fail;
10410 temp2 = true;
10411 }
10412 if (obj2) {
10413 {
10414 arg3 = (int)(SWIG_As_int(obj2));
10415 if (SWIG_arg_fail(3)) SWIG_fail;
10416 }
10417 }
10418 {
10419 PyThreadState* __tstate = wxPyBeginAllowThreads();
10420 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10421
10422 wxPyEndAllowThreads(__tstate);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10426 {
10427 if (temp1)
10428 delete arg1;
10429 }
10430 {
10431 if (temp2)
10432 delete arg2;
10433 }
10434 return resultobj;
10435 fail:
10436 {
10437 if (temp1)
10438 delete arg1;
10439 }
10440 {
10441 if (temp2)
10442 delete arg2;
10443 }
10444 return NULL;
10445 }
10446
10447
10448 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10449 PyObject *resultobj;
10450 wxInputStream *arg1 = 0 ;
10451 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10452 int arg3 = (int) -1 ;
10453 wxImage *result;
10454 wxPyInputStream *temp1 ;
10455 bool created1 ;
10456 PyObject * obj0 = 0 ;
10457 PyObject * obj1 = 0 ;
10458 PyObject * obj2 = 0 ;
10459 char *kwnames[] = {
10460 (char *) "stream",(char *) "type",(char *) "index", NULL
10461 };
10462
10463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10464 {
10465 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10466 arg1 = temp1->m_wxis;
10467 created1 = false;
10468 } else {
10469 PyErr_Clear(); // clear the failure of the wxPyConvert above
10470 arg1 = wxPyCBInputStream_create(obj0, false);
10471 if (arg1 == NULL) {
10472 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10473 SWIG_fail;
10474 }
10475 created1 = true;
10476 }
10477 }
10478 if (obj1) {
10479 {
10480 arg2 = (long)(SWIG_As_long(obj1));
10481 if (SWIG_arg_fail(2)) SWIG_fail;
10482 }
10483 }
10484 if (obj2) {
10485 {
10486 arg3 = (int)(SWIG_As_int(obj2));
10487 if (SWIG_arg_fail(3)) SWIG_fail;
10488 }
10489 }
10490 {
10491 PyThreadState* __tstate = wxPyBeginAllowThreads();
10492 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10493
10494 wxPyEndAllowThreads(__tstate);
10495 if (PyErr_Occurred()) SWIG_fail;
10496 }
10497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10498 {
10499 if (created1)
10500 delete arg1;
10501 }
10502 return resultobj;
10503 fail:
10504 {
10505 if (created1)
10506 delete arg1;
10507 }
10508 return NULL;
10509 }
10510
10511
10512 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10513 PyObject *resultobj;
10514 wxInputStream *arg1 = 0 ;
10515 wxString *arg2 = 0 ;
10516 int arg3 = (int) -1 ;
10517 wxImage *result;
10518 wxPyInputStream *temp1 ;
10519 bool created1 ;
10520 bool temp2 = false ;
10521 PyObject * obj0 = 0 ;
10522 PyObject * obj1 = 0 ;
10523 PyObject * obj2 = 0 ;
10524 char *kwnames[] = {
10525 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10526 };
10527
10528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10529 {
10530 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10531 arg1 = temp1->m_wxis;
10532 created1 = false;
10533 } else {
10534 PyErr_Clear(); // clear the failure of the wxPyConvert above
10535 arg1 = wxPyCBInputStream_create(obj0, false);
10536 if (arg1 == NULL) {
10537 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10538 SWIG_fail;
10539 }
10540 created1 = true;
10541 }
10542 }
10543 {
10544 arg2 = wxString_in_helper(obj1);
10545 if (arg2 == NULL) SWIG_fail;
10546 temp2 = true;
10547 }
10548 if (obj2) {
10549 {
10550 arg3 = (int)(SWIG_As_int(obj2));
10551 if (SWIG_arg_fail(3)) SWIG_fail;
10552 }
10553 }
10554 {
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10557
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10562 {
10563 if (created1)
10564 delete arg1;
10565 }
10566 {
10567 if (temp2)
10568 delete arg2;
10569 }
10570 return resultobj;
10571 fail:
10572 {
10573 if (created1)
10574 delete arg1;
10575 }
10576 {
10577 if (temp2)
10578 delete arg2;
10579 }
10580 return NULL;
10581 }
10582
10583
10584 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj;
10586 int arg1 = (int) 0 ;
10587 int arg2 = (int) 0 ;
10588 bool arg3 = (bool) true ;
10589 wxImage *result;
10590 PyObject * obj0 = 0 ;
10591 PyObject * obj1 = 0 ;
10592 PyObject * obj2 = 0 ;
10593 char *kwnames[] = {
10594 (char *) "width",(char *) "height",(char *) "clear", NULL
10595 };
10596
10597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10598 if (obj0) {
10599 {
10600 arg1 = (int)(SWIG_As_int(obj0));
10601 if (SWIG_arg_fail(1)) SWIG_fail;
10602 }
10603 }
10604 if (obj1) {
10605 {
10606 arg2 = (int)(SWIG_As_int(obj1));
10607 if (SWIG_arg_fail(2)) SWIG_fail;
10608 }
10609 }
10610 if (obj2) {
10611 {
10612 arg3 = (bool)(SWIG_As_bool(obj2));
10613 if (SWIG_arg_fail(3)) SWIG_fail;
10614 }
10615 }
10616 {
10617 PyThreadState* __tstate = wxPyBeginAllowThreads();
10618 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10619
10620 wxPyEndAllowThreads(__tstate);
10621 if (PyErr_Occurred()) SWIG_fail;
10622 }
10623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10624 return resultobj;
10625 fail:
10626 return NULL;
10627 }
10628
10629
10630 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10631 PyObject *resultobj;
10632 wxBitmap *arg1 = 0 ;
10633 wxImage *result;
10634 PyObject * obj0 = 0 ;
10635 char *kwnames[] = {
10636 (char *) "bitmap", NULL
10637 };
10638
10639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10640 {
10641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10642 if (SWIG_arg_fail(1)) SWIG_fail;
10643 if (arg1 == NULL) {
10644 SWIG_null_ref("wxBitmap");
10645 }
10646 if (SWIG_arg_fail(1)) SWIG_fail;
10647 }
10648 {
10649 if (!wxPyCheckForApp()) SWIG_fail;
10650 PyThreadState* __tstate = wxPyBeginAllowThreads();
10651 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10652
10653 wxPyEndAllowThreads(__tstate);
10654 if (PyErr_Occurred()) SWIG_fail;
10655 }
10656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10657 return resultobj;
10658 fail:
10659 return NULL;
10660 }
10661
10662
10663 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10664 PyObject *resultobj;
10665 int arg1 ;
10666 int arg2 ;
10667 unsigned char *arg3 = (unsigned char *) 0 ;
10668 wxImage *result;
10669 PyObject * obj0 = 0 ;
10670 PyObject * obj1 = 0 ;
10671 PyObject * obj2 = 0 ;
10672 char *kwnames[] = {
10673 (char *) "width",(char *) "height",(char *) "data", NULL
10674 };
10675
10676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10677 {
10678 arg1 = (int)(SWIG_As_int(obj0));
10679 if (SWIG_arg_fail(1)) SWIG_fail;
10680 }
10681 {
10682 arg2 = (int)(SWIG_As_int(obj1));
10683 if (SWIG_arg_fail(2)) SWIG_fail;
10684 }
10685 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10686 if (SWIG_arg_fail(3)) SWIG_fail;
10687 {
10688 PyThreadState* __tstate = wxPyBeginAllowThreads();
10689 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10690
10691 wxPyEndAllowThreads(__tstate);
10692 if (PyErr_Occurred()) SWIG_fail;
10693 }
10694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10695 return resultobj;
10696 fail:
10697 return NULL;
10698 }
10699
10700
10701 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10702 PyObject *resultobj;
10703 int arg1 ;
10704 int arg2 ;
10705 unsigned char *arg3 = (unsigned char *) 0 ;
10706 unsigned char *arg4 = (unsigned char *) 0 ;
10707 wxImage *result;
10708 PyObject * obj0 = 0 ;
10709 PyObject * obj1 = 0 ;
10710 PyObject * obj2 = 0 ;
10711 PyObject * obj3 = 0 ;
10712 char *kwnames[] = {
10713 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10714 };
10715
10716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10717 {
10718 arg1 = (int)(SWIG_As_int(obj0));
10719 if (SWIG_arg_fail(1)) SWIG_fail;
10720 }
10721 {
10722 arg2 = (int)(SWIG_As_int(obj1));
10723 if (SWIG_arg_fail(2)) SWIG_fail;
10724 }
10725 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10726 if (SWIG_arg_fail(3)) SWIG_fail;
10727 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10728 if (SWIG_arg_fail(4)) SWIG_fail;
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10732
10733 wxPyEndAllowThreads(__tstate);
10734 if (PyErr_Occurred()) SWIG_fail;
10735 }
10736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10737 return resultobj;
10738 fail:
10739 return NULL;
10740 }
10741
10742
10743 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10744 PyObject *resultobj;
10745 wxImage *arg1 = (wxImage *) 0 ;
10746 int arg2 ;
10747 int arg3 ;
10748 PyObject * obj0 = 0 ;
10749 PyObject * obj1 = 0 ;
10750 PyObject * obj2 = 0 ;
10751 char *kwnames[] = {
10752 (char *) "self",(char *) "width",(char *) "height", NULL
10753 };
10754
10755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10757 if (SWIG_arg_fail(1)) SWIG_fail;
10758 {
10759 arg2 = (int)(SWIG_As_int(obj1));
10760 if (SWIG_arg_fail(2)) SWIG_fail;
10761 }
10762 {
10763 arg3 = (int)(SWIG_As_int(obj2));
10764 if (SWIG_arg_fail(3)) SWIG_fail;
10765 }
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 (arg1)->Create(arg2,arg3);
10769
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 Py_INCREF(Py_None); resultobj = Py_None;
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10781 PyObject *resultobj;
10782 wxImage *arg1 = (wxImage *) 0 ;
10783 PyObject * obj0 = 0 ;
10784 char *kwnames[] = {
10785 (char *) "self", NULL
10786 };
10787
10788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10790 if (SWIG_arg_fail(1)) SWIG_fail;
10791 {
10792 PyThreadState* __tstate = wxPyBeginAllowThreads();
10793 (arg1)->Destroy();
10794
10795 wxPyEndAllowThreads(__tstate);
10796 if (PyErr_Occurred()) SWIG_fail;
10797 }
10798 Py_INCREF(Py_None); resultobj = Py_None;
10799 return resultobj;
10800 fail:
10801 return NULL;
10802 }
10803
10804
10805 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10806 PyObject *resultobj;
10807 wxImage *arg1 = (wxImage *) 0 ;
10808 int arg2 ;
10809 int arg3 ;
10810 SwigValueWrapper<wxImage > result;
10811 PyObject * obj0 = 0 ;
10812 PyObject * obj1 = 0 ;
10813 PyObject * obj2 = 0 ;
10814 char *kwnames[] = {
10815 (char *) "self",(char *) "width",(char *) "height", NULL
10816 };
10817
10818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10820 if (SWIG_arg_fail(1)) SWIG_fail;
10821 {
10822 arg2 = (int)(SWIG_As_int(obj1));
10823 if (SWIG_arg_fail(2)) SWIG_fail;
10824 }
10825 {
10826 arg3 = (int)(SWIG_As_int(obj2));
10827 if (SWIG_arg_fail(3)) SWIG_fail;
10828 }
10829 {
10830 PyThreadState* __tstate = wxPyBeginAllowThreads();
10831 result = (arg1)->Scale(arg2,arg3);
10832
10833 wxPyEndAllowThreads(__tstate);
10834 if (PyErr_Occurred()) SWIG_fail;
10835 }
10836 {
10837 wxImage * resultptr;
10838 resultptr = new wxImage((wxImage &)(result));
10839 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10840 }
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj;
10849 wxImage *arg1 = (wxImage *) 0 ;
10850 int arg2 ;
10851 int arg3 ;
10852 SwigValueWrapper<wxImage > result;
10853 PyObject * obj0 = 0 ;
10854 PyObject * obj1 = 0 ;
10855 PyObject * obj2 = 0 ;
10856 char *kwnames[] = {
10857 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10858 };
10859
10860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10862 if (SWIG_arg_fail(1)) SWIG_fail;
10863 {
10864 arg2 = (int)(SWIG_As_int(obj1));
10865 if (SWIG_arg_fail(2)) SWIG_fail;
10866 }
10867 {
10868 arg3 = (int)(SWIG_As_int(obj2));
10869 if (SWIG_arg_fail(3)) SWIG_fail;
10870 }
10871 {
10872 PyThreadState* __tstate = wxPyBeginAllowThreads();
10873 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10874
10875 wxPyEndAllowThreads(__tstate);
10876 if (PyErr_Occurred()) SWIG_fail;
10877 }
10878 {
10879 wxImage * resultptr;
10880 resultptr = new wxImage((wxImage &)(result));
10881 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10882 }
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj;
10891 wxImage *arg1 = (wxImage *) 0 ;
10892 int arg2 ;
10893 int arg3 ;
10894 wxImage *result;
10895 PyObject * obj0 = 0 ;
10896 PyObject * obj1 = 0 ;
10897 PyObject * obj2 = 0 ;
10898 char *kwnames[] = {
10899 (char *) "self",(char *) "width",(char *) "height", NULL
10900 };
10901
10902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10904 if (SWIG_arg_fail(1)) SWIG_fail;
10905 {
10906 arg2 = (int)(SWIG_As_int(obj1));
10907 if (SWIG_arg_fail(2)) SWIG_fail;
10908 }
10909 {
10910 arg3 = (int)(SWIG_As_int(obj2));
10911 if (SWIG_arg_fail(3)) SWIG_fail;
10912 }
10913 {
10914 PyThreadState* __tstate = wxPyBeginAllowThreads();
10915 {
10916 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10917 result = (wxImage *) &_result_ref;
10918 }
10919
10920 wxPyEndAllowThreads(__tstate);
10921 if (PyErr_Occurred()) SWIG_fail;
10922 }
10923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10924 return resultobj;
10925 fail:
10926 return NULL;
10927 }
10928
10929
10930 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10931 PyObject *resultobj;
10932 wxImage *arg1 = (wxImage *) 0 ;
10933 int arg2 ;
10934 int arg3 ;
10935 unsigned char arg4 ;
10936 unsigned char arg5 ;
10937 unsigned char arg6 ;
10938 PyObject * obj0 = 0 ;
10939 PyObject * obj1 = 0 ;
10940 PyObject * obj2 = 0 ;
10941 PyObject * obj3 = 0 ;
10942 PyObject * obj4 = 0 ;
10943 PyObject * obj5 = 0 ;
10944 char *kwnames[] = {
10945 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10946 };
10947
10948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10950 if (SWIG_arg_fail(1)) SWIG_fail;
10951 {
10952 arg2 = (int)(SWIG_As_int(obj1));
10953 if (SWIG_arg_fail(2)) SWIG_fail;
10954 }
10955 {
10956 arg3 = (int)(SWIG_As_int(obj2));
10957 if (SWIG_arg_fail(3)) SWIG_fail;
10958 }
10959 {
10960 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10961 if (SWIG_arg_fail(4)) SWIG_fail;
10962 }
10963 {
10964 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10965 if (SWIG_arg_fail(5)) SWIG_fail;
10966 }
10967 {
10968 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10969 if (SWIG_arg_fail(6)) SWIG_fail;
10970 }
10971 {
10972 PyThreadState* __tstate = wxPyBeginAllowThreads();
10973 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10974
10975 wxPyEndAllowThreads(__tstate);
10976 if (PyErr_Occurred()) SWIG_fail;
10977 }
10978 Py_INCREF(Py_None); resultobj = Py_None;
10979 return resultobj;
10980 fail:
10981 return NULL;
10982 }
10983
10984
10985 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10986 PyObject *resultobj;
10987 wxImage *arg1 = (wxImage *) 0 ;
10988 int arg2 ;
10989 int arg3 ;
10990 unsigned char result;
10991 PyObject * obj0 = 0 ;
10992 PyObject * obj1 = 0 ;
10993 PyObject * obj2 = 0 ;
10994 char *kwnames[] = {
10995 (char *) "self",(char *) "x",(char *) "y", NULL
10996 };
10997
10998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11000 if (SWIG_arg_fail(1)) SWIG_fail;
11001 {
11002 arg2 = (int)(SWIG_As_int(obj1));
11003 if (SWIG_arg_fail(2)) SWIG_fail;
11004 }
11005 {
11006 arg3 = (int)(SWIG_As_int(obj2));
11007 if (SWIG_arg_fail(3)) SWIG_fail;
11008 }
11009 {
11010 PyThreadState* __tstate = wxPyBeginAllowThreads();
11011 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11012
11013 wxPyEndAllowThreads(__tstate);
11014 if (PyErr_Occurred()) SWIG_fail;
11015 }
11016 {
11017 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11018 }
11019 return resultobj;
11020 fail:
11021 return NULL;
11022 }
11023
11024
11025 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11026 PyObject *resultobj;
11027 wxImage *arg1 = (wxImage *) 0 ;
11028 int arg2 ;
11029 int arg3 ;
11030 unsigned char result;
11031 PyObject * obj0 = 0 ;
11032 PyObject * obj1 = 0 ;
11033 PyObject * obj2 = 0 ;
11034 char *kwnames[] = {
11035 (char *) "self",(char *) "x",(char *) "y", NULL
11036 };
11037
11038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11040 if (SWIG_arg_fail(1)) SWIG_fail;
11041 {
11042 arg2 = (int)(SWIG_As_int(obj1));
11043 if (SWIG_arg_fail(2)) SWIG_fail;
11044 }
11045 {
11046 arg3 = (int)(SWIG_As_int(obj2));
11047 if (SWIG_arg_fail(3)) SWIG_fail;
11048 }
11049 {
11050 PyThreadState* __tstate = wxPyBeginAllowThreads();
11051 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11052
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 {
11057 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11058 }
11059 return resultobj;
11060 fail:
11061 return NULL;
11062 }
11063
11064
11065 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11066 PyObject *resultobj;
11067 wxImage *arg1 = (wxImage *) 0 ;
11068 int arg2 ;
11069 int arg3 ;
11070 unsigned char result;
11071 PyObject * obj0 = 0 ;
11072 PyObject * obj1 = 0 ;
11073 PyObject * obj2 = 0 ;
11074 char *kwnames[] = {
11075 (char *) "self",(char *) "x",(char *) "y", NULL
11076 };
11077
11078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11080 if (SWIG_arg_fail(1)) SWIG_fail;
11081 {
11082 arg2 = (int)(SWIG_As_int(obj1));
11083 if (SWIG_arg_fail(2)) SWIG_fail;
11084 }
11085 {
11086 arg3 = (int)(SWIG_As_int(obj2));
11087 if (SWIG_arg_fail(3)) SWIG_fail;
11088 }
11089 {
11090 PyThreadState* __tstate = wxPyBeginAllowThreads();
11091 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11092
11093 wxPyEndAllowThreads(__tstate);
11094 if (PyErr_Occurred()) SWIG_fail;
11095 }
11096 {
11097 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11098 }
11099 return resultobj;
11100 fail:
11101 return NULL;
11102 }
11103
11104
11105 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11106 PyObject *resultobj;
11107 wxImage *arg1 = (wxImage *) 0 ;
11108 int arg2 ;
11109 int arg3 ;
11110 unsigned char arg4 ;
11111 PyObject * obj0 = 0 ;
11112 PyObject * obj1 = 0 ;
11113 PyObject * obj2 = 0 ;
11114 PyObject * obj3 = 0 ;
11115 char *kwnames[] = {
11116 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11117 };
11118
11119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 = (int)(SWIG_As_int(obj1));
11124 if (SWIG_arg_fail(2)) SWIG_fail;
11125 }
11126 {
11127 arg3 = (int)(SWIG_As_int(obj2));
11128 if (SWIG_arg_fail(3)) SWIG_fail;
11129 }
11130 {
11131 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11132 if (SWIG_arg_fail(4)) SWIG_fail;
11133 }
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 (arg1)->SetAlpha(arg2,arg3,arg4);
11137
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 Py_INCREF(Py_None); resultobj = Py_None;
11142 return resultobj;
11143 fail:
11144 return NULL;
11145 }
11146
11147
11148 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj;
11150 wxImage *arg1 = (wxImage *) 0 ;
11151 int arg2 ;
11152 int arg3 ;
11153 unsigned char result;
11154 PyObject * obj0 = 0 ;
11155 PyObject * obj1 = 0 ;
11156 PyObject * obj2 = 0 ;
11157 char *kwnames[] = {
11158 (char *) "self",(char *) "x",(char *) "y", NULL
11159 };
11160
11161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11163 if (SWIG_arg_fail(1)) SWIG_fail;
11164 {
11165 arg2 = (int)(SWIG_As_int(obj1));
11166 if (SWIG_arg_fail(2)) SWIG_fail;
11167 }
11168 {
11169 arg3 = (int)(SWIG_As_int(obj2));
11170 if (SWIG_arg_fail(3)) SWIG_fail;
11171 }
11172 {
11173 PyThreadState* __tstate = wxPyBeginAllowThreads();
11174 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11175
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 {
11180 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11181 }
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11189 PyObject *resultobj;
11190 wxImage *arg1 = (wxImage *) 0 ;
11191 bool result;
11192 PyObject * obj0 = 0 ;
11193 char *kwnames[] = {
11194 (char *) "self", NULL
11195 };
11196
11197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11199 if (SWIG_arg_fail(1)) SWIG_fail;
11200 {
11201 PyThreadState* __tstate = wxPyBeginAllowThreads();
11202 result = (bool)(arg1)->HasAlpha();
11203
11204 wxPyEndAllowThreads(__tstate);
11205 if (PyErr_Occurred()) SWIG_fail;
11206 }
11207 {
11208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11209 }
11210 return resultobj;
11211 fail:
11212 return NULL;
11213 }
11214
11215
11216 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11217 PyObject *resultobj;
11218 wxImage *arg1 = (wxImage *) 0 ;
11219 PyObject * obj0 = 0 ;
11220 char *kwnames[] = {
11221 (char *) "self", NULL
11222 };
11223
11224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11226 if (SWIG_arg_fail(1)) SWIG_fail;
11227 {
11228 PyThreadState* __tstate = wxPyBeginAllowThreads();
11229 (arg1)->InitAlpha();
11230
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 Py_INCREF(Py_None); resultobj = Py_None;
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj;
11243 wxImage *arg1 = (wxImage *) 0 ;
11244 byte *arg2 = (byte *) 0 ;
11245 byte *arg3 = (byte *) 0 ;
11246 byte *arg4 = (byte *) 0 ;
11247 byte arg5 = (byte) 0 ;
11248 byte arg6 = (byte) 0 ;
11249 byte arg7 = (byte) 0 ;
11250 bool result;
11251 byte temp2 ;
11252 int res2 = 0 ;
11253 byte temp3 ;
11254 int res3 = 0 ;
11255 byte temp4 ;
11256 int res4 = 0 ;
11257 PyObject * obj0 = 0 ;
11258 PyObject * obj1 = 0 ;
11259 PyObject * obj2 = 0 ;
11260 PyObject * obj3 = 0 ;
11261 char *kwnames[] = {
11262 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11263 };
11264
11265 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11266 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11267 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11270 if (SWIG_arg_fail(1)) SWIG_fail;
11271 if (obj1) {
11272 {
11273 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11274 if (SWIG_arg_fail(5)) SWIG_fail;
11275 }
11276 }
11277 if (obj2) {
11278 {
11279 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11280 if (SWIG_arg_fail(6)) SWIG_fail;
11281 }
11282 }
11283 if (obj3) {
11284 {
11285 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11286 if (SWIG_arg_fail(7)) SWIG_fail;
11287 }
11288 }
11289 {
11290 PyThreadState* __tstate = wxPyBeginAllowThreads();
11291 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11292
11293 wxPyEndAllowThreads(__tstate);
11294 if (PyErr_Occurred()) SWIG_fail;
11295 }
11296 {
11297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11298 }
11299 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11300 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11301 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11302 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11303 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11304 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11305 return resultobj;
11306 fail:
11307 return NULL;
11308 }
11309
11310
11311 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11312 PyObject *resultobj;
11313 wxImage *arg1 = (wxImage *) 0 ;
11314 byte arg2 = (byte) 128 ;
11315 bool result;
11316 PyObject * obj0 = 0 ;
11317 PyObject * obj1 = 0 ;
11318 char *kwnames[] = {
11319 (char *) "self",(char *) "threshold", NULL
11320 };
11321
11322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11324 if (SWIG_arg_fail(1)) SWIG_fail;
11325 if (obj1) {
11326 {
11327 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11328 if (SWIG_arg_fail(2)) SWIG_fail;
11329 }
11330 }
11331 {
11332 PyThreadState* __tstate = wxPyBeginAllowThreads();
11333 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11334
11335 wxPyEndAllowThreads(__tstate);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 {
11339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11340 }
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11348 PyObject *resultobj;
11349 wxImage *arg1 = (wxImage *) 0 ;
11350 unsigned char arg2 ;
11351 unsigned char arg3 ;
11352 unsigned char arg4 ;
11353 bool result;
11354 PyObject * obj0 = 0 ;
11355 PyObject * obj1 = 0 ;
11356 PyObject * obj2 = 0 ;
11357 PyObject * obj3 = 0 ;
11358 char *kwnames[] = {
11359 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11360 };
11361
11362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11364 if (SWIG_arg_fail(1)) SWIG_fail;
11365 {
11366 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11367 if (SWIG_arg_fail(2)) SWIG_fail;
11368 }
11369 {
11370 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11371 if (SWIG_arg_fail(3)) SWIG_fail;
11372 }
11373 {
11374 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11375 if (SWIG_arg_fail(4)) SWIG_fail;
11376 }
11377 {
11378 PyThreadState* __tstate = wxPyBeginAllowThreads();
11379 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11380
11381 wxPyEndAllowThreads(__tstate);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 {
11385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11386 }
11387 return resultobj;
11388 fail:
11389 return NULL;
11390 }
11391
11392
11393 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11394 PyObject *resultobj;
11395 wxImage *arg1 = (wxImage *) 0 ;
11396 wxImage *arg2 = 0 ;
11397 byte arg3 ;
11398 byte arg4 ;
11399 byte arg5 ;
11400 bool result;
11401 PyObject * obj0 = 0 ;
11402 PyObject * obj1 = 0 ;
11403 PyObject * obj2 = 0 ;
11404 PyObject * obj3 = 0 ;
11405 PyObject * obj4 = 0 ;
11406 char *kwnames[] = {
11407 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11408 };
11409
11410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11412 if (SWIG_arg_fail(1)) SWIG_fail;
11413 {
11414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11415 if (SWIG_arg_fail(2)) SWIG_fail;
11416 if (arg2 == NULL) {
11417 SWIG_null_ref("wxImage");
11418 }
11419 if (SWIG_arg_fail(2)) SWIG_fail;
11420 }
11421 {
11422 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11423 if (SWIG_arg_fail(3)) SWIG_fail;
11424 }
11425 {
11426 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11427 if (SWIG_arg_fail(4)) SWIG_fail;
11428 }
11429 {
11430 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11431 if (SWIG_arg_fail(5)) SWIG_fail;
11432 }
11433 {
11434 PyThreadState* __tstate = wxPyBeginAllowThreads();
11435 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11436
11437 wxPyEndAllowThreads(__tstate);
11438 if (PyErr_Occurred()) SWIG_fail;
11439 }
11440 {
11441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11442 }
11443 return resultobj;
11444 fail:
11445 return NULL;
11446 }
11447
11448
11449 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11450 PyObject *resultobj;
11451 wxString *arg1 = 0 ;
11452 bool result;
11453 bool temp1 = false ;
11454 PyObject * obj0 = 0 ;
11455 char *kwnames[] = {
11456 (char *) "name", NULL
11457 };
11458
11459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11460 {
11461 arg1 = wxString_in_helper(obj0);
11462 if (arg1 == NULL) SWIG_fail;
11463 temp1 = true;
11464 }
11465 {
11466 PyThreadState* __tstate = wxPyBeginAllowThreads();
11467 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11468
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 {
11473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11474 }
11475 {
11476 if (temp1)
11477 delete arg1;
11478 }
11479 return resultobj;
11480 fail:
11481 {
11482 if (temp1)
11483 delete arg1;
11484 }
11485 return NULL;
11486 }
11487
11488
11489 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11490 PyObject *resultobj;
11491 wxString *arg1 = 0 ;
11492 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11493 int result;
11494 bool temp1 = false ;
11495 PyObject * obj0 = 0 ;
11496 PyObject * obj1 = 0 ;
11497 char *kwnames[] = {
11498 (char *) "name",(char *) "type", NULL
11499 };
11500
11501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11502 {
11503 arg1 = wxString_in_helper(obj0);
11504 if (arg1 == NULL) SWIG_fail;
11505 temp1 = true;
11506 }
11507 if (obj1) {
11508 {
11509 arg2 = (long)(SWIG_As_long(obj1));
11510 if (SWIG_arg_fail(2)) SWIG_fail;
11511 }
11512 }
11513 {
11514 PyThreadState* __tstate = wxPyBeginAllowThreads();
11515 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11516
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 {
11521 resultobj = SWIG_From_int((int)(result));
11522 }
11523 {
11524 if (temp1)
11525 delete arg1;
11526 }
11527 return resultobj;
11528 fail:
11529 {
11530 if (temp1)
11531 delete arg1;
11532 }
11533 return NULL;
11534 }
11535
11536
11537 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11538 PyObject *resultobj;
11539 wxImage *arg1 = (wxImage *) 0 ;
11540 wxString *arg2 = 0 ;
11541 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11542 int arg4 = (int) -1 ;
11543 bool result;
11544 bool temp2 = false ;
11545 PyObject * obj0 = 0 ;
11546 PyObject * obj1 = 0 ;
11547 PyObject * obj2 = 0 ;
11548 PyObject * obj3 = 0 ;
11549 char *kwnames[] = {
11550 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11551 };
11552
11553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11555 if (SWIG_arg_fail(1)) SWIG_fail;
11556 {
11557 arg2 = wxString_in_helper(obj1);
11558 if (arg2 == NULL) SWIG_fail;
11559 temp2 = true;
11560 }
11561 if (obj2) {
11562 {
11563 arg3 = (long)(SWIG_As_long(obj2));
11564 if (SWIG_arg_fail(3)) SWIG_fail;
11565 }
11566 }
11567 if (obj3) {
11568 {
11569 arg4 = (int)(SWIG_As_int(obj3));
11570 if (SWIG_arg_fail(4)) SWIG_fail;
11571 }
11572 }
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11576
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 {
11581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11582 }
11583 {
11584 if (temp2)
11585 delete arg2;
11586 }
11587 return resultobj;
11588 fail:
11589 {
11590 if (temp2)
11591 delete arg2;
11592 }
11593 return NULL;
11594 }
11595
11596
11597 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11598 PyObject *resultobj;
11599 wxImage *arg1 = (wxImage *) 0 ;
11600 wxString *arg2 = 0 ;
11601 wxString *arg3 = 0 ;
11602 int arg4 = (int) -1 ;
11603 bool result;
11604 bool temp2 = false ;
11605 bool temp3 = false ;
11606 PyObject * obj0 = 0 ;
11607 PyObject * obj1 = 0 ;
11608 PyObject * obj2 = 0 ;
11609 PyObject * obj3 = 0 ;
11610 char *kwnames[] = {
11611 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11612 };
11613
11614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11616 if (SWIG_arg_fail(1)) SWIG_fail;
11617 {
11618 arg2 = wxString_in_helper(obj1);
11619 if (arg2 == NULL) SWIG_fail;
11620 temp2 = true;
11621 }
11622 {
11623 arg3 = wxString_in_helper(obj2);
11624 if (arg3 == NULL) SWIG_fail;
11625 temp3 = true;
11626 }
11627 if (obj3) {
11628 {
11629 arg4 = (int)(SWIG_As_int(obj3));
11630 if (SWIG_arg_fail(4)) SWIG_fail;
11631 }
11632 }
11633 {
11634 PyThreadState* __tstate = wxPyBeginAllowThreads();
11635 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11636
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 {
11641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11642 }
11643 {
11644 if (temp2)
11645 delete arg2;
11646 }
11647 {
11648 if (temp3)
11649 delete arg3;
11650 }
11651 return resultobj;
11652 fail:
11653 {
11654 if (temp2)
11655 delete arg2;
11656 }
11657 {
11658 if (temp3)
11659 delete arg3;
11660 }
11661 return NULL;
11662 }
11663
11664
11665 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11666 PyObject *resultobj;
11667 wxImage *arg1 = (wxImage *) 0 ;
11668 wxString *arg2 = 0 ;
11669 int arg3 ;
11670 bool result;
11671 bool temp2 = false ;
11672 PyObject * obj0 = 0 ;
11673 PyObject * obj1 = 0 ;
11674 PyObject * obj2 = 0 ;
11675 char *kwnames[] = {
11676 (char *) "self",(char *) "name",(char *) "type", NULL
11677 };
11678
11679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11681 if (SWIG_arg_fail(1)) SWIG_fail;
11682 {
11683 arg2 = wxString_in_helper(obj1);
11684 if (arg2 == NULL) SWIG_fail;
11685 temp2 = true;
11686 }
11687 {
11688 arg3 = (int)(SWIG_As_int(obj2));
11689 if (SWIG_arg_fail(3)) SWIG_fail;
11690 }
11691 {
11692 PyThreadState* __tstate = wxPyBeginAllowThreads();
11693 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11694
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 {
11699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11700 }
11701 {
11702 if (temp2)
11703 delete arg2;
11704 }
11705 return resultobj;
11706 fail:
11707 {
11708 if (temp2)
11709 delete arg2;
11710 }
11711 return NULL;
11712 }
11713
11714
11715 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11716 PyObject *resultobj;
11717 wxImage *arg1 = (wxImage *) 0 ;
11718 wxString *arg2 = 0 ;
11719 wxString *arg3 = 0 ;
11720 bool result;
11721 bool temp2 = false ;
11722 bool temp3 = false ;
11723 PyObject * obj0 = 0 ;
11724 PyObject * obj1 = 0 ;
11725 PyObject * obj2 = 0 ;
11726 char *kwnames[] = {
11727 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11728 };
11729
11730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11732 if (SWIG_arg_fail(1)) SWIG_fail;
11733 {
11734 arg2 = wxString_in_helper(obj1);
11735 if (arg2 == NULL) SWIG_fail;
11736 temp2 = true;
11737 }
11738 {
11739 arg3 = wxString_in_helper(obj2);
11740 if (arg3 == NULL) SWIG_fail;
11741 temp3 = true;
11742 }
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11752 }
11753 {
11754 if (temp2)
11755 delete arg2;
11756 }
11757 {
11758 if (temp3)
11759 delete arg3;
11760 }
11761 return resultobj;
11762 fail:
11763 {
11764 if (temp2)
11765 delete arg2;
11766 }
11767 {
11768 if (temp3)
11769 delete arg3;
11770 }
11771 return NULL;
11772 }
11773
11774
11775 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11776 PyObject *resultobj;
11777 wxInputStream *arg1 = 0 ;
11778 bool result;
11779 wxPyInputStream *temp1 ;
11780 bool created1 ;
11781 PyObject * obj0 = 0 ;
11782 char *kwnames[] = {
11783 (char *) "stream", NULL
11784 };
11785
11786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11787 {
11788 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11789 arg1 = temp1->m_wxis;
11790 created1 = false;
11791 } else {
11792 PyErr_Clear(); // clear the failure of the wxPyConvert above
11793 arg1 = wxPyCBInputStream_create(obj0, false);
11794 if (arg1 == NULL) {
11795 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11796 SWIG_fail;
11797 }
11798 created1 = true;
11799 }
11800 }
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 result = (bool)wxImage::CanRead(*arg1);
11804
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 {
11809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11810 }
11811 {
11812 if (created1)
11813 delete arg1;
11814 }
11815 return resultobj;
11816 fail:
11817 {
11818 if (created1)
11819 delete arg1;
11820 }
11821 return NULL;
11822 }
11823
11824
11825 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11826 PyObject *resultobj;
11827 wxImage *arg1 = (wxImage *) 0 ;
11828 wxInputStream *arg2 = 0 ;
11829 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11830 int arg4 = (int) -1 ;
11831 bool result;
11832 wxPyInputStream *temp2 ;
11833 bool created2 ;
11834 PyObject * obj0 = 0 ;
11835 PyObject * obj1 = 0 ;
11836 PyObject * obj2 = 0 ;
11837 PyObject * obj3 = 0 ;
11838 char *kwnames[] = {
11839 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11840 };
11841
11842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11844 if (SWIG_arg_fail(1)) SWIG_fail;
11845 {
11846 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11847 arg2 = temp2->m_wxis;
11848 created2 = false;
11849 } else {
11850 PyErr_Clear(); // clear the failure of the wxPyConvert above
11851 arg2 = wxPyCBInputStream_create(obj1, false);
11852 if (arg2 == NULL) {
11853 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11854 SWIG_fail;
11855 }
11856 created2 = true;
11857 }
11858 }
11859 if (obj2) {
11860 {
11861 arg3 = (long)(SWIG_As_long(obj2));
11862 if (SWIG_arg_fail(3)) SWIG_fail;
11863 }
11864 }
11865 if (obj3) {
11866 {
11867 arg4 = (int)(SWIG_As_int(obj3));
11868 if (SWIG_arg_fail(4)) SWIG_fail;
11869 }
11870 }
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11874
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11880 }
11881 {
11882 if (created2)
11883 delete arg2;
11884 }
11885 return resultobj;
11886 fail:
11887 {
11888 if (created2)
11889 delete arg2;
11890 }
11891 return NULL;
11892 }
11893
11894
11895 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11896 PyObject *resultobj;
11897 wxImage *arg1 = (wxImage *) 0 ;
11898 wxInputStream *arg2 = 0 ;
11899 wxString *arg3 = 0 ;
11900 int arg4 = (int) -1 ;
11901 bool result;
11902 wxPyInputStream *temp2 ;
11903 bool created2 ;
11904 bool temp3 = false ;
11905 PyObject * obj0 = 0 ;
11906 PyObject * obj1 = 0 ;
11907 PyObject * obj2 = 0 ;
11908 PyObject * obj3 = 0 ;
11909 char *kwnames[] = {
11910 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11911 };
11912
11913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11915 if (SWIG_arg_fail(1)) SWIG_fail;
11916 {
11917 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11918 arg2 = temp2->m_wxis;
11919 created2 = false;
11920 } else {
11921 PyErr_Clear(); // clear the failure of the wxPyConvert above
11922 arg2 = wxPyCBInputStream_create(obj1, false);
11923 if (arg2 == NULL) {
11924 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11925 SWIG_fail;
11926 }
11927 created2 = true;
11928 }
11929 }
11930 {
11931 arg3 = wxString_in_helper(obj2);
11932 if (arg3 == NULL) SWIG_fail;
11933 temp3 = true;
11934 }
11935 if (obj3) {
11936 {
11937 arg4 = (int)(SWIG_As_int(obj3));
11938 if (SWIG_arg_fail(4)) SWIG_fail;
11939 }
11940 }
11941 {
11942 PyThreadState* __tstate = wxPyBeginAllowThreads();
11943 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11944
11945 wxPyEndAllowThreads(__tstate);
11946 if (PyErr_Occurred()) SWIG_fail;
11947 }
11948 {
11949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11950 }
11951 {
11952 if (created2)
11953 delete arg2;
11954 }
11955 {
11956 if (temp3)
11957 delete arg3;
11958 }
11959 return resultobj;
11960 fail:
11961 {
11962 if (created2)
11963 delete arg2;
11964 }
11965 {
11966 if (temp3)
11967 delete arg3;
11968 }
11969 return NULL;
11970 }
11971
11972
11973 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11974 PyObject *resultobj;
11975 wxImage *arg1 = (wxImage *) 0 ;
11976 bool result;
11977 PyObject * obj0 = 0 ;
11978 char *kwnames[] = {
11979 (char *) "self", NULL
11980 };
11981
11982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11984 if (SWIG_arg_fail(1)) SWIG_fail;
11985 {
11986 PyThreadState* __tstate = wxPyBeginAllowThreads();
11987 result = (bool)(arg1)->Ok();
11988
11989 wxPyEndAllowThreads(__tstate);
11990 if (PyErr_Occurred()) SWIG_fail;
11991 }
11992 {
11993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11994 }
11995 return resultobj;
11996 fail:
11997 return NULL;
11998 }
11999
12000
12001 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12002 PyObject *resultobj;
12003 wxImage *arg1 = (wxImage *) 0 ;
12004 int result;
12005 PyObject * obj0 = 0 ;
12006 char *kwnames[] = {
12007 (char *) "self", NULL
12008 };
12009
12010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12012 if (SWIG_arg_fail(1)) SWIG_fail;
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 result = (int)(arg1)->GetWidth();
12016
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 {
12021 resultobj = SWIG_From_int((int)(result));
12022 }
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12030 PyObject *resultobj;
12031 wxImage *arg1 = (wxImage *) 0 ;
12032 int result;
12033 PyObject * obj0 = 0 ;
12034 char *kwnames[] = {
12035 (char *) "self", NULL
12036 };
12037
12038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12040 if (SWIG_arg_fail(1)) SWIG_fail;
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 result = (int)(arg1)->GetHeight();
12044
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 {
12049 resultobj = SWIG_From_int((int)(result));
12050 }
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj;
12059 wxImage *arg1 = (wxImage *) 0 ;
12060 wxSize result;
12061 PyObject * obj0 = 0 ;
12062 char *kwnames[] = {
12063 (char *) "self", NULL
12064 };
12065
12066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12068 if (SWIG_arg_fail(1)) SWIG_fail;
12069 {
12070 PyThreadState* __tstate = wxPyBeginAllowThreads();
12071 result = wxImage_GetSize(arg1);
12072
12073 wxPyEndAllowThreads(__tstate);
12074 if (PyErr_Occurred()) SWIG_fail;
12075 }
12076 {
12077 wxSize * resultptr;
12078 resultptr = new wxSize((wxSize &)(result));
12079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12080 }
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj;
12089 wxImage *arg1 = (wxImage *) 0 ;
12090 wxRect *arg2 = 0 ;
12091 SwigValueWrapper<wxImage > result;
12092 wxRect temp2 ;
12093 PyObject * obj0 = 0 ;
12094 PyObject * obj1 = 0 ;
12095 char *kwnames[] = {
12096 (char *) "self",(char *) "rect", NULL
12097 };
12098
12099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12101 if (SWIG_arg_fail(1)) SWIG_fail;
12102 {
12103 arg2 = &temp2;
12104 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12105 }
12106 {
12107 PyThreadState* __tstate = wxPyBeginAllowThreads();
12108 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12109
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 {
12114 wxImage * resultptr;
12115 resultptr = new wxImage((wxImage &)(result));
12116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12117 }
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12125 PyObject *resultobj;
12126 wxImage *arg1 = (wxImage *) 0 ;
12127 SwigValueWrapper<wxImage > result;
12128 PyObject * obj0 = 0 ;
12129 char *kwnames[] = {
12130 (char *) "self", NULL
12131 };
12132
12133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(1)) SWIG_fail;
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (arg1)->Copy();
12139
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 wxImage * resultptr;
12145 resultptr = new wxImage((wxImage &)(result));
12146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12147 }
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12155 PyObject *resultobj;
12156 wxImage *arg1 = (wxImage *) 0 ;
12157 wxImage *arg2 = 0 ;
12158 int arg3 ;
12159 int arg4 ;
12160 PyObject * obj0 = 0 ;
12161 PyObject * obj1 = 0 ;
12162 PyObject * obj2 = 0 ;
12163 PyObject * obj3 = 0 ;
12164 char *kwnames[] = {
12165 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12166 };
12167
12168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12170 if (SWIG_arg_fail(1)) SWIG_fail;
12171 {
12172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12173 if (SWIG_arg_fail(2)) SWIG_fail;
12174 if (arg2 == NULL) {
12175 SWIG_null_ref("wxImage");
12176 }
12177 if (SWIG_arg_fail(2)) SWIG_fail;
12178 }
12179 {
12180 arg3 = (int)(SWIG_As_int(obj2));
12181 if (SWIG_arg_fail(3)) SWIG_fail;
12182 }
12183 {
12184 arg4 = (int)(SWIG_As_int(obj3));
12185 if (SWIG_arg_fail(4)) SWIG_fail;
12186 }
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12190
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 Py_INCREF(Py_None); resultobj = Py_None;
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12202 PyObject *resultobj;
12203 wxImage *arg1 = (wxImage *) 0 ;
12204 PyObject *result;
12205 PyObject * obj0 = 0 ;
12206 char *kwnames[] = {
12207 (char *) "self", NULL
12208 };
12209
12210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12212 if (SWIG_arg_fail(1)) SWIG_fail;
12213 {
12214 PyThreadState* __tstate = wxPyBeginAllowThreads();
12215 result = (PyObject *)wxImage_GetData(arg1);
12216
12217 wxPyEndAllowThreads(__tstate);
12218 if (PyErr_Occurred()) SWIG_fail;
12219 }
12220 resultobj = result;
12221 return resultobj;
12222 fail:
12223 return NULL;
12224 }
12225
12226
12227 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12228 PyObject *resultobj;
12229 wxImage *arg1 = (wxImage *) 0 ;
12230 PyObject *arg2 = (PyObject *) 0 ;
12231 PyObject * obj0 = 0 ;
12232 PyObject * obj1 = 0 ;
12233 char *kwnames[] = {
12234 (char *) "self",(char *) "data", NULL
12235 };
12236
12237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12239 if (SWIG_arg_fail(1)) SWIG_fail;
12240 arg2 = obj1;
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 wxImage_SetData(arg1,arg2);
12244
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 Py_INCREF(Py_None); resultobj = Py_None;
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj;
12257 wxImage *arg1 = (wxImage *) 0 ;
12258 PyObject *result;
12259 PyObject * obj0 = 0 ;
12260 char *kwnames[] = {
12261 (char *) "self", NULL
12262 };
12263
12264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12266 if (SWIG_arg_fail(1)) SWIG_fail;
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12270
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 resultobj = result;
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj;
12283 wxImage *arg1 = (wxImage *) 0 ;
12284 PyObject *arg2 = (PyObject *) 0 ;
12285 PyObject * obj0 = 0 ;
12286 PyObject * obj1 = 0 ;
12287 char *kwnames[] = {
12288 (char *) "self",(char *) "data", NULL
12289 };
12290
12291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12293 if (SWIG_arg_fail(1)) SWIG_fail;
12294 arg2 = obj1;
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 wxImage_SetDataBuffer(arg1,arg2);
12298
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 Py_INCREF(Py_None); resultobj = Py_None;
12303 return resultobj;
12304 fail:
12305 return NULL;
12306 }
12307
12308
12309 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12310 PyObject *resultobj;
12311 wxImage *arg1 = (wxImage *) 0 ;
12312 PyObject *result;
12313 PyObject * obj0 = 0 ;
12314 char *kwnames[] = {
12315 (char *) "self", NULL
12316 };
12317
12318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12320 if (SWIG_arg_fail(1)) SWIG_fail;
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 result = (PyObject *)wxImage_GetAlphaData(arg1);
12324
12325 wxPyEndAllowThreads(__tstate);
12326 if (PyErr_Occurred()) SWIG_fail;
12327 }
12328 resultobj = result;
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12336 PyObject *resultobj;
12337 wxImage *arg1 = (wxImage *) 0 ;
12338 PyObject *arg2 = (PyObject *) 0 ;
12339 PyObject * obj0 = 0 ;
12340 PyObject * obj1 = 0 ;
12341 char *kwnames[] = {
12342 (char *) "self",(char *) "data", NULL
12343 };
12344
12345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12347 if (SWIG_arg_fail(1)) SWIG_fail;
12348 arg2 = obj1;
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 wxImage_SetAlphaData(arg1,arg2);
12352
12353 wxPyEndAllowThreads(__tstate);
12354 if (PyErr_Occurred()) SWIG_fail;
12355 }
12356 Py_INCREF(Py_None); resultobj = Py_None;
12357 return resultobj;
12358 fail:
12359 return NULL;
12360 }
12361
12362
12363 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12364 PyObject *resultobj;
12365 wxImage *arg1 = (wxImage *) 0 ;
12366 PyObject *result;
12367 PyObject * obj0 = 0 ;
12368 char *kwnames[] = {
12369 (char *) "self", NULL
12370 };
12371
12372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12374 if (SWIG_arg_fail(1)) SWIG_fail;
12375 {
12376 PyThreadState* __tstate = wxPyBeginAllowThreads();
12377 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12378
12379 wxPyEndAllowThreads(__tstate);
12380 if (PyErr_Occurred()) SWIG_fail;
12381 }
12382 resultobj = result;
12383 return resultobj;
12384 fail:
12385 return NULL;
12386 }
12387
12388
12389 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12390 PyObject *resultobj;
12391 wxImage *arg1 = (wxImage *) 0 ;
12392 PyObject *arg2 = (PyObject *) 0 ;
12393 PyObject * obj0 = 0 ;
12394 PyObject * obj1 = 0 ;
12395 char *kwnames[] = {
12396 (char *) "self",(char *) "data", NULL
12397 };
12398
12399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12401 if (SWIG_arg_fail(1)) SWIG_fail;
12402 arg2 = obj1;
12403 {
12404 PyThreadState* __tstate = wxPyBeginAllowThreads();
12405 wxImage_SetAlphaBuffer(arg1,arg2);
12406
12407 wxPyEndAllowThreads(__tstate);
12408 if (PyErr_Occurred()) SWIG_fail;
12409 }
12410 Py_INCREF(Py_None); resultobj = Py_None;
12411 return resultobj;
12412 fail:
12413 return NULL;
12414 }
12415
12416
12417 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12418 PyObject *resultobj;
12419 wxImage *arg1 = (wxImage *) 0 ;
12420 unsigned char arg2 ;
12421 unsigned char arg3 ;
12422 unsigned char arg4 ;
12423 PyObject * obj0 = 0 ;
12424 PyObject * obj1 = 0 ;
12425 PyObject * obj2 = 0 ;
12426 PyObject * obj3 = 0 ;
12427 char *kwnames[] = {
12428 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12429 };
12430
12431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12433 if (SWIG_arg_fail(1)) SWIG_fail;
12434 {
12435 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12436 if (SWIG_arg_fail(2)) SWIG_fail;
12437 }
12438 {
12439 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12440 if (SWIG_arg_fail(3)) SWIG_fail;
12441 }
12442 {
12443 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12444 if (SWIG_arg_fail(4)) SWIG_fail;
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 (arg1)->SetMaskColour(arg2,arg3,arg4);
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 Py_INCREF(Py_None); resultobj = Py_None;
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12461 PyObject *resultobj;
12462 wxImage *arg1 = (wxImage *) 0 ;
12463 unsigned char result;
12464 PyObject * obj0 = 0 ;
12465 char *kwnames[] = {
12466 (char *) "self", NULL
12467 };
12468
12469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12471 if (SWIG_arg_fail(1)) SWIG_fail;
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (unsigned char)(arg1)->GetMaskRed();
12475
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 {
12480 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12481 }
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj;
12490 wxImage *arg1 = (wxImage *) 0 ;
12491 unsigned char result;
12492 PyObject * obj0 = 0 ;
12493 char *kwnames[] = {
12494 (char *) "self", NULL
12495 };
12496
12497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12499 if (SWIG_arg_fail(1)) SWIG_fail;
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (unsigned char)(arg1)->GetMaskGreen();
12503
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 {
12508 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12509 }
12510 return resultobj;
12511 fail:
12512 return NULL;
12513 }
12514
12515
12516 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12517 PyObject *resultobj;
12518 wxImage *arg1 = (wxImage *) 0 ;
12519 unsigned char result;
12520 PyObject * obj0 = 0 ;
12521 char *kwnames[] = {
12522 (char *) "self", NULL
12523 };
12524
12525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12527 if (SWIG_arg_fail(1)) SWIG_fail;
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 result = (unsigned char)(arg1)->GetMaskBlue();
12531
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 {
12536 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12537 }
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj;
12546 wxImage *arg1 = (wxImage *) 0 ;
12547 bool arg2 = (bool) true ;
12548 PyObject * obj0 = 0 ;
12549 PyObject * obj1 = 0 ;
12550 char *kwnames[] = {
12551 (char *) "self",(char *) "mask", NULL
12552 };
12553
12554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12556 if (SWIG_arg_fail(1)) SWIG_fail;
12557 if (obj1) {
12558 {
12559 arg2 = (bool)(SWIG_As_bool(obj1));
12560 if (SWIG_arg_fail(2)) SWIG_fail;
12561 }
12562 }
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 (arg1)->SetMask(arg2);
12566
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 Py_INCREF(Py_None); resultobj = Py_None;
12571 return resultobj;
12572 fail:
12573 return NULL;
12574 }
12575
12576
12577 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12578 PyObject *resultobj;
12579 wxImage *arg1 = (wxImage *) 0 ;
12580 bool result;
12581 PyObject * obj0 = 0 ;
12582 char *kwnames[] = {
12583 (char *) "self", NULL
12584 };
12585
12586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12588 if (SWIG_arg_fail(1)) SWIG_fail;
12589 {
12590 PyThreadState* __tstate = wxPyBeginAllowThreads();
12591 result = (bool)(arg1)->HasMask();
12592
12593 wxPyEndAllowThreads(__tstate);
12594 if (PyErr_Occurred()) SWIG_fail;
12595 }
12596 {
12597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12598 }
12599 return resultobj;
12600 fail:
12601 return NULL;
12602 }
12603
12604
12605 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12606 PyObject *resultobj;
12607 wxImage *arg1 = (wxImage *) 0 ;
12608 double arg2 ;
12609 wxPoint *arg3 = 0 ;
12610 bool arg4 = (bool) true ;
12611 wxPoint *arg5 = (wxPoint *) NULL ;
12612 SwigValueWrapper<wxImage > result;
12613 wxPoint temp3 ;
12614 PyObject * obj0 = 0 ;
12615 PyObject * obj1 = 0 ;
12616 PyObject * obj2 = 0 ;
12617 PyObject * obj3 = 0 ;
12618 PyObject * obj4 = 0 ;
12619 char *kwnames[] = {
12620 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12621 };
12622
12623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12625 if (SWIG_arg_fail(1)) SWIG_fail;
12626 {
12627 arg2 = (double)(SWIG_As_double(obj1));
12628 if (SWIG_arg_fail(2)) SWIG_fail;
12629 }
12630 {
12631 arg3 = &temp3;
12632 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12633 }
12634 if (obj3) {
12635 {
12636 arg4 = (bool)(SWIG_As_bool(obj3));
12637 if (SWIG_arg_fail(4)) SWIG_fail;
12638 }
12639 }
12640 if (obj4) {
12641 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12642 if (SWIG_arg_fail(5)) SWIG_fail;
12643 }
12644 {
12645 PyThreadState* __tstate = wxPyBeginAllowThreads();
12646 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12647
12648 wxPyEndAllowThreads(__tstate);
12649 if (PyErr_Occurred()) SWIG_fail;
12650 }
12651 {
12652 wxImage * resultptr;
12653 resultptr = new wxImage((wxImage &)(result));
12654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12655 }
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj;
12664 wxImage *arg1 = (wxImage *) 0 ;
12665 bool arg2 = (bool) true ;
12666 SwigValueWrapper<wxImage > result;
12667 PyObject * obj0 = 0 ;
12668 PyObject * obj1 = 0 ;
12669 char *kwnames[] = {
12670 (char *) "self",(char *) "clockwise", NULL
12671 };
12672
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 if (obj1) {
12677 {
12678 arg2 = (bool)(SWIG_As_bool(obj1));
12679 if (SWIG_arg_fail(2)) SWIG_fail;
12680 }
12681 }
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (arg1)->Rotate90(arg2);
12685
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 {
12690 wxImage * resultptr;
12691 resultptr = new wxImage((wxImage &)(result));
12692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12693 }
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12701 PyObject *resultobj;
12702 wxImage *arg1 = (wxImage *) 0 ;
12703 bool arg2 = (bool) true ;
12704 SwigValueWrapper<wxImage > result;
12705 PyObject * obj0 = 0 ;
12706 PyObject * obj1 = 0 ;
12707 char *kwnames[] = {
12708 (char *) "self",(char *) "horizontally", NULL
12709 };
12710
12711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12713 if (SWIG_arg_fail(1)) SWIG_fail;
12714 if (obj1) {
12715 {
12716 arg2 = (bool)(SWIG_As_bool(obj1));
12717 if (SWIG_arg_fail(2)) SWIG_fail;
12718 }
12719 }
12720 {
12721 PyThreadState* __tstate = wxPyBeginAllowThreads();
12722 result = (arg1)->Mirror(arg2);
12723
12724 wxPyEndAllowThreads(__tstate);
12725 if (PyErr_Occurred()) SWIG_fail;
12726 }
12727 {
12728 wxImage * resultptr;
12729 resultptr = new wxImage((wxImage &)(result));
12730 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12731 }
12732 return resultobj;
12733 fail:
12734 return NULL;
12735 }
12736
12737
12738 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12739 PyObject *resultobj;
12740 wxImage *arg1 = (wxImage *) 0 ;
12741 unsigned char arg2 ;
12742 unsigned char arg3 ;
12743 unsigned char arg4 ;
12744 unsigned char arg5 ;
12745 unsigned char arg6 ;
12746 unsigned char arg7 ;
12747 PyObject * obj0 = 0 ;
12748 PyObject * obj1 = 0 ;
12749 PyObject * obj2 = 0 ;
12750 PyObject * obj3 = 0 ;
12751 PyObject * obj4 = 0 ;
12752 PyObject * obj5 = 0 ;
12753 PyObject * obj6 = 0 ;
12754 char *kwnames[] = {
12755 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12756 };
12757
12758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12760 if (SWIG_arg_fail(1)) SWIG_fail;
12761 {
12762 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12763 if (SWIG_arg_fail(2)) SWIG_fail;
12764 }
12765 {
12766 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12767 if (SWIG_arg_fail(3)) SWIG_fail;
12768 }
12769 {
12770 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12771 if (SWIG_arg_fail(4)) SWIG_fail;
12772 }
12773 {
12774 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12775 if (SWIG_arg_fail(5)) SWIG_fail;
12776 }
12777 {
12778 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12779 if (SWIG_arg_fail(6)) SWIG_fail;
12780 }
12781 {
12782 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12783 if (SWIG_arg_fail(7)) SWIG_fail;
12784 }
12785 {
12786 PyThreadState* __tstate = wxPyBeginAllowThreads();
12787 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12788
12789 wxPyEndAllowThreads(__tstate);
12790 if (PyErr_Occurred()) SWIG_fail;
12791 }
12792 Py_INCREF(Py_None); resultobj = Py_None;
12793 return resultobj;
12794 fail:
12795 return NULL;
12796 }
12797
12798
12799 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12800 PyObject *resultobj;
12801 wxImage *arg1 = (wxImage *) 0 ;
12802 unsigned char arg2 ;
12803 unsigned char arg3 ;
12804 unsigned char arg4 ;
12805 SwigValueWrapper<wxImage > result;
12806 PyObject * obj0 = 0 ;
12807 PyObject * obj1 = 0 ;
12808 PyObject * obj2 = 0 ;
12809 PyObject * obj3 = 0 ;
12810 char *kwnames[] = {
12811 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12812 };
12813
12814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12816 if (SWIG_arg_fail(1)) SWIG_fail;
12817 {
12818 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12819 if (SWIG_arg_fail(2)) SWIG_fail;
12820 }
12821 {
12822 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12823 if (SWIG_arg_fail(3)) SWIG_fail;
12824 }
12825 {
12826 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12827 if (SWIG_arg_fail(4)) SWIG_fail;
12828 }
12829 {
12830 PyThreadState* __tstate = wxPyBeginAllowThreads();
12831 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12832
12833 wxPyEndAllowThreads(__tstate);
12834 if (PyErr_Occurred()) SWIG_fail;
12835 }
12836 {
12837 wxImage * resultptr;
12838 resultptr = new wxImage((wxImage &)(result));
12839 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12840 }
12841 return resultobj;
12842 fail:
12843 return NULL;
12844 }
12845
12846
12847 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12848 PyObject *resultobj;
12849 wxImage *arg1 = (wxImage *) 0 ;
12850 wxString *arg2 = 0 ;
12851 wxString *arg3 = 0 ;
12852 bool temp2 = false ;
12853 bool temp3 = false ;
12854 PyObject * obj0 = 0 ;
12855 PyObject * obj1 = 0 ;
12856 PyObject * obj2 = 0 ;
12857 char *kwnames[] = {
12858 (char *) "self",(char *) "name",(char *) "value", NULL
12859 };
12860
12861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12863 if (SWIG_arg_fail(1)) SWIG_fail;
12864 {
12865 arg2 = wxString_in_helper(obj1);
12866 if (arg2 == NULL) SWIG_fail;
12867 temp2 = true;
12868 }
12869 {
12870 arg3 = wxString_in_helper(obj2);
12871 if (arg3 == NULL) SWIG_fail;
12872 temp3 = true;
12873 }
12874 {
12875 PyThreadState* __tstate = wxPyBeginAllowThreads();
12876 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12877
12878 wxPyEndAllowThreads(__tstate);
12879 if (PyErr_Occurred()) SWIG_fail;
12880 }
12881 Py_INCREF(Py_None); resultobj = Py_None;
12882 {
12883 if (temp2)
12884 delete arg2;
12885 }
12886 {
12887 if (temp3)
12888 delete arg3;
12889 }
12890 return resultobj;
12891 fail:
12892 {
12893 if (temp2)
12894 delete arg2;
12895 }
12896 {
12897 if (temp3)
12898 delete arg3;
12899 }
12900 return NULL;
12901 }
12902
12903
12904 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12905 PyObject *resultobj;
12906 wxImage *arg1 = (wxImage *) 0 ;
12907 wxString *arg2 = 0 ;
12908 int arg3 ;
12909 bool temp2 = false ;
12910 PyObject * obj0 = 0 ;
12911 PyObject * obj1 = 0 ;
12912 PyObject * obj2 = 0 ;
12913 char *kwnames[] = {
12914 (char *) "self",(char *) "name",(char *) "value", NULL
12915 };
12916
12917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12919 if (SWIG_arg_fail(1)) SWIG_fail;
12920 {
12921 arg2 = wxString_in_helper(obj1);
12922 if (arg2 == NULL) SWIG_fail;
12923 temp2 = true;
12924 }
12925 {
12926 arg3 = (int)(SWIG_As_int(obj2));
12927 if (SWIG_arg_fail(3)) SWIG_fail;
12928 }
12929 {
12930 PyThreadState* __tstate = wxPyBeginAllowThreads();
12931 (arg1)->SetOption((wxString const &)*arg2,arg3);
12932
12933 wxPyEndAllowThreads(__tstate);
12934 if (PyErr_Occurred()) SWIG_fail;
12935 }
12936 Py_INCREF(Py_None); resultobj = Py_None;
12937 {
12938 if (temp2)
12939 delete arg2;
12940 }
12941 return resultobj;
12942 fail:
12943 {
12944 if (temp2)
12945 delete arg2;
12946 }
12947 return NULL;
12948 }
12949
12950
12951 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12952 PyObject *resultobj;
12953 wxImage *arg1 = (wxImage *) 0 ;
12954 wxString *arg2 = 0 ;
12955 wxString result;
12956 bool temp2 = false ;
12957 PyObject * obj0 = 0 ;
12958 PyObject * obj1 = 0 ;
12959 char *kwnames[] = {
12960 (char *) "self",(char *) "name", NULL
12961 };
12962
12963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12965 if (SWIG_arg_fail(1)) SWIG_fail;
12966 {
12967 arg2 = wxString_in_helper(obj1);
12968 if (arg2 == NULL) SWIG_fail;
12969 temp2 = true;
12970 }
12971 {
12972 PyThreadState* __tstate = wxPyBeginAllowThreads();
12973 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12974
12975 wxPyEndAllowThreads(__tstate);
12976 if (PyErr_Occurred()) SWIG_fail;
12977 }
12978 {
12979 #if wxUSE_UNICODE
12980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12981 #else
12982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12983 #endif
12984 }
12985 {
12986 if (temp2)
12987 delete arg2;
12988 }
12989 return resultobj;
12990 fail:
12991 {
12992 if (temp2)
12993 delete arg2;
12994 }
12995 return NULL;
12996 }
12997
12998
12999 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13000 PyObject *resultobj;
13001 wxImage *arg1 = (wxImage *) 0 ;
13002 wxString *arg2 = 0 ;
13003 int result;
13004 bool temp2 = false ;
13005 PyObject * obj0 = 0 ;
13006 PyObject * obj1 = 0 ;
13007 char *kwnames[] = {
13008 (char *) "self",(char *) "name", NULL
13009 };
13010
13011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13013 if (SWIG_arg_fail(1)) SWIG_fail;
13014 {
13015 arg2 = wxString_in_helper(obj1);
13016 if (arg2 == NULL) SWIG_fail;
13017 temp2 = true;
13018 }
13019 {
13020 PyThreadState* __tstate = wxPyBeginAllowThreads();
13021 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13022
13023 wxPyEndAllowThreads(__tstate);
13024 if (PyErr_Occurred()) SWIG_fail;
13025 }
13026 {
13027 resultobj = SWIG_From_int((int)(result));
13028 }
13029 {
13030 if (temp2)
13031 delete arg2;
13032 }
13033 return resultobj;
13034 fail:
13035 {
13036 if (temp2)
13037 delete arg2;
13038 }
13039 return NULL;
13040 }
13041
13042
13043 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13044 PyObject *resultobj;
13045 wxImage *arg1 = (wxImage *) 0 ;
13046 wxString *arg2 = 0 ;
13047 bool result;
13048 bool temp2 = false ;
13049 PyObject * obj0 = 0 ;
13050 PyObject * obj1 = 0 ;
13051 char *kwnames[] = {
13052 (char *) "self",(char *) "name", NULL
13053 };
13054
13055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13057 if (SWIG_arg_fail(1)) SWIG_fail;
13058 {
13059 arg2 = wxString_in_helper(obj1);
13060 if (arg2 == NULL) SWIG_fail;
13061 temp2 = true;
13062 }
13063 {
13064 PyThreadState* __tstate = wxPyBeginAllowThreads();
13065 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13066
13067 wxPyEndAllowThreads(__tstate);
13068 if (PyErr_Occurred()) SWIG_fail;
13069 }
13070 {
13071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13072 }
13073 {
13074 if (temp2)
13075 delete arg2;
13076 }
13077 return resultobj;
13078 fail:
13079 {
13080 if (temp2)
13081 delete arg2;
13082 }
13083 return NULL;
13084 }
13085
13086
13087 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13088 PyObject *resultobj;
13089 wxImage *arg1 = (wxImage *) 0 ;
13090 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13091 unsigned long result;
13092 PyObject * obj0 = 0 ;
13093 PyObject * obj1 = 0 ;
13094 char *kwnames[] = {
13095 (char *) "self",(char *) "stopafter", NULL
13096 };
13097
13098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13100 if (SWIG_arg_fail(1)) SWIG_fail;
13101 if (obj1) {
13102 {
13103 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13104 if (SWIG_arg_fail(2)) SWIG_fail;
13105 }
13106 }
13107 {
13108 PyThreadState* __tstate = wxPyBeginAllowThreads();
13109 result = (unsigned long)(arg1)->CountColours(arg2);
13110
13111 wxPyEndAllowThreads(__tstate);
13112 if (PyErr_Occurred()) SWIG_fail;
13113 }
13114 {
13115 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13116 }
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj;
13125 wxImage *arg1 = (wxImage *) 0 ;
13126 wxImageHistogram *arg2 = 0 ;
13127 unsigned long result;
13128 PyObject * obj0 = 0 ;
13129 PyObject * obj1 = 0 ;
13130 char *kwnames[] = {
13131 (char *) "self",(char *) "h", NULL
13132 };
13133
13134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13136 if (SWIG_arg_fail(1)) SWIG_fail;
13137 {
13138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13139 if (SWIG_arg_fail(2)) SWIG_fail;
13140 if (arg2 == NULL) {
13141 SWIG_null_ref("wxImageHistogram");
13142 }
13143 if (SWIG_arg_fail(2)) SWIG_fail;
13144 }
13145 {
13146 PyThreadState* __tstate = wxPyBeginAllowThreads();
13147 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13148
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 {
13153 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13154 }
13155 return resultobj;
13156 fail:
13157 return NULL;
13158 }
13159
13160
13161 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13162 PyObject *resultobj;
13163 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13164 PyObject * obj0 = 0 ;
13165 char *kwnames[] = {
13166 (char *) "handler", NULL
13167 };
13168
13169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13171 if (SWIG_arg_fail(1)) SWIG_fail;
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 wxImage::AddHandler(arg1);
13175
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 Py_INCREF(Py_None); resultobj = Py_None;
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj;
13188 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13189 PyObject * obj0 = 0 ;
13190 char *kwnames[] = {
13191 (char *) "handler", NULL
13192 };
13193
13194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13196 if (SWIG_arg_fail(1)) SWIG_fail;
13197 {
13198 PyThreadState* __tstate = wxPyBeginAllowThreads();
13199 wxImage::InsertHandler(arg1);
13200
13201 wxPyEndAllowThreads(__tstate);
13202 if (PyErr_Occurred()) SWIG_fail;
13203 }
13204 Py_INCREF(Py_None); resultobj = Py_None;
13205 return resultobj;
13206 fail:
13207 return NULL;
13208 }
13209
13210
13211 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13212 PyObject *resultobj;
13213 wxString *arg1 = 0 ;
13214 bool result;
13215 bool temp1 = false ;
13216 PyObject * obj0 = 0 ;
13217 char *kwnames[] = {
13218 (char *) "name", NULL
13219 };
13220
13221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13222 {
13223 arg1 = wxString_in_helper(obj0);
13224 if (arg1 == NULL) SWIG_fail;
13225 temp1 = true;
13226 }
13227 {
13228 PyThreadState* __tstate = wxPyBeginAllowThreads();
13229 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13230
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 {
13235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13236 }
13237 {
13238 if (temp1)
13239 delete arg1;
13240 }
13241 return resultobj;
13242 fail:
13243 {
13244 if (temp1)
13245 delete arg1;
13246 }
13247 return NULL;
13248 }
13249
13250
13251 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj;
13253 wxString result;
13254 char *kwnames[] = {
13255 NULL
13256 };
13257
13258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 result = wxImage::GetImageExtWildcard();
13262
13263 wxPyEndAllowThreads(__tstate);
13264 if (PyErr_Occurred()) SWIG_fail;
13265 }
13266 {
13267 #if wxUSE_UNICODE
13268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13269 #else
13270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13271 #endif
13272 }
13273 return resultobj;
13274 fail:
13275 return NULL;
13276 }
13277
13278
13279 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13280 PyObject *resultobj;
13281 wxImage *arg1 = (wxImage *) 0 ;
13282 int arg2 = (int) -1 ;
13283 wxBitmap result;
13284 PyObject * obj0 = 0 ;
13285 PyObject * obj1 = 0 ;
13286 char *kwnames[] = {
13287 (char *) "self",(char *) "depth", NULL
13288 };
13289
13290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13292 if (SWIG_arg_fail(1)) SWIG_fail;
13293 if (obj1) {
13294 {
13295 arg2 = (int)(SWIG_As_int(obj1));
13296 if (SWIG_arg_fail(2)) SWIG_fail;
13297 }
13298 }
13299 {
13300 if (!wxPyCheckForApp()) SWIG_fail;
13301 PyThreadState* __tstate = wxPyBeginAllowThreads();
13302 result = wxImage_ConvertToBitmap(arg1,arg2);
13303
13304 wxPyEndAllowThreads(__tstate);
13305 if (PyErr_Occurred()) SWIG_fail;
13306 }
13307 {
13308 wxBitmap * resultptr;
13309 resultptr = new wxBitmap((wxBitmap &)(result));
13310 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13311 }
13312 return resultobj;
13313 fail:
13314 return NULL;
13315 }
13316
13317
13318 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj;
13320 wxImage *arg1 = (wxImage *) 0 ;
13321 unsigned char arg2 ;
13322 unsigned char arg3 ;
13323 unsigned char arg4 ;
13324 wxBitmap result;
13325 PyObject * obj0 = 0 ;
13326 PyObject * obj1 = 0 ;
13327 PyObject * obj2 = 0 ;
13328 PyObject * obj3 = 0 ;
13329 char *kwnames[] = {
13330 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13331 };
13332
13333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13335 if (SWIG_arg_fail(1)) SWIG_fail;
13336 {
13337 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13338 if (SWIG_arg_fail(2)) SWIG_fail;
13339 }
13340 {
13341 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13342 if (SWIG_arg_fail(3)) SWIG_fail;
13343 }
13344 {
13345 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13346 if (SWIG_arg_fail(4)) SWIG_fail;
13347 }
13348 {
13349 if (!wxPyCheckForApp()) SWIG_fail;
13350 PyThreadState* __tstate = wxPyBeginAllowThreads();
13351 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13352
13353 wxPyEndAllowThreads(__tstate);
13354 if (PyErr_Occurred()) SWIG_fail;
13355 }
13356 {
13357 wxBitmap * resultptr;
13358 resultptr = new wxBitmap((wxBitmap &)(result));
13359 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13360 }
13361 return resultobj;
13362 fail:
13363 return NULL;
13364 }
13365
13366
13367 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13368 PyObject *obj;
13369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13370 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13371 Py_INCREF(obj);
13372 return Py_BuildValue((char *)"");
13373 }
13374 static int _wrap_NullImage_set(PyObject *) {
13375 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13376 return 1;
13377 }
13378
13379
13380 static PyObject *_wrap_NullImage_get(void) {
13381 PyObject *pyobj;
13382
13383 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13384 return pyobj;
13385 }
13386
13387
13388 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13389 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13390 return 1;
13391 }
13392
13393
13394 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13395 PyObject *pyobj;
13396
13397 {
13398 #if wxUSE_UNICODE
13399 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13400 #else
13401 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13402 #endif
13403 }
13404 return pyobj;
13405 }
13406
13407
13408 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13409 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13410 return 1;
13411 }
13412
13413
13414 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13415 PyObject *pyobj;
13416
13417 {
13418 #if wxUSE_UNICODE
13419 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13420 #else
13421 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13422 #endif
13423 }
13424 return pyobj;
13425 }
13426
13427
13428 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13429 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13430 return 1;
13431 }
13432
13433
13434 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13435 PyObject *pyobj;
13436
13437 {
13438 #if wxUSE_UNICODE
13439 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13440 #else
13441 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13442 #endif
13443 }
13444 return pyobj;
13445 }
13446
13447
13448 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13449 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13450 return 1;
13451 }
13452
13453
13454 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13455 PyObject *pyobj;
13456
13457 {
13458 #if wxUSE_UNICODE
13459 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13460 #else
13461 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13462 #endif
13463 }
13464 return pyobj;
13465 }
13466
13467
13468 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13469 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13470 return 1;
13471 }
13472
13473
13474 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13475 PyObject *pyobj;
13476
13477 {
13478 #if wxUSE_UNICODE
13479 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13480 #else
13481 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13482 #endif
13483 }
13484 return pyobj;
13485 }
13486
13487
13488 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13489 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13490 return 1;
13491 }
13492
13493
13494 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13495 PyObject *pyobj;
13496
13497 {
13498 #if wxUSE_UNICODE
13499 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13500 #else
13501 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13502 #endif
13503 }
13504 return pyobj;
13505 }
13506
13507
13508 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13509 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13510 return 1;
13511 }
13512
13513
13514 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13515 PyObject *pyobj;
13516
13517 {
13518 #if wxUSE_UNICODE
13519 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13520 #else
13521 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13522 #endif
13523 }
13524 return pyobj;
13525 }
13526
13527
13528 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13529 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13530 return 1;
13531 }
13532
13533
13534 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13535 PyObject *pyobj;
13536
13537 {
13538 #if wxUSE_UNICODE
13539 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13540 #else
13541 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13542 #endif
13543 }
13544 return pyobj;
13545 }
13546
13547
13548 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13549 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13550 return 1;
13551 }
13552
13553
13554 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13555 PyObject *pyobj;
13556
13557 {
13558 #if wxUSE_UNICODE
13559 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13560 #else
13561 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13562 #endif
13563 }
13564 return pyobj;
13565 }
13566
13567
13568 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13569 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13570 return 1;
13571 }
13572
13573
13574 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13575 PyObject *pyobj;
13576
13577 {
13578 #if wxUSE_UNICODE
13579 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13580 #else
13581 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13582 #endif
13583 }
13584 return pyobj;
13585 }
13586
13587
13588 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13589 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13590 return 1;
13591 }
13592
13593
13594 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13595 PyObject *pyobj;
13596
13597 {
13598 #if wxUSE_UNICODE
13599 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13600 #else
13601 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13602 #endif
13603 }
13604 return pyobj;
13605 }
13606
13607
13608 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13609 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13610 return 1;
13611 }
13612
13613
13614 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13615 PyObject *pyobj;
13616
13617 {
13618 #if wxUSE_UNICODE
13619 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13620 #else
13621 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13622 #endif
13623 }
13624 return pyobj;
13625 }
13626
13627
13628 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13629 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13630 return 1;
13631 }
13632
13633
13634 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13635 PyObject *pyobj;
13636
13637 {
13638 #if wxUSE_UNICODE
13639 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13640 #else
13641 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13642 #endif
13643 }
13644 return pyobj;
13645 }
13646
13647
13648 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
13649 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
13650 return 1;
13651 }
13652
13653
13654 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
13655 PyObject *pyobj;
13656
13657 {
13658 #if wxUSE_UNICODE
13659 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13660 #else
13661 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13662 #endif
13663 }
13664 return pyobj;
13665 }
13666
13667
13668 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
13669 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
13670 return 1;
13671 }
13672
13673
13674 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
13675 PyObject *pyobj;
13676
13677 {
13678 #if wxUSE_UNICODE
13679 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13680 #else
13681 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13682 #endif
13683 }
13684 return pyobj;
13685 }
13686
13687
13688 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13689 PyObject *resultobj;
13690 wxBMPHandler *result;
13691 char *kwnames[] = {
13692 NULL
13693 };
13694
13695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13696 {
13697 PyThreadState* __tstate = wxPyBeginAllowThreads();
13698 result = (wxBMPHandler *)new wxBMPHandler();
13699
13700 wxPyEndAllowThreads(__tstate);
13701 if (PyErr_Occurred()) SWIG_fail;
13702 }
13703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13704 return resultobj;
13705 fail:
13706 return NULL;
13707 }
13708
13709
13710 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13711 PyObject *obj;
13712 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13713 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13714 Py_INCREF(obj);
13715 return Py_BuildValue((char *)"");
13716 }
13717 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13718 PyObject *resultobj;
13719 wxICOHandler *result;
13720 char *kwnames[] = {
13721 NULL
13722 };
13723
13724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13725 {
13726 PyThreadState* __tstate = wxPyBeginAllowThreads();
13727 result = (wxICOHandler *)new wxICOHandler();
13728
13729 wxPyEndAllowThreads(__tstate);
13730 if (PyErr_Occurred()) SWIG_fail;
13731 }
13732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13733 return resultobj;
13734 fail:
13735 return NULL;
13736 }
13737
13738
13739 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13740 PyObject *obj;
13741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13742 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13743 Py_INCREF(obj);
13744 return Py_BuildValue((char *)"");
13745 }
13746 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13747 PyObject *resultobj;
13748 wxCURHandler *result;
13749 char *kwnames[] = {
13750 NULL
13751 };
13752
13753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13754 {
13755 PyThreadState* __tstate = wxPyBeginAllowThreads();
13756 result = (wxCURHandler *)new wxCURHandler();
13757
13758 wxPyEndAllowThreads(__tstate);
13759 if (PyErr_Occurred()) SWIG_fail;
13760 }
13761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13762 return resultobj;
13763 fail:
13764 return NULL;
13765 }
13766
13767
13768 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13769 PyObject *obj;
13770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13771 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13772 Py_INCREF(obj);
13773 return Py_BuildValue((char *)"");
13774 }
13775 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13776 PyObject *resultobj;
13777 wxANIHandler *result;
13778 char *kwnames[] = {
13779 NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13783 {
13784 PyThreadState* __tstate = wxPyBeginAllowThreads();
13785 result = (wxANIHandler *)new wxANIHandler();
13786
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13791 return resultobj;
13792 fail:
13793 return NULL;
13794 }
13795
13796
13797 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13798 PyObject *obj;
13799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13800 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13801 Py_INCREF(obj);
13802 return Py_BuildValue((char *)"");
13803 }
13804 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj;
13806 wxPNGHandler *result;
13807 char *kwnames[] = {
13808 NULL
13809 };
13810
13811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13812 {
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 result = (wxPNGHandler *)new wxPNGHandler();
13815
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13827 PyObject *obj;
13828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13829 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13830 Py_INCREF(obj);
13831 return Py_BuildValue((char *)"");
13832 }
13833 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13834 PyObject *resultobj;
13835 wxGIFHandler *result;
13836 char *kwnames[] = {
13837 NULL
13838 };
13839
13840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13841 {
13842 PyThreadState* __tstate = wxPyBeginAllowThreads();
13843 result = (wxGIFHandler *)new wxGIFHandler();
13844
13845 wxPyEndAllowThreads(__tstate);
13846 if (PyErr_Occurred()) SWIG_fail;
13847 }
13848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13856 PyObject *obj;
13857 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13858 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13859 Py_INCREF(obj);
13860 return Py_BuildValue((char *)"");
13861 }
13862 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13863 PyObject *resultobj;
13864 wxPCXHandler *result;
13865 char *kwnames[] = {
13866 NULL
13867 };
13868
13869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 result = (wxPCXHandler *)new wxPCXHandler();
13873
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13878 return resultobj;
13879 fail:
13880 return NULL;
13881 }
13882
13883
13884 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13885 PyObject *obj;
13886 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13887 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13888 Py_INCREF(obj);
13889 return Py_BuildValue((char *)"");
13890 }
13891 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13892 PyObject *resultobj;
13893 wxJPEGHandler *result;
13894 char *kwnames[] = {
13895 NULL
13896 };
13897
13898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13899 {
13900 PyThreadState* __tstate = wxPyBeginAllowThreads();
13901 result = (wxJPEGHandler *)new wxJPEGHandler();
13902
13903 wxPyEndAllowThreads(__tstate);
13904 if (PyErr_Occurred()) SWIG_fail;
13905 }
13906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13907 return resultobj;
13908 fail:
13909 return NULL;
13910 }
13911
13912
13913 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13914 PyObject *obj;
13915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13916 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13917 Py_INCREF(obj);
13918 return Py_BuildValue((char *)"");
13919 }
13920 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13921 PyObject *resultobj;
13922 wxPNMHandler *result;
13923 char *kwnames[] = {
13924 NULL
13925 };
13926
13927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 result = (wxPNMHandler *)new wxPNMHandler();
13931
13932 wxPyEndAllowThreads(__tstate);
13933 if (PyErr_Occurred()) SWIG_fail;
13934 }
13935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13936 return resultobj;
13937 fail:
13938 return NULL;
13939 }
13940
13941
13942 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13943 PyObject *obj;
13944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13945 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13946 Py_INCREF(obj);
13947 return Py_BuildValue((char *)"");
13948 }
13949 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13950 PyObject *resultobj;
13951 wxXPMHandler *result;
13952 char *kwnames[] = {
13953 NULL
13954 };
13955
13956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13957 {
13958 PyThreadState* __tstate = wxPyBeginAllowThreads();
13959 result = (wxXPMHandler *)new wxXPMHandler();
13960
13961 wxPyEndAllowThreads(__tstate);
13962 if (PyErr_Occurred()) SWIG_fail;
13963 }
13964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13965 return resultobj;
13966 fail:
13967 return NULL;
13968 }
13969
13970
13971 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13972 PyObject *obj;
13973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13974 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13975 Py_INCREF(obj);
13976 return Py_BuildValue((char *)"");
13977 }
13978 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13979 PyObject *resultobj;
13980 wxTIFFHandler *result;
13981 char *kwnames[] = {
13982 NULL
13983 };
13984
13985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13986 {
13987 PyThreadState* __tstate = wxPyBeginAllowThreads();
13988 result = (wxTIFFHandler *)new wxTIFFHandler();
13989
13990 wxPyEndAllowThreads(__tstate);
13991 if (PyErr_Occurred()) SWIG_fail;
13992 }
13993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13994 return resultobj;
13995 fail:
13996 return NULL;
13997 }
13998
13999
14000 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14001 PyObject *obj;
14002 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14003 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14004 Py_INCREF(obj);
14005 return Py_BuildValue((char *)"");
14006 }
14007 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14008 PyObject *resultobj;
14009 wxImage *arg1 = 0 ;
14010 wxImage *arg2 = 0 ;
14011 int arg3 = (int) 236 ;
14012 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14013 bool result;
14014 PyObject * obj0 = 0 ;
14015 PyObject * obj1 = 0 ;
14016 PyObject * obj2 = 0 ;
14017 PyObject * obj3 = 0 ;
14018 char *kwnames[] = {
14019 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14020 };
14021
14022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14023 {
14024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14025 if (SWIG_arg_fail(1)) SWIG_fail;
14026 if (arg1 == NULL) {
14027 SWIG_null_ref("wxImage");
14028 }
14029 if (SWIG_arg_fail(1)) SWIG_fail;
14030 }
14031 {
14032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14033 if (SWIG_arg_fail(2)) SWIG_fail;
14034 if (arg2 == NULL) {
14035 SWIG_null_ref("wxImage");
14036 }
14037 if (SWIG_arg_fail(2)) SWIG_fail;
14038 }
14039 if (obj2) {
14040 {
14041 arg3 = (int)(SWIG_As_int(obj2));
14042 if (SWIG_arg_fail(3)) SWIG_fail;
14043 }
14044 }
14045 if (obj3) {
14046 {
14047 arg4 = (int)(SWIG_As_int(obj3));
14048 if (SWIG_arg_fail(4)) SWIG_fail;
14049 }
14050 }
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14054
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 {
14059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14060 }
14061 return resultobj;
14062 fail:
14063 return NULL;
14064 }
14065
14066
14067 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14068 PyObject *obj;
14069 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14070 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14071 Py_INCREF(obj);
14072 return Py_BuildValue((char *)"");
14073 }
14074 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj;
14076 wxEvtHandler *result;
14077 char *kwnames[] = {
14078 NULL
14079 };
14080
14081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 result = (wxEvtHandler *)new wxEvtHandler();
14085
14086 wxPyEndAllowThreads(__tstate);
14087 if (PyErr_Occurred()) SWIG_fail;
14088 }
14089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14090 return resultobj;
14091 fail:
14092 return NULL;
14093 }
14094
14095
14096 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14097 PyObject *resultobj;
14098 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14099 wxEvtHandler *result;
14100 PyObject * obj0 = 0 ;
14101 char *kwnames[] = {
14102 (char *) "self", NULL
14103 };
14104
14105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14107 if (SWIG_arg_fail(1)) SWIG_fail;
14108 {
14109 PyThreadState* __tstate = wxPyBeginAllowThreads();
14110 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14111
14112 wxPyEndAllowThreads(__tstate);
14113 if (PyErr_Occurred()) SWIG_fail;
14114 }
14115 {
14116 resultobj = wxPyMake_wxObject(result, 0);
14117 }
14118 return resultobj;
14119 fail:
14120 return NULL;
14121 }
14122
14123
14124 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14125 PyObject *resultobj;
14126 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14127 wxEvtHandler *result;
14128 PyObject * obj0 = 0 ;
14129 char *kwnames[] = {
14130 (char *) "self", NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14135 if (SWIG_arg_fail(1)) SWIG_fail;
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 {
14144 resultobj = wxPyMake_wxObject(result, 0);
14145 }
14146 return resultobj;
14147 fail:
14148 return NULL;
14149 }
14150
14151
14152 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14153 PyObject *resultobj;
14154 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14155 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 char *kwnames[] = {
14159 (char *) "self",(char *) "handler", NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14164 if (SWIG_arg_fail(1)) SWIG_fail;
14165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14166 if (SWIG_arg_fail(2)) SWIG_fail;
14167 {
14168 PyThreadState* __tstate = wxPyBeginAllowThreads();
14169 (arg1)->SetNextHandler(arg2);
14170
14171 wxPyEndAllowThreads(__tstate);
14172 if (PyErr_Occurred()) SWIG_fail;
14173 }
14174 Py_INCREF(Py_None); resultobj = Py_None;
14175 return resultobj;
14176 fail:
14177 return NULL;
14178 }
14179
14180
14181 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14182 PyObject *resultobj;
14183 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14184 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14185 PyObject * obj0 = 0 ;
14186 PyObject * obj1 = 0 ;
14187 char *kwnames[] = {
14188 (char *) "self",(char *) "handler", NULL
14189 };
14190
14191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14193 if (SWIG_arg_fail(1)) SWIG_fail;
14194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14195 if (SWIG_arg_fail(2)) SWIG_fail;
14196 {
14197 PyThreadState* __tstate = wxPyBeginAllowThreads();
14198 (arg1)->SetPreviousHandler(arg2);
14199
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 Py_INCREF(Py_None); resultobj = Py_None;
14204 return resultobj;
14205 fail:
14206 return NULL;
14207 }
14208
14209
14210 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14211 PyObject *resultobj;
14212 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14213 bool result;
14214 PyObject * obj0 = 0 ;
14215 char *kwnames[] = {
14216 (char *) "self", NULL
14217 };
14218
14219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14221 if (SWIG_arg_fail(1)) SWIG_fail;
14222 {
14223 PyThreadState* __tstate = wxPyBeginAllowThreads();
14224 result = (bool)(arg1)->GetEvtHandlerEnabled();
14225
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 {
14230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14231 }
14232 return resultobj;
14233 fail:
14234 return NULL;
14235 }
14236
14237
14238 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14239 PyObject *resultobj;
14240 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14241 bool arg2 ;
14242 PyObject * obj0 = 0 ;
14243 PyObject * obj1 = 0 ;
14244 char *kwnames[] = {
14245 (char *) "self",(char *) "enabled", NULL
14246 };
14247
14248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14250 if (SWIG_arg_fail(1)) SWIG_fail;
14251 {
14252 arg2 = (bool)(SWIG_As_bool(obj1));
14253 if (SWIG_arg_fail(2)) SWIG_fail;
14254 }
14255 {
14256 PyThreadState* __tstate = wxPyBeginAllowThreads();
14257 (arg1)->SetEvtHandlerEnabled(arg2);
14258
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 Py_INCREF(Py_None); resultobj = Py_None;
14263 return resultobj;
14264 fail:
14265 return NULL;
14266 }
14267
14268
14269 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14270 PyObject *resultobj;
14271 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14272 wxEvent *arg2 = 0 ;
14273 bool result;
14274 PyObject * obj0 = 0 ;
14275 PyObject * obj1 = 0 ;
14276 char *kwnames[] = {
14277 (char *) "self",(char *) "event", NULL
14278 };
14279
14280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14282 if (SWIG_arg_fail(1)) SWIG_fail;
14283 {
14284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14285 if (SWIG_arg_fail(2)) SWIG_fail;
14286 if (arg2 == NULL) {
14287 SWIG_null_ref("wxEvent");
14288 }
14289 if (SWIG_arg_fail(2)) SWIG_fail;
14290 }
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (bool)(arg1)->ProcessEvent(*arg2);
14294
14295 wxPyEndAllowThreads(__tstate);
14296 if (PyErr_Occurred()) SWIG_fail;
14297 }
14298 {
14299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14300 }
14301 return resultobj;
14302 fail:
14303 return NULL;
14304 }
14305
14306
14307 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14308 PyObject *resultobj;
14309 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14310 wxEvent *arg2 = 0 ;
14311 PyObject * obj0 = 0 ;
14312 PyObject * obj1 = 0 ;
14313 char *kwnames[] = {
14314 (char *) "self",(char *) "event", NULL
14315 };
14316
14317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14319 if (SWIG_arg_fail(1)) SWIG_fail;
14320 {
14321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14322 if (SWIG_arg_fail(2)) SWIG_fail;
14323 if (arg2 == NULL) {
14324 SWIG_null_ref("wxEvent");
14325 }
14326 if (SWIG_arg_fail(2)) SWIG_fail;
14327 }
14328 {
14329 PyThreadState* __tstate = wxPyBeginAllowThreads();
14330 (arg1)->AddPendingEvent(*arg2);
14331
14332 wxPyEndAllowThreads(__tstate);
14333 if (PyErr_Occurred()) SWIG_fail;
14334 }
14335 Py_INCREF(Py_None); resultobj = Py_None;
14336 return resultobj;
14337 fail:
14338 return NULL;
14339 }
14340
14341
14342 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14343 PyObject *resultobj;
14344 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14345 PyObject * obj0 = 0 ;
14346 char *kwnames[] = {
14347 (char *) "self", NULL
14348 };
14349
14350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14352 if (SWIG_arg_fail(1)) SWIG_fail;
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 (arg1)->ProcessPendingEvents();
14356
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 Py_INCREF(Py_None); resultobj = Py_None;
14361 return resultobj;
14362 fail:
14363 return NULL;
14364 }
14365
14366
14367 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14368 PyObject *resultobj;
14369 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14370 int arg2 ;
14371 int arg3 ;
14372 int arg4 ;
14373 PyObject *arg5 = (PyObject *) 0 ;
14374 PyObject * obj0 = 0 ;
14375 PyObject * obj1 = 0 ;
14376 PyObject * obj2 = 0 ;
14377 PyObject * obj3 = 0 ;
14378 PyObject * obj4 = 0 ;
14379 char *kwnames[] = {
14380 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14381 };
14382
14383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14385 if (SWIG_arg_fail(1)) SWIG_fail;
14386 {
14387 arg2 = (int)(SWIG_As_int(obj1));
14388 if (SWIG_arg_fail(2)) SWIG_fail;
14389 }
14390 {
14391 arg3 = (int)(SWIG_As_int(obj2));
14392 if (SWIG_arg_fail(3)) SWIG_fail;
14393 }
14394 {
14395 arg4 = (int)(SWIG_As_int(obj3));
14396 if (SWIG_arg_fail(4)) SWIG_fail;
14397 }
14398 arg5 = obj4;
14399 {
14400 PyThreadState* __tstate = wxPyBeginAllowThreads();
14401 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14402
14403 wxPyEndAllowThreads(__tstate);
14404 if (PyErr_Occurred()) SWIG_fail;
14405 }
14406 Py_INCREF(Py_None); resultobj = Py_None;
14407 return resultobj;
14408 fail:
14409 return NULL;
14410 }
14411
14412
14413 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14414 PyObject *resultobj;
14415 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14416 int arg2 ;
14417 int arg3 = (int) -1 ;
14418 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14419 bool result;
14420 PyObject * obj0 = 0 ;
14421 PyObject * obj1 = 0 ;
14422 PyObject * obj2 = 0 ;
14423 PyObject * obj3 = 0 ;
14424 char *kwnames[] = {
14425 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14426 };
14427
14428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14430 if (SWIG_arg_fail(1)) SWIG_fail;
14431 {
14432 arg2 = (int)(SWIG_As_int(obj1));
14433 if (SWIG_arg_fail(2)) SWIG_fail;
14434 }
14435 if (obj2) {
14436 {
14437 arg3 = (int)(SWIG_As_int(obj2));
14438 if (SWIG_arg_fail(3)) SWIG_fail;
14439 }
14440 }
14441 if (obj3) {
14442 {
14443 arg4 = (wxEventType)(SWIG_As_int(obj3));
14444 if (SWIG_arg_fail(4)) SWIG_fail;
14445 }
14446 }
14447 {
14448 PyThreadState* __tstate = wxPyBeginAllowThreads();
14449 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14450
14451 wxPyEndAllowThreads(__tstate);
14452 if (PyErr_Occurred()) SWIG_fail;
14453 }
14454 {
14455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14456 }
14457 return resultobj;
14458 fail:
14459 return NULL;
14460 }
14461
14462
14463 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14464 PyObject *resultobj;
14465 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14466 PyObject *arg2 = (PyObject *) 0 ;
14467 bool arg3 = (bool) true ;
14468 PyObject * obj0 = 0 ;
14469 PyObject * obj1 = 0 ;
14470 PyObject * obj2 = 0 ;
14471 char *kwnames[] = {
14472 (char *) "self",(char *) "_self",(char *) "incref", NULL
14473 };
14474
14475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14477 if (SWIG_arg_fail(1)) SWIG_fail;
14478 arg2 = obj1;
14479 if (obj2) {
14480 {
14481 arg3 = (bool)(SWIG_As_bool(obj2));
14482 if (SWIG_arg_fail(3)) SWIG_fail;
14483 }
14484 }
14485 {
14486 PyThreadState* __tstate = wxPyBeginAllowThreads();
14487 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14488
14489 wxPyEndAllowThreads(__tstate);
14490 if (PyErr_Occurred()) SWIG_fail;
14491 }
14492 Py_INCREF(Py_None); resultobj = Py_None;
14493 return resultobj;
14494 fail:
14495 return NULL;
14496 }
14497
14498
14499 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14500 PyObject *obj;
14501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14502 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14503 Py_INCREF(obj);
14504 return Py_BuildValue((char *)"");
14505 }
14506 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14507 PyObject *resultobj;
14508 wxEventType result;
14509 char *kwnames[] = {
14510 NULL
14511 };
14512
14513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 result = (wxEventType)wxNewEventType();
14517
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 {
14522 resultobj = SWIG_From_int((int)(result));
14523 }
14524 return resultobj;
14525 fail:
14526 return NULL;
14527 }
14528
14529
14530 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14531 PyObject *resultobj;
14532 wxEvent *arg1 = (wxEvent *) 0 ;
14533 PyObject * obj0 = 0 ;
14534 char *kwnames[] = {
14535 (char *) "self", NULL
14536 };
14537
14538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14540 if (SWIG_arg_fail(1)) SWIG_fail;
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 delete arg1;
14544
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 Py_INCREF(Py_None); resultobj = Py_None;
14549 return resultobj;
14550 fail:
14551 return NULL;
14552 }
14553
14554
14555 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14556 PyObject *resultobj;
14557 wxEvent *arg1 = (wxEvent *) 0 ;
14558 wxEventType arg2 ;
14559 PyObject * obj0 = 0 ;
14560 PyObject * obj1 = 0 ;
14561 char *kwnames[] = {
14562 (char *) "self",(char *) "typ", NULL
14563 };
14564
14565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14567 if (SWIG_arg_fail(1)) SWIG_fail;
14568 {
14569 arg2 = (wxEventType)(SWIG_As_int(obj1));
14570 if (SWIG_arg_fail(2)) SWIG_fail;
14571 }
14572 {
14573 PyThreadState* __tstate = wxPyBeginAllowThreads();
14574 (arg1)->SetEventType(arg2);
14575
14576 wxPyEndAllowThreads(__tstate);
14577 if (PyErr_Occurred()) SWIG_fail;
14578 }
14579 Py_INCREF(Py_None); resultobj = Py_None;
14580 return resultobj;
14581 fail:
14582 return NULL;
14583 }
14584
14585
14586 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14587 PyObject *resultobj;
14588 wxEvent *arg1 = (wxEvent *) 0 ;
14589 wxEventType result;
14590 PyObject * obj0 = 0 ;
14591 char *kwnames[] = {
14592 (char *) "self", NULL
14593 };
14594
14595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14597 if (SWIG_arg_fail(1)) SWIG_fail;
14598 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14601
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 {
14606 resultobj = SWIG_From_int((int)(result));
14607 }
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj;
14616 wxEvent *arg1 = (wxEvent *) 0 ;
14617 wxObject *result;
14618 PyObject * obj0 = 0 ;
14619 char *kwnames[] = {
14620 (char *) "self", NULL
14621 };
14622
14623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14625 if (SWIG_arg_fail(1)) SWIG_fail;
14626 {
14627 PyThreadState* __tstate = wxPyBeginAllowThreads();
14628 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14629
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 {
14634 resultobj = wxPyMake_wxObject(result, 0);
14635 }
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj;
14644 wxEvent *arg1 = (wxEvent *) 0 ;
14645 wxObject *arg2 = (wxObject *) 0 ;
14646 PyObject * obj0 = 0 ;
14647 PyObject * obj1 = 0 ;
14648 char *kwnames[] = {
14649 (char *) "self",(char *) "obj", NULL
14650 };
14651
14652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14654 if (SWIG_arg_fail(1)) SWIG_fail;
14655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14656 if (SWIG_arg_fail(2)) SWIG_fail;
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 (arg1)->SetEventObject(arg2);
14660
14661 wxPyEndAllowThreads(__tstate);
14662 if (PyErr_Occurred()) SWIG_fail;
14663 }
14664 Py_INCREF(Py_None); resultobj = Py_None;
14665 return resultobj;
14666 fail:
14667 return NULL;
14668 }
14669
14670
14671 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj;
14673 wxEvent *arg1 = (wxEvent *) 0 ;
14674 long result;
14675 PyObject * obj0 = 0 ;
14676 char *kwnames[] = {
14677 (char *) "self", NULL
14678 };
14679
14680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14682 if (SWIG_arg_fail(1)) SWIG_fail;
14683 {
14684 PyThreadState* __tstate = wxPyBeginAllowThreads();
14685 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14686
14687 wxPyEndAllowThreads(__tstate);
14688 if (PyErr_Occurred()) SWIG_fail;
14689 }
14690 {
14691 resultobj = SWIG_From_long((long)(result));
14692 }
14693 return resultobj;
14694 fail:
14695 return NULL;
14696 }
14697
14698
14699 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14700 PyObject *resultobj;
14701 wxEvent *arg1 = (wxEvent *) 0 ;
14702 long arg2 = (long) 0 ;
14703 PyObject * obj0 = 0 ;
14704 PyObject * obj1 = 0 ;
14705 char *kwnames[] = {
14706 (char *) "self",(char *) "ts", NULL
14707 };
14708
14709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14711 if (SWIG_arg_fail(1)) SWIG_fail;
14712 if (obj1) {
14713 {
14714 arg2 = (long)(SWIG_As_long(obj1));
14715 if (SWIG_arg_fail(2)) SWIG_fail;
14716 }
14717 }
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 (arg1)->SetTimestamp(arg2);
14721
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 Py_INCREF(Py_None); resultobj = Py_None;
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14733 PyObject *resultobj;
14734 wxEvent *arg1 = (wxEvent *) 0 ;
14735 int result;
14736 PyObject * obj0 = 0 ;
14737 char *kwnames[] = {
14738 (char *) "self", NULL
14739 };
14740
14741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14743 if (SWIG_arg_fail(1)) SWIG_fail;
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (int)((wxEvent const *)arg1)->GetId();
14747
14748 wxPyEndAllowThreads(__tstate);
14749 if (PyErr_Occurred()) SWIG_fail;
14750 }
14751 {
14752 resultobj = SWIG_From_int((int)(result));
14753 }
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14761 PyObject *resultobj;
14762 wxEvent *arg1 = (wxEvent *) 0 ;
14763 int arg2 ;
14764 PyObject * obj0 = 0 ;
14765 PyObject * obj1 = 0 ;
14766 char *kwnames[] = {
14767 (char *) "self",(char *) "Id", NULL
14768 };
14769
14770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14772 if (SWIG_arg_fail(1)) SWIG_fail;
14773 {
14774 arg2 = (int)(SWIG_As_int(obj1));
14775 if (SWIG_arg_fail(2)) SWIG_fail;
14776 }
14777 {
14778 PyThreadState* __tstate = wxPyBeginAllowThreads();
14779 (arg1)->SetId(arg2);
14780
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 Py_INCREF(Py_None); resultobj = Py_None;
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14792 PyObject *resultobj;
14793 wxEvent *arg1 = (wxEvent *) 0 ;
14794 bool result;
14795 PyObject * obj0 = 0 ;
14796 char *kwnames[] = {
14797 (char *) "self", NULL
14798 };
14799
14800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14802 if (SWIG_arg_fail(1)) SWIG_fail;
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14806
14807 wxPyEndAllowThreads(__tstate);
14808 if (PyErr_Occurred()) SWIG_fail;
14809 }
14810 {
14811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14812 }
14813 return resultobj;
14814 fail:
14815 return NULL;
14816 }
14817
14818
14819 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14820 PyObject *resultobj;
14821 wxEvent *arg1 = (wxEvent *) 0 ;
14822 bool arg2 = (bool) true ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 char *kwnames[] = {
14826 (char *) "self",(char *) "skip", NULL
14827 };
14828
14829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14831 if (SWIG_arg_fail(1)) SWIG_fail;
14832 if (obj1) {
14833 {
14834 arg2 = (bool)(SWIG_As_bool(obj1));
14835 if (SWIG_arg_fail(2)) SWIG_fail;
14836 }
14837 }
14838 {
14839 PyThreadState* __tstate = wxPyBeginAllowThreads();
14840 (arg1)->Skip(arg2);
14841
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 Py_INCREF(Py_None); resultobj = Py_None;
14846 return resultobj;
14847 fail:
14848 return NULL;
14849 }
14850
14851
14852 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14853 PyObject *resultobj;
14854 wxEvent *arg1 = (wxEvent *) 0 ;
14855 bool result;
14856 PyObject * obj0 = 0 ;
14857 char *kwnames[] = {
14858 (char *) "self", NULL
14859 };
14860
14861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14863 if (SWIG_arg_fail(1)) SWIG_fail;
14864 {
14865 PyThreadState* __tstate = wxPyBeginAllowThreads();
14866 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14867
14868 wxPyEndAllowThreads(__tstate);
14869 if (PyErr_Occurred()) SWIG_fail;
14870 }
14871 {
14872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14873 }
14874 return resultobj;
14875 fail:
14876 return NULL;
14877 }
14878
14879
14880 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14881 PyObject *resultobj;
14882 wxEvent *arg1 = (wxEvent *) 0 ;
14883 bool result;
14884 PyObject * obj0 = 0 ;
14885 char *kwnames[] = {
14886 (char *) "self", NULL
14887 };
14888
14889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14891 if (SWIG_arg_fail(1)) SWIG_fail;
14892 {
14893 PyThreadState* __tstate = wxPyBeginAllowThreads();
14894 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14895
14896 wxPyEndAllowThreads(__tstate);
14897 if (PyErr_Occurred()) SWIG_fail;
14898 }
14899 {
14900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14901 }
14902 return resultobj;
14903 fail:
14904 return NULL;
14905 }
14906
14907
14908 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14909 PyObject *resultobj;
14910 wxEvent *arg1 = (wxEvent *) 0 ;
14911 int result;
14912 PyObject * obj0 = 0 ;
14913 char *kwnames[] = {
14914 (char *) "self", NULL
14915 };
14916
14917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14919 if (SWIG_arg_fail(1)) SWIG_fail;
14920 {
14921 PyThreadState* __tstate = wxPyBeginAllowThreads();
14922 result = (int)(arg1)->StopPropagation();
14923
14924 wxPyEndAllowThreads(__tstate);
14925 if (PyErr_Occurred()) SWIG_fail;
14926 }
14927 {
14928 resultobj = SWIG_From_int((int)(result));
14929 }
14930 return resultobj;
14931 fail:
14932 return NULL;
14933 }
14934
14935
14936 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14937 PyObject *resultobj;
14938 wxEvent *arg1 = (wxEvent *) 0 ;
14939 int arg2 ;
14940 PyObject * obj0 = 0 ;
14941 PyObject * obj1 = 0 ;
14942 char *kwnames[] = {
14943 (char *) "self",(char *) "propagationLevel", NULL
14944 };
14945
14946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14948 if (SWIG_arg_fail(1)) SWIG_fail;
14949 {
14950 arg2 = (int)(SWIG_As_int(obj1));
14951 if (SWIG_arg_fail(2)) SWIG_fail;
14952 }
14953 {
14954 PyThreadState* __tstate = wxPyBeginAllowThreads();
14955 (arg1)->ResumePropagation(arg2);
14956
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 Py_INCREF(Py_None); resultobj = Py_None;
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14968 PyObject *resultobj;
14969 wxEvent *arg1 = (wxEvent *) 0 ;
14970 wxEvent *result;
14971 PyObject * obj0 = 0 ;
14972 char *kwnames[] = {
14973 (char *) "self", NULL
14974 };
14975
14976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14978 if (SWIG_arg_fail(1)) SWIG_fail;
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 result = (wxEvent *)(arg1)->Clone();
14982
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14994 PyObject *obj;
14995 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14996 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14997 Py_INCREF(obj);
14998 return Py_BuildValue((char *)"");
14999 }
15000 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15001 PyObject *resultobj;
15002 wxEvent *arg1 = 0 ;
15003 wxPropagationDisabler *result;
15004 PyObject * obj0 = 0 ;
15005 char *kwnames[] = {
15006 (char *) "event", NULL
15007 };
15008
15009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15010 {
15011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15012 if (SWIG_arg_fail(1)) SWIG_fail;
15013 if (arg1 == NULL) {
15014 SWIG_null_ref("wxEvent");
15015 }
15016 if (SWIG_arg_fail(1)) SWIG_fail;
15017 }
15018 {
15019 PyThreadState* __tstate = wxPyBeginAllowThreads();
15020 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15021
15022 wxPyEndAllowThreads(__tstate);
15023 if (PyErr_Occurred()) SWIG_fail;
15024 }
15025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15026 return resultobj;
15027 fail:
15028 return NULL;
15029 }
15030
15031
15032 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15033 PyObject *resultobj;
15034 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15035 PyObject * obj0 = 0 ;
15036 char *kwnames[] = {
15037 (char *) "self", NULL
15038 };
15039
15040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15042 if (SWIG_arg_fail(1)) SWIG_fail;
15043 {
15044 PyThreadState* __tstate = wxPyBeginAllowThreads();
15045 delete arg1;
15046
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 Py_INCREF(Py_None); resultobj = Py_None;
15051 return resultobj;
15052 fail:
15053 return NULL;
15054 }
15055
15056
15057 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15058 PyObject *obj;
15059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15060 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15061 Py_INCREF(obj);
15062 return Py_BuildValue((char *)"");
15063 }
15064 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj;
15066 wxEvent *arg1 = 0 ;
15067 wxPropagateOnce *result;
15068 PyObject * obj0 = 0 ;
15069 char *kwnames[] = {
15070 (char *) "event", NULL
15071 };
15072
15073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15074 {
15075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15076 if (SWIG_arg_fail(1)) SWIG_fail;
15077 if (arg1 == NULL) {
15078 SWIG_null_ref("wxEvent");
15079 }
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 }
15082 {
15083 PyThreadState* __tstate = wxPyBeginAllowThreads();
15084 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15085
15086 wxPyEndAllowThreads(__tstate);
15087 if (PyErr_Occurred()) SWIG_fail;
15088 }
15089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15090 return resultobj;
15091 fail:
15092 return NULL;
15093 }
15094
15095
15096 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15097 PyObject *resultobj;
15098 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15099 PyObject * obj0 = 0 ;
15100 char *kwnames[] = {
15101 (char *) "self", NULL
15102 };
15103
15104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15106 if (SWIG_arg_fail(1)) SWIG_fail;
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 delete arg1;
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 * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15122 PyObject *obj;
15123 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15124 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15125 Py_INCREF(obj);
15126 return Py_BuildValue((char *)"");
15127 }
15128 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15129 PyObject *resultobj;
15130 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15131 int arg2 = (int) 0 ;
15132 wxCommandEvent *result;
15133 PyObject * obj0 = 0 ;
15134 PyObject * obj1 = 0 ;
15135 char *kwnames[] = {
15136 (char *) "commandType",(char *) "winid", NULL
15137 };
15138
15139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15140 if (obj0) {
15141 {
15142 arg1 = (wxEventType)(SWIG_As_int(obj0));
15143 if (SWIG_arg_fail(1)) SWIG_fail;
15144 }
15145 }
15146 if (obj1) {
15147 {
15148 arg2 = (int)(SWIG_As_int(obj1));
15149 if (SWIG_arg_fail(2)) SWIG_fail;
15150 }
15151 }
15152 {
15153 PyThreadState* __tstate = wxPyBeginAllowThreads();
15154 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15155
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15160 return resultobj;
15161 fail:
15162 return NULL;
15163 }
15164
15165
15166 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15167 PyObject *resultobj;
15168 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15169 int result;
15170 PyObject * obj0 = 0 ;
15171 char *kwnames[] = {
15172 (char *) "self", NULL
15173 };
15174
15175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15177 if (SWIG_arg_fail(1)) SWIG_fail;
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15181
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 {
15186 resultobj = SWIG_From_int((int)(result));
15187 }
15188 return resultobj;
15189 fail:
15190 return NULL;
15191 }
15192
15193
15194 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15195 PyObject *resultobj;
15196 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15197 wxString *arg2 = 0 ;
15198 bool temp2 = false ;
15199 PyObject * obj0 = 0 ;
15200 PyObject * obj1 = 0 ;
15201 char *kwnames[] = {
15202 (char *) "self",(char *) "s", NULL
15203 };
15204
15205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15207 if (SWIG_arg_fail(1)) SWIG_fail;
15208 {
15209 arg2 = wxString_in_helper(obj1);
15210 if (arg2 == NULL) SWIG_fail;
15211 temp2 = true;
15212 }
15213 {
15214 PyThreadState* __tstate = wxPyBeginAllowThreads();
15215 (arg1)->SetString((wxString const &)*arg2);
15216
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 Py_INCREF(Py_None); resultobj = Py_None;
15221 {
15222 if (temp2)
15223 delete arg2;
15224 }
15225 return resultobj;
15226 fail:
15227 {
15228 if (temp2)
15229 delete arg2;
15230 }
15231 return NULL;
15232 }
15233
15234
15235 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15236 PyObject *resultobj;
15237 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15238 wxString result;
15239 PyObject * obj0 = 0 ;
15240 char *kwnames[] = {
15241 (char *) "self", NULL
15242 };
15243
15244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15246 if (SWIG_arg_fail(1)) SWIG_fail;
15247 {
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = ((wxCommandEvent const *)arg1)->GetString();
15250
15251 wxPyEndAllowThreads(__tstate);
15252 if (PyErr_Occurred()) SWIG_fail;
15253 }
15254 {
15255 #if wxUSE_UNICODE
15256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15257 #else
15258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15259 #endif
15260 }
15261 return resultobj;
15262 fail:
15263 return NULL;
15264 }
15265
15266
15267 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15268 PyObject *resultobj;
15269 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15270 bool result;
15271 PyObject * obj0 = 0 ;
15272 char *kwnames[] = {
15273 (char *) "self", NULL
15274 };
15275
15276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15278 if (SWIG_arg_fail(1)) SWIG_fail;
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15282
15283 wxPyEndAllowThreads(__tstate);
15284 if (PyErr_Occurred()) SWIG_fail;
15285 }
15286 {
15287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15288 }
15289 return resultobj;
15290 fail:
15291 return NULL;
15292 }
15293
15294
15295 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15296 PyObject *resultobj;
15297 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15298 bool result;
15299 PyObject * obj0 = 0 ;
15300 char *kwnames[] = {
15301 (char *) "self", NULL
15302 };
15303
15304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15306 if (SWIG_arg_fail(1)) SWIG_fail;
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15310
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 {
15315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15316 }
15317 return resultobj;
15318 fail:
15319 return NULL;
15320 }
15321
15322
15323 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15324 PyObject *resultobj;
15325 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15326 long arg2 ;
15327 PyObject * obj0 = 0 ;
15328 PyObject * obj1 = 0 ;
15329 char *kwnames[] = {
15330 (char *) "self",(char *) "extraLong", NULL
15331 };
15332
15333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15335 if (SWIG_arg_fail(1)) SWIG_fail;
15336 {
15337 arg2 = (long)(SWIG_As_long(obj1));
15338 if (SWIG_arg_fail(2)) SWIG_fail;
15339 }
15340 {
15341 PyThreadState* __tstate = wxPyBeginAllowThreads();
15342 (arg1)->SetExtraLong(arg2);
15343
15344 wxPyEndAllowThreads(__tstate);
15345 if (PyErr_Occurred()) SWIG_fail;
15346 }
15347 Py_INCREF(Py_None); resultobj = Py_None;
15348 return resultobj;
15349 fail:
15350 return NULL;
15351 }
15352
15353
15354 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15355 PyObject *resultobj;
15356 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15357 long result;
15358 PyObject * obj0 = 0 ;
15359 char *kwnames[] = {
15360 (char *) "self", NULL
15361 };
15362
15363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15365 if (SWIG_arg_fail(1)) SWIG_fail;
15366 {
15367 PyThreadState* __tstate = wxPyBeginAllowThreads();
15368 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15369
15370 wxPyEndAllowThreads(__tstate);
15371 if (PyErr_Occurred()) SWIG_fail;
15372 }
15373 {
15374 resultobj = SWIG_From_long((long)(result));
15375 }
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15383 PyObject *resultobj;
15384 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15385 int arg2 ;
15386 PyObject * obj0 = 0 ;
15387 PyObject * obj1 = 0 ;
15388 char *kwnames[] = {
15389 (char *) "self",(char *) "i", NULL
15390 };
15391
15392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15394 if (SWIG_arg_fail(1)) SWIG_fail;
15395 {
15396 arg2 = (int)(SWIG_As_int(obj1));
15397 if (SWIG_arg_fail(2)) SWIG_fail;
15398 }
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 (arg1)->SetInt(arg2);
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 Py_INCREF(Py_None); resultobj = Py_None;
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15416 long result;
15417 PyObject * obj0 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 {
15433 resultobj = SWIG_From_long((long)(result));
15434 }
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj;
15443 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15444 wxEvent *result;
15445 PyObject * obj0 = 0 ;
15446 char *kwnames[] = {
15447 (char *) "self", NULL
15448 };
15449
15450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15452 if (SWIG_arg_fail(1)) SWIG_fail;
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15456
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15461 return resultobj;
15462 fail:
15463 return NULL;
15464 }
15465
15466
15467 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15468 PyObject *obj;
15469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15470 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15471 Py_INCREF(obj);
15472 return Py_BuildValue((char *)"");
15473 }
15474 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15475 PyObject *resultobj;
15476 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15477 int arg2 = (int) 0 ;
15478 wxNotifyEvent *result;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 char *kwnames[] = {
15482 (char *) "commandType",(char *) "winid", NULL
15483 };
15484
15485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15486 if (obj0) {
15487 {
15488 arg1 = (wxEventType)(SWIG_As_int(obj0));
15489 if (SWIG_arg_fail(1)) SWIG_fail;
15490 }
15491 }
15492 if (obj1) {
15493 {
15494 arg2 = (int)(SWIG_As_int(obj1));
15495 if (SWIG_arg_fail(2)) SWIG_fail;
15496 }
15497 }
15498 {
15499 PyThreadState* __tstate = wxPyBeginAllowThreads();
15500 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15501
15502 wxPyEndAllowThreads(__tstate);
15503 if (PyErr_Occurred()) SWIG_fail;
15504 }
15505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15506 return resultobj;
15507 fail:
15508 return NULL;
15509 }
15510
15511
15512 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15513 PyObject *resultobj;
15514 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15515 PyObject * obj0 = 0 ;
15516 char *kwnames[] = {
15517 (char *) "self", NULL
15518 };
15519
15520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15522 if (SWIG_arg_fail(1)) SWIG_fail;
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 (arg1)->Veto();
15526
15527 wxPyEndAllowThreads(__tstate);
15528 if (PyErr_Occurred()) SWIG_fail;
15529 }
15530 Py_INCREF(Py_None); resultobj = Py_None;
15531 return resultobj;
15532 fail:
15533 return NULL;
15534 }
15535
15536
15537 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15538 PyObject *resultobj;
15539 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15540 PyObject * obj0 = 0 ;
15541 char *kwnames[] = {
15542 (char *) "self", NULL
15543 };
15544
15545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15547 if (SWIG_arg_fail(1)) SWIG_fail;
15548 {
15549 PyThreadState* __tstate = wxPyBeginAllowThreads();
15550 (arg1)->Allow();
15551
15552 wxPyEndAllowThreads(__tstate);
15553 if (PyErr_Occurred()) SWIG_fail;
15554 }
15555 Py_INCREF(Py_None); resultobj = Py_None;
15556 return resultobj;
15557 fail:
15558 return NULL;
15559 }
15560
15561
15562 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15563 PyObject *resultobj;
15564 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15565 bool result;
15566 PyObject * obj0 = 0 ;
15567 char *kwnames[] = {
15568 (char *) "self", NULL
15569 };
15570
15571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15573 if (SWIG_arg_fail(1)) SWIG_fail;
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 result = (bool)(arg1)->IsAllowed();
15577
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 {
15582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15583 }
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15591 PyObject *obj;
15592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15593 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15594 Py_INCREF(obj);
15595 return Py_BuildValue((char *)"");
15596 }
15597 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15598 PyObject *resultobj;
15599 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15600 int arg2 = (int) 0 ;
15601 int arg3 = (int) 0 ;
15602 int arg4 = (int) 0 ;
15603 wxScrollEvent *result;
15604 PyObject * obj0 = 0 ;
15605 PyObject * obj1 = 0 ;
15606 PyObject * obj2 = 0 ;
15607 PyObject * obj3 = 0 ;
15608 char *kwnames[] = {
15609 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15610 };
15611
15612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15613 if (obj0) {
15614 {
15615 arg1 = (wxEventType)(SWIG_As_int(obj0));
15616 if (SWIG_arg_fail(1)) SWIG_fail;
15617 }
15618 }
15619 if (obj1) {
15620 {
15621 arg2 = (int)(SWIG_As_int(obj1));
15622 if (SWIG_arg_fail(2)) SWIG_fail;
15623 }
15624 }
15625 if (obj2) {
15626 {
15627 arg3 = (int)(SWIG_As_int(obj2));
15628 if (SWIG_arg_fail(3)) SWIG_fail;
15629 }
15630 }
15631 if (obj3) {
15632 {
15633 arg4 = (int)(SWIG_As_int(obj3));
15634 if (SWIG_arg_fail(4)) SWIG_fail;
15635 }
15636 }
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15640
15641 wxPyEndAllowThreads(__tstate);
15642 if (PyErr_Occurred()) SWIG_fail;
15643 }
15644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15652 PyObject *resultobj;
15653 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15654 int result;
15655 PyObject * obj0 = 0 ;
15656 char *kwnames[] = {
15657 (char *) "self", NULL
15658 };
15659
15660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15662 if (SWIG_arg_fail(1)) SWIG_fail;
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15666
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 {
15671 resultobj = SWIG_From_int((int)(result));
15672 }
15673 return resultobj;
15674 fail:
15675 return NULL;
15676 }
15677
15678
15679 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15680 PyObject *resultobj;
15681 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15682 int result;
15683 PyObject * obj0 = 0 ;
15684 char *kwnames[] = {
15685 (char *) "self", NULL
15686 };
15687
15688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15690 if (SWIG_arg_fail(1)) SWIG_fail;
15691 {
15692 PyThreadState* __tstate = wxPyBeginAllowThreads();
15693 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15694
15695 wxPyEndAllowThreads(__tstate);
15696 if (PyErr_Occurred()) SWIG_fail;
15697 }
15698 {
15699 resultobj = SWIG_From_int((int)(result));
15700 }
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15708 PyObject *resultobj;
15709 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15710 int arg2 ;
15711 PyObject * obj0 = 0 ;
15712 PyObject * obj1 = 0 ;
15713 char *kwnames[] = {
15714 (char *) "self",(char *) "orient", NULL
15715 };
15716
15717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15719 if (SWIG_arg_fail(1)) SWIG_fail;
15720 {
15721 arg2 = (int)(SWIG_As_int(obj1));
15722 if (SWIG_arg_fail(2)) SWIG_fail;
15723 }
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 (arg1)->SetOrientation(arg2);
15727
15728 wxPyEndAllowThreads(__tstate);
15729 if (PyErr_Occurred()) SWIG_fail;
15730 }
15731 Py_INCREF(Py_None); resultobj = Py_None;
15732 return resultobj;
15733 fail:
15734 return NULL;
15735 }
15736
15737
15738 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15739 PyObject *resultobj;
15740 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15741 int arg2 ;
15742 PyObject * obj0 = 0 ;
15743 PyObject * obj1 = 0 ;
15744 char *kwnames[] = {
15745 (char *) "self",(char *) "pos", NULL
15746 };
15747
15748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15750 if (SWIG_arg_fail(1)) SWIG_fail;
15751 {
15752 arg2 = (int)(SWIG_As_int(obj1));
15753 if (SWIG_arg_fail(2)) SWIG_fail;
15754 }
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 (arg1)->SetPosition(arg2);
15758
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 Py_INCREF(Py_None); resultobj = Py_None;
15763 return resultobj;
15764 fail:
15765 return NULL;
15766 }
15767
15768
15769 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15770 PyObject *obj;
15771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15772 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15773 Py_INCREF(obj);
15774 return Py_BuildValue((char *)"");
15775 }
15776 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj;
15778 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15779 int arg2 = (int) 0 ;
15780 int arg3 = (int) 0 ;
15781 wxScrollWinEvent *result;
15782 PyObject * obj0 = 0 ;
15783 PyObject * obj1 = 0 ;
15784 PyObject * obj2 = 0 ;
15785 char *kwnames[] = {
15786 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15787 };
15788
15789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15790 if (obj0) {
15791 {
15792 arg1 = (wxEventType)(SWIG_As_int(obj0));
15793 if (SWIG_arg_fail(1)) SWIG_fail;
15794 }
15795 }
15796 if (obj1) {
15797 {
15798 arg2 = (int)(SWIG_As_int(obj1));
15799 if (SWIG_arg_fail(2)) SWIG_fail;
15800 }
15801 }
15802 if (obj2) {
15803 {
15804 arg3 = (int)(SWIG_As_int(obj2));
15805 if (SWIG_arg_fail(3)) SWIG_fail;
15806 }
15807 }
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15811
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15816 return resultobj;
15817 fail:
15818 return NULL;
15819 }
15820
15821
15822 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15823 PyObject *resultobj;
15824 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15825 int result;
15826 PyObject * obj0 = 0 ;
15827 char *kwnames[] = {
15828 (char *) "self", NULL
15829 };
15830
15831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15833 if (SWIG_arg_fail(1)) SWIG_fail;
15834 {
15835 PyThreadState* __tstate = wxPyBeginAllowThreads();
15836 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15837
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 {
15842 resultobj = SWIG_From_int((int)(result));
15843 }
15844 return resultobj;
15845 fail:
15846 return NULL;
15847 }
15848
15849
15850 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15851 PyObject *resultobj;
15852 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15853 int result;
15854 PyObject * obj0 = 0 ;
15855 char *kwnames[] = {
15856 (char *) "self", NULL
15857 };
15858
15859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15861 if (SWIG_arg_fail(1)) SWIG_fail;
15862 {
15863 PyThreadState* __tstate = wxPyBeginAllowThreads();
15864 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15865
15866 wxPyEndAllowThreads(__tstate);
15867 if (PyErr_Occurred()) SWIG_fail;
15868 }
15869 {
15870 resultobj = SWIG_From_int((int)(result));
15871 }
15872 return resultobj;
15873 fail:
15874 return NULL;
15875 }
15876
15877
15878 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15879 PyObject *resultobj;
15880 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15881 int arg2 ;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 char *kwnames[] = {
15885 (char *) "self",(char *) "orient", NULL
15886 };
15887
15888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 {
15892 arg2 = (int)(SWIG_As_int(obj1));
15893 if (SWIG_arg_fail(2)) SWIG_fail;
15894 }
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 (arg1)->SetOrientation(arg2);
15898
15899 wxPyEndAllowThreads(__tstate);
15900 if (PyErr_Occurred()) SWIG_fail;
15901 }
15902 Py_INCREF(Py_None); resultobj = Py_None;
15903 return resultobj;
15904 fail:
15905 return NULL;
15906 }
15907
15908
15909 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15910 PyObject *resultobj;
15911 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15912 int arg2 ;
15913 PyObject * obj0 = 0 ;
15914 PyObject * obj1 = 0 ;
15915 char *kwnames[] = {
15916 (char *) "self",(char *) "pos", NULL
15917 };
15918
15919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15921 if (SWIG_arg_fail(1)) SWIG_fail;
15922 {
15923 arg2 = (int)(SWIG_As_int(obj1));
15924 if (SWIG_arg_fail(2)) SWIG_fail;
15925 }
15926 {
15927 PyThreadState* __tstate = wxPyBeginAllowThreads();
15928 (arg1)->SetPosition(arg2);
15929
15930 wxPyEndAllowThreads(__tstate);
15931 if (PyErr_Occurred()) SWIG_fail;
15932 }
15933 Py_INCREF(Py_None); resultobj = Py_None;
15934 return resultobj;
15935 fail:
15936 return NULL;
15937 }
15938
15939
15940 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15941 PyObject *obj;
15942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15943 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15944 Py_INCREF(obj);
15945 return Py_BuildValue((char *)"");
15946 }
15947 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15948 PyObject *resultobj;
15949 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15950 wxMouseEvent *result;
15951 PyObject * obj0 = 0 ;
15952 char *kwnames[] = {
15953 (char *) "mouseType", NULL
15954 };
15955
15956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15957 if (obj0) {
15958 {
15959 arg1 = (wxEventType)(SWIG_As_int(obj0));
15960 if (SWIG_arg_fail(1)) SWIG_fail;
15961 }
15962 }
15963 {
15964 PyThreadState* __tstate = wxPyBeginAllowThreads();
15965 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15966
15967 wxPyEndAllowThreads(__tstate);
15968 if (PyErr_Occurred()) SWIG_fail;
15969 }
15970 {
15971 resultobj = wxPyMake_wxObject(result, 1);
15972 }
15973 return resultobj;
15974 fail:
15975 return NULL;
15976 }
15977
15978
15979 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15980 PyObject *resultobj;
15981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15982 bool result;
15983 PyObject * obj0 = 0 ;
15984 char *kwnames[] = {
15985 (char *) "self", NULL
15986 };
15987
15988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15990 if (SWIG_arg_fail(1)) SWIG_fail;
15991 {
15992 PyThreadState* __tstate = wxPyBeginAllowThreads();
15993 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15994
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 {
15999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16000 }
16001 return resultobj;
16002 fail:
16003 return NULL;
16004 }
16005
16006
16007 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16008 PyObject *resultobj;
16009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16010 int arg2 = (int) wxMOUSE_BTN_ANY ;
16011 bool result;
16012 PyObject * obj0 = 0 ;
16013 PyObject * obj1 = 0 ;
16014 char *kwnames[] = {
16015 (char *) "self",(char *) "but", NULL
16016 };
16017
16018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16020 if (SWIG_arg_fail(1)) SWIG_fail;
16021 if (obj1) {
16022 {
16023 arg2 = (int)(SWIG_As_int(obj1));
16024 if (SWIG_arg_fail(2)) SWIG_fail;
16025 }
16026 }
16027 {
16028 PyThreadState* __tstate = wxPyBeginAllowThreads();
16029 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16030
16031 wxPyEndAllowThreads(__tstate);
16032 if (PyErr_Occurred()) SWIG_fail;
16033 }
16034 {
16035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16036 }
16037 return resultobj;
16038 fail:
16039 return NULL;
16040 }
16041
16042
16043 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16044 PyObject *resultobj;
16045 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16046 int arg2 = (int) wxMOUSE_BTN_ANY ;
16047 bool result;
16048 PyObject * obj0 = 0 ;
16049 PyObject * obj1 = 0 ;
16050 char *kwnames[] = {
16051 (char *) "self",(char *) "but", NULL
16052 };
16053
16054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16056 if (SWIG_arg_fail(1)) SWIG_fail;
16057 if (obj1) {
16058 {
16059 arg2 = (int)(SWIG_As_int(obj1));
16060 if (SWIG_arg_fail(2)) SWIG_fail;
16061 }
16062 }
16063 {
16064 PyThreadState* __tstate = wxPyBeginAllowThreads();
16065 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16066
16067 wxPyEndAllowThreads(__tstate);
16068 if (PyErr_Occurred()) SWIG_fail;
16069 }
16070 {
16071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16072 }
16073 return resultobj;
16074 fail:
16075 return NULL;
16076 }
16077
16078
16079 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16080 PyObject *resultobj;
16081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16082 int arg2 = (int) wxMOUSE_BTN_ANY ;
16083 bool result;
16084 PyObject * obj0 = 0 ;
16085 PyObject * obj1 = 0 ;
16086 char *kwnames[] = {
16087 (char *) "self",(char *) "but", NULL
16088 };
16089
16090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16092 if (SWIG_arg_fail(1)) SWIG_fail;
16093 if (obj1) {
16094 {
16095 arg2 = (int)(SWIG_As_int(obj1));
16096 if (SWIG_arg_fail(2)) SWIG_fail;
16097 }
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 {
16107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16108 }
16109 return resultobj;
16110 fail:
16111 return NULL;
16112 }
16113
16114
16115 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16116 PyObject *resultobj;
16117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16118 int arg2 ;
16119 bool result;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 char *kwnames[] = {
16123 (char *) "self",(char *) "but", NULL
16124 };
16125
16126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16128 if (SWIG_arg_fail(1)) SWIG_fail;
16129 {
16130 arg2 = (int)(SWIG_As_int(obj1));
16131 if (SWIG_arg_fail(2)) SWIG_fail;
16132 }
16133 {
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16136
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 {
16141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16142 }
16143 return resultobj;
16144 fail:
16145 return NULL;
16146 }
16147
16148
16149 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16150 PyObject *resultobj;
16151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16152 int arg2 ;
16153 bool result;
16154 PyObject * obj0 = 0 ;
16155 PyObject * obj1 = 0 ;
16156 char *kwnames[] = {
16157 (char *) "self",(char *) "but", NULL
16158 };
16159
16160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16162 if (SWIG_arg_fail(1)) SWIG_fail;
16163 {
16164 arg2 = (int)(SWIG_As_int(obj1));
16165 if (SWIG_arg_fail(2)) SWIG_fail;
16166 }
16167 {
16168 PyThreadState* __tstate = wxPyBeginAllowThreads();
16169 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16170
16171 wxPyEndAllowThreads(__tstate);
16172 if (PyErr_Occurred()) SWIG_fail;
16173 }
16174 {
16175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16176 }
16177 return resultobj;
16178 fail:
16179 return NULL;
16180 }
16181
16182
16183 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj;
16185 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16186 int result;
16187 PyObject * obj0 = 0 ;
16188 char *kwnames[] = {
16189 (char *) "self", NULL
16190 };
16191
16192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16194 if (SWIG_arg_fail(1)) SWIG_fail;
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16198
16199 wxPyEndAllowThreads(__tstate);
16200 if (PyErr_Occurred()) SWIG_fail;
16201 }
16202 {
16203 resultobj = SWIG_From_int((int)(result));
16204 }
16205 return resultobj;
16206 fail:
16207 return NULL;
16208 }
16209
16210
16211 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16212 PyObject *resultobj;
16213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16214 bool result;
16215 PyObject * obj0 = 0 ;
16216 char *kwnames[] = {
16217 (char *) "self", NULL
16218 };
16219
16220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16222 if (SWIG_arg_fail(1)) SWIG_fail;
16223 {
16224 PyThreadState* __tstate = wxPyBeginAllowThreads();
16225 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16226
16227 wxPyEndAllowThreads(__tstate);
16228 if (PyErr_Occurred()) SWIG_fail;
16229 }
16230 {
16231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16232 }
16233 return resultobj;
16234 fail:
16235 return NULL;
16236 }
16237
16238
16239 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16240 PyObject *resultobj;
16241 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16242 bool result;
16243 PyObject * obj0 = 0 ;
16244 char *kwnames[] = {
16245 (char *) "self", NULL
16246 };
16247
16248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16250 if (SWIG_arg_fail(1)) SWIG_fail;
16251 {
16252 PyThreadState* __tstate = wxPyBeginAllowThreads();
16253 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16254
16255 wxPyEndAllowThreads(__tstate);
16256 if (PyErr_Occurred()) SWIG_fail;
16257 }
16258 {
16259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16260 }
16261 return resultobj;
16262 fail:
16263 return NULL;
16264 }
16265
16266
16267 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16268 PyObject *resultobj;
16269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16270 bool result;
16271 PyObject * obj0 = 0 ;
16272 char *kwnames[] = {
16273 (char *) "self", NULL
16274 };
16275
16276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16278 if (SWIG_arg_fail(1)) SWIG_fail;
16279 {
16280 PyThreadState* __tstate = wxPyBeginAllowThreads();
16281 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16282
16283 wxPyEndAllowThreads(__tstate);
16284 if (PyErr_Occurred()) SWIG_fail;
16285 }
16286 {
16287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16288 }
16289 return resultobj;
16290 fail:
16291 return NULL;
16292 }
16293
16294
16295 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16296 PyObject *resultobj;
16297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16298 bool result;
16299 PyObject * obj0 = 0 ;
16300 char *kwnames[] = {
16301 (char *) "self", NULL
16302 };
16303
16304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16306 if (SWIG_arg_fail(1)) SWIG_fail;
16307 {
16308 PyThreadState* __tstate = wxPyBeginAllowThreads();
16309 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16310
16311 wxPyEndAllowThreads(__tstate);
16312 if (PyErr_Occurred()) SWIG_fail;
16313 }
16314 {
16315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16316 }
16317 return resultobj;
16318 fail:
16319 return NULL;
16320 }
16321
16322
16323 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16324 PyObject *resultobj;
16325 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16326 bool result;
16327 PyObject * obj0 = 0 ;
16328 char *kwnames[] = {
16329 (char *) "self", NULL
16330 };
16331
16332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16334 if (SWIG_arg_fail(1)) SWIG_fail;
16335 {
16336 PyThreadState* __tstate = wxPyBeginAllowThreads();
16337 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16338
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 {
16343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16344 }
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj;
16353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16354 bool result;
16355 PyObject * obj0 = 0 ;
16356 char *kwnames[] = {
16357 (char *) "self", NULL
16358 };
16359
16360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16362 if (SWIG_arg_fail(1)) SWIG_fail;
16363 {
16364 PyThreadState* __tstate = wxPyBeginAllowThreads();
16365 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16366
16367 wxPyEndAllowThreads(__tstate);
16368 if (PyErr_Occurred()) SWIG_fail;
16369 }
16370 {
16371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16372 }
16373 return resultobj;
16374 fail:
16375 return NULL;
16376 }
16377
16378
16379 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16380 PyObject *resultobj;
16381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16382 bool result;
16383 PyObject * obj0 = 0 ;
16384 char *kwnames[] = {
16385 (char *) "self", NULL
16386 };
16387
16388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16390 if (SWIG_arg_fail(1)) SWIG_fail;
16391 {
16392 PyThreadState* __tstate = wxPyBeginAllowThreads();
16393 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16394
16395 wxPyEndAllowThreads(__tstate);
16396 if (PyErr_Occurred()) SWIG_fail;
16397 }
16398 {
16399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16400 }
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj;
16409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16410 bool result;
16411 PyObject * obj0 = 0 ;
16412 char *kwnames[] = {
16413 (char *) "self", NULL
16414 };
16415
16416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16418 if (SWIG_arg_fail(1)) SWIG_fail;
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16422
16423 wxPyEndAllowThreads(__tstate);
16424 if (PyErr_Occurred()) SWIG_fail;
16425 }
16426 {
16427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16428 }
16429 return resultobj;
16430 fail:
16431 return NULL;
16432 }
16433
16434
16435 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16436 PyObject *resultobj;
16437 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16438 bool result;
16439 PyObject * obj0 = 0 ;
16440 char *kwnames[] = {
16441 (char *) "self", NULL
16442 };
16443
16444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16446 if (SWIG_arg_fail(1)) SWIG_fail;
16447 {
16448 PyThreadState* __tstate = wxPyBeginAllowThreads();
16449 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16450
16451 wxPyEndAllowThreads(__tstate);
16452 if (PyErr_Occurred()) SWIG_fail;
16453 }
16454 {
16455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16456 }
16457 return resultobj;
16458 fail:
16459 return NULL;
16460 }
16461
16462
16463 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16464 PyObject *resultobj;
16465 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16466 bool result;
16467 PyObject * obj0 = 0 ;
16468 char *kwnames[] = {
16469 (char *) "self", NULL
16470 };
16471
16472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16474 if (SWIG_arg_fail(1)) SWIG_fail;
16475 {
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16478
16479 wxPyEndAllowThreads(__tstate);
16480 if (PyErr_Occurred()) SWIG_fail;
16481 }
16482 {
16483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16484 }
16485 return resultobj;
16486 fail:
16487 return NULL;
16488 }
16489
16490
16491 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16492 PyObject *resultobj;
16493 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16494 bool result;
16495 PyObject * obj0 = 0 ;
16496 char *kwnames[] = {
16497 (char *) "self", NULL
16498 };
16499
16500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16502 if (SWIG_arg_fail(1)) SWIG_fail;
16503 {
16504 PyThreadState* __tstate = wxPyBeginAllowThreads();
16505 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16506
16507 wxPyEndAllowThreads(__tstate);
16508 if (PyErr_Occurred()) SWIG_fail;
16509 }
16510 {
16511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16512 }
16513 return resultobj;
16514 fail:
16515 return NULL;
16516 }
16517
16518
16519 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj;
16521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16522 bool result;
16523 PyObject * obj0 = 0 ;
16524 char *kwnames[] = {
16525 (char *) "self", NULL
16526 };
16527
16528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16530 if (SWIG_arg_fail(1)) SWIG_fail;
16531 {
16532 PyThreadState* __tstate = wxPyBeginAllowThreads();
16533 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16534
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 {
16539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16540 }
16541 return resultobj;
16542 fail:
16543 return NULL;
16544 }
16545
16546
16547 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16548 PyObject *resultobj;
16549 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16550 bool result;
16551 PyObject * obj0 = 0 ;
16552 char *kwnames[] = {
16553 (char *) "self", NULL
16554 };
16555
16556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16558 if (SWIG_arg_fail(1)) SWIG_fail;
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16562
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 {
16567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16568 }
16569 return resultobj;
16570 fail:
16571 return NULL;
16572 }
16573
16574
16575 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16576 PyObject *resultobj;
16577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16578 bool result;
16579 PyObject * obj0 = 0 ;
16580 char *kwnames[] = {
16581 (char *) "self", NULL
16582 };
16583
16584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16586 if (SWIG_arg_fail(1)) SWIG_fail;
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16590
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 {
16595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16596 }
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj;
16605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16606 bool result;
16607 PyObject * obj0 = 0 ;
16608 char *kwnames[] = {
16609 (char *) "self", NULL
16610 };
16611
16612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16614 if (SWIG_arg_fail(1)) SWIG_fail;
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 result = (bool)(arg1)->LeftIsDown();
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 {
16623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16624 }
16625 return resultobj;
16626 fail:
16627 return NULL;
16628 }
16629
16630
16631 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16632 PyObject *resultobj;
16633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16634 bool result;
16635 PyObject * obj0 = 0 ;
16636 char *kwnames[] = {
16637 (char *) "self", NULL
16638 };
16639
16640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16642 if (SWIG_arg_fail(1)) SWIG_fail;
16643 {
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 result = (bool)(arg1)->MiddleIsDown();
16646
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 {
16651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16652 }
16653 return resultobj;
16654 fail:
16655 return NULL;
16656 }
16657
16658
16659 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16660 PyObject *resultobj;
16661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16662 bool result;
16663 PyObject * obj0 = 0 ;
16664 char *kwnames[] = {
16665 (char *) "self", NULL
16666 };
16667
16668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16670 if (SWIG_arg_fail(1)) SWIG_fail;
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = (bool)(arg1)->RightIsDown();
16674
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 {
16679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16680 }
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16688 PyObject *resultobj;
16689 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16690 bool result;
16691 PyObject * obj0 = 0 ;
16692 char *kwnames[] = {
16693 (char *) "self", NULL
16694 };
16695
16696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16698 if (SWIG_arg_fail(1)) SWIG_fail;
16699 {
16700 PyThreadState* __tstate = wxPyBeginAllowThreads();
16701 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16702
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 {
16707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16708 }
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16716 PyObject *resultobj;
16717 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16718 bool result;
16719 PyObject * obj0 = 0 ;
16720 char *kwnames[] = {
16721 (char *) "self", NULL
16722 };
16723
16724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16726 if (SWIG_arg_fail(1)) SWIG_fail;
16727 {
16728 PyThreadState* __tstate = wxPyBeginAllowThreads();
16729 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16730
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 {
16735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16736 }
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj;
16745 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16746 bool result;
16747 PyObject * obj0 = 0 ;
16748 char *kwnames[] = {
16749 (char *) "self", NULL
16750 };
16751
16752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16754 if (SWIG_arg_fail(1)) SWIG_fail;
16755 {
16756 PyThreadState* __tstate = wxPyBeginAllowThreads();
16757 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16758
16759 wxPyEndAllowThreads(__tstate);
16760 if (PyErr_Occurred()) SWIG_fail;
16761 }
16762 {
16763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16764 }
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16772 PyObject *resultobj;
16773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16774 bool result;
16775 PyObject * obj0 = 0 ;
16776 char *kwnames[] = {
16777 (char *) "self", NULL
16778 };
16779
16780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16782 if (SWIG_arg_fail(1)) SWIG_fail;
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16786
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 {
16791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16792 }
16793 return resultobj;
16794 fail:
16795 return NULL;
16796 }
16797
16798
16799 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16800 PyObject *resultobj;
16801 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16802 wxPoint result;
16803 PyObject * obj0 = 0 ;
16804 char *kwnames[] = {
16805 (char *) "self", NULL
16806 };
16807
16808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16810 if (SWIG_arg_fail(1)) SWIG_fail;
16811 {
16812 PyThreadState* __tstate = wxPyBeginAllowThreads();
16813 result = (arg1)->GetPosition();
16814
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 {
16819 wxPoint * resultptr;
16820 resultptr = new wxPoint((wxPoint &)(result));
16821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16822 }
16823 return resultobj;
16824 fail:
16825 return NULL;
16826 }
16827
16828
16829 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16830 PyObject *resultobj;
16831 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16832 long *arg2 = (long *) 0 ;
16833 long *arg3 = (long *) 0 ;
16834 long temp2 ;
16835 int res2 = 0 ;
16836 long temp3 ;
16837 int res3 = 0 ;
16838 PyObject * obj0 = 0 ;
16839 char *kwnames[] = {
16840 (char *) "self", NULL
16841 };
16842
16843 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16844 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16847 if (SWIG_arg_fail(1)) SWIG_fail;
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 (arg1)->GetPosition(arg2,arg3);
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 Py_INCREF(Py_None); resultobj = Py_None;
16856 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16857 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16858 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16859 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj;
16868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16869 wxDC *arg2 = 0 ;
16870 wxPoint result;
16871 PyObject * obj0 = 0 ;
16872 PyObject * obj1 = 0 ;
16873 char *kwnames[] = {
16874 (char *) "self",(char *) "dc", NULL
16875 };
16876
16877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16879 if (SWIG_arg_fail(1)) SWIG_fail;
16880 {
16881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16882 if (SWIG_arg_fail(2)) SWIG_fail;
16883 if (arg2 == NULL) {
16884 SWIG_null_ref("wxDC");
16885 }
16886 if (SWIG_arg_fail(2)) SWIG_fail;
16887 }
16888 {
16889 PyThreadState* __tstate = wxPyBeginAllowThreads();
16890 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16891
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 {
16896 wxPoint * resultptr;
16897 resultptr = new wxPoint((wxPoint &)(result));
16898 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16899 }
16900 return resultobj;
16901 fail:
16902 return NULL;
16903 }
16904
16905
16906 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16907 PyObject *resultobj;
16908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16909 int result;
16910 PyObject * obj0 = 0 ;
16911 char *kwnames[] = {
16912 (char *) "self", NULL
16913 };
16914
16915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16917 if (SWIG_arg_fail(1)) SWIG_fail;
16918 {
16919 PyThreadState* __tstate = wxPyBeginAllowThreads();
16920 result = (int)((wxMouseEvent const *)arg1)->GetX();
16921
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 {
16926 resultobj = SWIG_From_int((int)(result));
16927 }
16928 return resultobj;
16929 fail:
16930 return NULL;
16931 }
16932
16933
16934 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16935 PyObject *resultobj;
16936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16937 int result;
16938 PyObject * obj0 = 0 ;
16939 char *kwnames[] = {
16940 (char *) "self", NULL
16941 };
16942
16943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16945 if (SWIG_arg_fail(1)) SWIG_fail;
16946 {
16947 PyThreadState* __tstate = wxPyBeginAllowThreads();
16948 result = (int)((wxMouseEvent const *)arg1)->GetY();
16949
16950 wxPyEndAllowThreads(__tstate);
16951 if (PyErr_Occurred()) SWIG_fail;
16952 }
16953 {
16954 resultobj = SWIG_From_int((int)(result));
16955 }
16956 return resultobj;
16957 fail:
16958 return NULL;
16959 }
16960
16961
16962 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16963 PyObject *resultobj;
16964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16965 int result;
16966 PyObject * obj0 = 0 ;
16967 char *kwnames[] = {
16968 (char *) "self", NULL
16969 };
16970
16971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16973 if (SWIG_arg_fail(1)) SWIG_fail;
16974 {
16975 PyThreadState* __tstate = wxPyBeginAllowThreads();
16976 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16977
16978 wxPyEndAllowThreads(__tstate);
16979 if (PyErr_Occurred()) SWIG_fail;
16980 }
16981 {
16982 resultobj = SWIG_From_int((int)(result));
16983 }
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16991 PyObject *resultobj;
16992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16993 int result;
16994 PyObject * obj0 = 0 ;
16995 char *kwnames[] = {
16996 (char *) "self", NULL
16997 };
16998
16999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17001 if (SWIG_arg_fail(1)) SWIG_fail;
17002 {
17003 PyThreadState* __tstate = wxPyBeginAllowThreads();
17004 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17005
17006 wxPyEndAllowThreads(__tstate);
17007 if (PyErr_Occurred()) SWIG_fail;
17008 }
17009 {
17010 resultobj = SWIG_From_int((int)(result));
17011 }
17012 return resultobj;
17013 fail:
17014 return NULL;
17015 }
17016
17017
17018 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17019 PyObject *resultobj;
17020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17021 int result;
17022 PyObject * obj0 = 0 ;
17023 char *kwnames[] = {
17024 (char *) "self", NULL
17025 };
17026
17027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17029 if (SWIG_arg_fail(1)) SWIG_fail;
17030 {
17031 PyThreadState* __tstate = wxPyBeginAllowThreads();
17032 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17033
17034 wxPyEndAllowThreads(__tstate);
17035 if (PyErr_Occurred()) SWIG_fail;
17036 }
17037 {
17038 resultobj = SWIG_From_int((int)(result));
17039 }
17040 return resultobj;
17041 fail:
17042 return NULL;
17043 }
17044
17045
17046 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17047 PyObject *resultobj;
17048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17049 bool result;
17050 PyObject * obj0 = 0 ;
17051 char *kwnames[] = {
17052 (char *) "self", NULL
17053 };
17054
17055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17057 if (SWIG_arg_fail(1)) SWIG_fail;
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17061
17062 wxPyEndAllowThreads(__tstate);
17063 if (PyErr_Occurred()) SWIG_fail;
17064 }
17065 {
17066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17067 }
17068 return resultobj;
17069 fail:
17070 return NULL;
17071 }
17072
17073
17074 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17075 PyObject *resultobj;
17076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17077 int arg2 ;
17078 PyObject * obj0 = 0 ;
17079 PyObject * obj1 = 0 ;
17080 char *kwnames[] = {
17081 (char *) "self",(char *) "m_x", NULL
17082 };
17083
17084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17086 if (SWIG_arg_fail(1)) SWIG_fail;
17087 {
17088 arg2 = (int)(SWIG_As_int(obj1));
17089 if (SWIG_arg_fail(2)) SWIG_fail;
17090 }
17091 if (arg1) (arg1)->m_x = arg2;
17092
17093 Py_INCREF(Py_None); resultobj = Py_None;
17094 return resultobj;
17095 fail:
17096 return NULL;
17097 }
17098
17099
17100 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17101 PyObject *resultobj;
17102 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17103 int result;
17104 PyObject * obj0 = 0 ;
17105 char *kwnames[] = {
17106 (char *) "self", NULL
17107 };
17108
17109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17111 if (SWIG_arg_fail(1)) SWIG_fail;
17112 result = (int) ((arg1)->m_x);
17113
17114 {
17115 resultobj = SWIG_From_int((int)(result));
17116 }
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj;
17125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17126 int arg2 ;
17127 PyObject * obj0 = 0 ;
17128 PyObject * obj1 = 0 ;
17129 char *kwnames[] = {
17130 (char *) "self",(char *) "m_y", NULL
17131 };
17132
17133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17135 if (SWIG_arg_fail(1)) SWIG_fail;
17136 {
17137 arg2 = (int)(SWIG_As_int(obj1));
17138 if (SWIG_arg_fail(2)) SWIG_fail;
17139 }
17140 if (arg1) (arg1)->m_y = arg2;
17141
17142 Py_INCREF(Py_None); resultobj = Py_None;
17143 return resultobj;
17144 fail:
17145 return NULL;
17146 }
17147
17148
17149 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17150 PyObject *resultobj;
17151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17152 int result;
17153 PyObject * obj0 = 0 ;
17154 char *kwnames[] = {
17155 (char *) "self", NULL
17156 };
17157
17158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17160 if (SWIG_arg_fail(1)) SWIG_fail;
17161 result = (int) ((arg1)->m_y);
17162
17163 {
17164 resultobj = SWIG_From_int((int)(result));
17165 }
17166 return resultobj;
17167 fail:
17168 return NULL;
17169 }
17170
17171
17172 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17173 PyObject *resultobj;
17174 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17175 bool arg2 ;
17176 PyObject * obj0 = 0 ;
17177 PyObject * obj1 = 0 ;
17178 char *kwnames[] = {
17179 (char *) "self",(char *) "m_leftDown", NULL
17180 };
17181
17182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17184 if (SWIG_arg_fail(1)) SWIG_fail;
17185 {
17186 arg2 = (bool)(SWIG_As_bool(obj1));
17187 if (SWIG_arg_fail(2)) SWIG_fail;
17188 }
17189 if (arg1) (arg1)->m_leftDown = arg2;
17190
17191 Py_INCREF(Py_None); resultobj = Py_None;
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj;
17200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17201 bool result;
17202 PyObject * obj0 = 0 ;
17203 char *kwnames[] = {
17204 (char *) "self", NULL
17205 };
17206
17207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17209 if (SWIG_arg_fail(1)) SWIG_fail;
17210 result = (bool) ((arg1)->m_leftDown);
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_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17222 PyObject *resultobj;
17223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17224 bool arg2 ;
17225 PyObject * obj0 = 0 ;
17226 PyObject * obj1 = 0 ;
17227 char *kwnames[] = {
17228 (char *) "self",(char *) "m_middleDown", NULL
17229 };
17230
17231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17233 if (SWIG_arg_fail(1)) SWIG_fail;
17234 {
17235 arg2 = (bool)(SWIG_As_bool(obj1));
17236 if (SWIG_arg_fail(2)) SWIG_fail;
17237 }
17238 if (arg1) (arg1)->m_middleDown = arg2;
17239
17240 Py_INCREF(Py_None); resultobj = Py_None;
17241 return resultobj;
17242 fail:
17243 return NULL;
17244 }
17245
17246
17247 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17248 PyObject *resultobj;
17249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17250 bool result;
17251 PyObject * obj0 = 0 ;
17252 char *kwnames[] = {
17253 (char *) "self", NULL
17254 };
17255
17256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17258 if (SWIG_arg_fail(1)) SWIG_fail;
17259 result = (bool) ((arg1)->m_middleDown);
17260
17261 {
17262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj;
17272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17273 bool arg2 ;
17274 PyObject * obj0 = 0 ;
17275 PyObject * obj1 = 0 ;
17276 char *kwnames[] = {
17277 (char *) "self",(char *) "m_rightDown", NULL
17278 };
17279
17280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17282 if (SWIG_arg_fail(1)) SWIG_fail;
17283 {
17284 arg2 = (bool)(SWIG_As_bool(obj1));
17285 if (SWIG_arg_fail(2)) SWIG_fail;
17286 }
17287 if (arg1) (arg1)->m_rightDown = arg2;
17288
17289 Py_INCREF(Py_None); resultobj = Py_None;
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17297 PyObject *resultobj;
17298 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17299 bool result;
17300 PyObject * obj0 = 0 ;
17301 char *kwnames[] = {
17302 (char *) "self", NULL
17303 };
17304
17305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17307 if (SWIG_arg_fail(1)) SWIG_fail;
17308 result = (bool) ((arg1)->m_rightDown);
17309
17310 {
17311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17312 }
17313 return resultobj;
17314 fail:
17315 return NULL;
17316 }
17317
17318
17319 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17320 PyObject *resultobj;
17321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17322 bool arg2 ;
17323 PyObject * obj0 = 0 ;
17324 PyObject * obj1 = 0 ;
17325 char *kwnames[] = {
17326 (char *) "self",(char *) "m_controlDown", NULL
17327 };
17328
17329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17331 if (SWIG_arg_fail(1)) SWIG_fail;
17332 {
17333 arg2 = (bool)(SWIG_As_bool(obj1));
17334 if (SWIG_arg_fail(2)) SWIG_fail;
17335 }
17336 if (arg1) (arg1)->m_controlDown = arg2;
17337
17338 Py_INCREF(Py_None); resultobj = Py_None;
17339 return resultobj;
17340 fail:
17341 return NULL;
17342 }
17343
17344
17345 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17346 PyObject *resultobj;
17347 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17348 bool result;
17349 PyObject * obj0 = 0 ;
17350 char *kwnames[] = {
17351 (char *) "self", NULL
17352 };
17353
17354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17356 if (SWIG_arg_fail(1)) SWIG_fail;
17357 result = (bool) ((arg1)->m_controlDown);
17358
17359 {
17360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17361 }
17362 return resultobj;
17363 fail:
17364 return NULL;
17365 }
17366
17367
17368 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17369 PyObject *resultobj;
17370 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17371 bool arg2 ;
17372 PyObject * obj0 = 0 ;
17373 PyObject * obj1 = 0 ;
17374 char *kwnames[] = {
17375 (char *) "self",(char *) "m_shiftDown", NULL
17376 };
17377
17378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17380 if (SWIG_arg_fail(1)) SWIG_fail;
17381 {
17382 arg2 = (bool)(SWIG_As_bool(obj1));
17383 if (SWIG_arg_fail(2)) SWIG_fail;
17384 }
17385 if (arg1) (arg1)->m_shiftDown = arg2;
17386
17387 Py_INCREF(Py_None); resultobj = Py_None;
17388 return resultobj;
17389 fail:
17390 return NULL;
17391 }
17392
17393
17394 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17395 PyObject *resultobj;
17396 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17397 bool result;
17398 PyObject * obj0 = 0 ;
17399 char *kwnames[] = {
17400 (char *) "self", NULL
17401 };
17402
17403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17405 if (SWIG_arg_fail(1)) SWIG_fail;
17406 result = (bool) ((arg1)->m_shiftDown);
17407
17408 {
17409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17410 }
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17418 PyObject *resultobj;
17419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17420 bool arg2 ;
17421 PyObject * obj0 = 0 ;
17422 PyObject * obj1 = 0 ;
17423 char *kwnames[] = {
17424 (char *) "self",(char *) "m_altDown", NULL
17425 };
17426
17427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17429 if (SWIG_arg_fail(1)) SWIG_fail;
17430 {
17431 arg2 = (bool)(SWIG_As_bool(obj1));
17432 if (SWIG_arg_fail(2)) SWIG_fail;
17433 }
17434 if (arg1) (arg1)->m_altDown = arg2;
17435
17436 Py_INCREF(Py_None); resultobj = Py_None;
17437 return resultobj;
17438 fail:
17439 return NULL;
17440 }
17441
17442
17443 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17444 PyObject *resultobj;
17445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17446 bool result;
17447 PyObject * obj0 = 0 ;
17448 char *kwnames[] = {
17449 (char *) "self", NULL
17450 };
17451
17452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17454 if (SWIG_arg_fail(1)) SWIG_fail;
17455 result = (bool) ((arg1)->m_altDown);
17456
17457 {
17458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17459 }
17460 return resultobj;
17461 fail:
17462 return NULL;
17463 }
17464
17465
17466 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17467 PyObject *resultobj;
17468 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17469 bool arg2 ;
17470 PyObject * obj0 = 0 ;
17471 PyObject * obj1 = 0 ;
17472 char *kwnames[] = {
17473 (char *) "self",(char *) "m_metaDown", NULL
17474 };
17475
17476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17478 if (SWIG_arg_fail(1)) SWIG_fail;
17479 {
17480 arg2 = (bool)(SWIG_As_bool(obj1));
17481 if (SWIG_arg_fail(2)) SWIG_fail;
17482 }
17483 if (arg1) (arg1)->m_metaDown = arg2;
17484
17485 Py_INCREF(Py_None); resultobj = Py_None;
17486 return resultobj;
17487 fail:
17488 return NULL;
17489 }
17490
17491
17492 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17493 PyObject *resultobj;
17494 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17495 bool result;
17496 PyObject * obj0 = 0 ;
17497 char *kwnames[] = {
17498 (char *) "self", NULL
17499 };
17500
17501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17503 if (SWIG_arg_fail(1)) SWIG_fail;
17504 result = (bool) ((arg1)->m_metaDown);
17505
17506 {
17507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17508 }
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj;
17517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17518 int arg2 ;
17519 PyObject * obj0 = 0 ;
17520 PyObject * obj1 = 0 ;
17521 char *kwnames[] = {
17522 (char *) "self",(char *) "m_wheelRotation", NULL
17523 };
17524
17525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17527 if (SWIG_arg_fail(1)) SWIG_fail;
17528 {
17529 arg2 = (int)(SWIG_As_int(obj1));
17530 if (SWIG_arg_fail(2)) SWIG_fail;
17531 }
17532 if (arg1) (arg1)->m_wheelRotation = arg2;
17533
17534 Py_INCREF(Py_None); resultobj = Py_None;
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj;
17543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17544 int result;
17545 PyObject * obj0 = 0 ;
17546 char *kwnames[] = {
17547 (char *) "self", NULL
17548 };
17549
17550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17552 if (SWIG_arg_fail(1)) SWIG_fail;
17553 result = (int) ((arg1)->m_wheelRotation);
17554
17555 {
17556 resultobj = SWIG_From_int((int)(result));
17557 }
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj;
17566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17567 int arg2 ;
17568 PyObject * obj0 = 0 ;
17569 PyObject * obj1 = 0 ;
17570 char *kwnames[] = {
17571 (char *) "self",(char *) "m_wheelDelta", NULL
17572 };
17573
17574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17576 if (SWIG_arg_fail(1)) SWIG_fail;
17577 {
17578 arg2 = (int)(SWIG_As_int(obj1));
17579 if (SWIG_arg_fail(2)) SWIG_fail;
17580 }
17581 if (arg1) (arg1)->m_wheelDelta = arg2;
17582
17583 Py_INCREF(Py_None); resultobj = Py_None;
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj;
17592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17593 int result;
17594 PyObject * obj0 = 0 ;
17595 char *kwnames[] = {
17596 (char *) "self", NULL
17597 };
17598
17599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17601 if (SWIG_arg_fail(1)) SWIG_fail;
17602 result = (int) ((arg1)->m_wheelDelta);
17603
17604 {
17605 resultobj = SWIG_From_int((int)(result));
17606 }
17607 return resultobj;
17608 fail:
17609 return NULL;
17610 }
17611
17612
17613 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17614 PyObject *resultobj;
17615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17616 int arg2 ;
17617 PyObject * obj0 = 0 ;
17618 PyObject * obj1 = 0 ;
17619 char *kwnames[] = {
17620 (char *) "self",(char *) "m_linesPerAction", NULL
17621 };
17622
17623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17625 if (SWIG_arg_fail(1)) SWIG_fail;
17626 {
17627 arg2 = (int)(SWIG_As_int(obj1));
17628 if (SWIG_arg_fail(2)) SWIG_fail;
17629 }
17630 if (arg1) (arg1)->m_linesPerAction = arg2;
17631
17632 Py_INCREF(Py_None); resultobj = Py_None;
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj;
17641 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17642 int result;
17643 PyObject * obj0 = 0 ;
17644 char *kwnames[] = {
17645 (char *) "self", NULL
17646 };
17647
17648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17650 if (SWIG_arg_fail(1)) SWIG_fail;
17651 result = (int) ((arg1)->m_linesPerAction);
17652
17653 {
17654 resultobj = SWIG_From_int((int)(result));
17655 }
17656 return resultobj;
17657 fail:
17658 return NULL;
17659 }
17660
17661
17662 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17663 PyObject *obj;
17664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17665 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17666 Py_INCREF(obj);
17667 return Py_BuildValue((char *)"");
17668 }
17669 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17670 PyObject *resultobj;
17671 int arg1 = (int) 0 ;
17672 int arg2 = (int) 0 ;
17673 wxSetCursorEvent *result;
17674 PyObject * obj0 = 0 ;
17675 PyObject * obj1 = 0 ;
17676 char *kwnames[] = {
17677 (char *) "x",(char *) "y", NULL
17678 };
17679
17680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17681 if (obj0) {
17682 {
17683 arg1 = (int)(SWIG_As_int(obj0));
17684 if (SWIG_arg_fail(1)) SWIG_fail;
17685 }
17686 }
17687 if (obj1) {
17688 {
17689 arg2 = (int)(SWIG_As_int(obj1));
17690 if (SWIG_arg_fail(2)) SWIG_fail;
17691 }
17692 }
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17696
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17701 return resultobj;
17702 fail:
17703 return NULL;
17704 }
17705
17706
17707 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17708 PyObject *resultobj;
17709 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17710 int result;
17711 PyObject * obj0 = 0 ;
17712 char *kwnames[] = {
17713 (char *) "self", NULL
17714 };
17715
17716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17718 if (SWIG_arg_fail(1)) SWIG_fail;
17719 {
17720 PyThreadState* __tstate = wxPyBeginAllowThreads();
17721 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17722
17723 wxPyEndAllowThreads(__tstate);
17724 if (PyErr_Occurred()) SWIG_fail;
17725 }
17726 {
17727 resultobj = SWIG_From_int((int)(result));
17728 }
17729 return resultobj;
17730 fail:
17731 return NULL;
17732 }
17733
17734
17735 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17736 PyObject *resultobj;
17737 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17738 int result;
17739 PyObject * obj0 = 0 ;
17740 char *kwnames[] = {
17741 (char *) "self", NULL
17742 };
17743
17744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17746 if (SWIG_arg_fail(1)) SWIG_fail;
17747 {
17748 PyThreadState* __tstate = wxPyBeginAllowThreads();
17749 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17750
17751 wxPyEndAllowThreads(__tstate);
17752 if (PyErr_Occurred()) SWIG_fail;
17753 }
17754 {
17755 resultobj = SWIG_From_int((int)(result));
17756 }
17757 return resultobj;
17758 fail:
17759 return NULL;
17760 }
17761
17762
17763 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj;
17765 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17766 wxCursor *arg2 = 0 ;
17767 PyObject * obj0 = 0 ;
17768 PyObject * obj1 = 0 ;
17769 char *kwnames[] = {
17770 (char *) "self",(char *) "cursor", NULL
17771 };
17772
17773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17775 if (SWIG_arg_fail(1)) SWIG_fail;
17776 {
17777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17778 if (SWIG_arg_fail(2)) SWIG_fail;
17779 if (arg2 == NULL) {
17780 SWIG_null_ref("wxCursor");
17781 }
17782 if (SWIG_arg_fail(2)) SWIG_fail;
17783 }
17784 {
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 (arg1)->SetCursor((wxCursor const &)*arg2);
17787
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 Py_INCREF(Py_None); resultobj = Py_None;
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17799 PyObject *resultobj;
17800 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17801 wxCursor *result;
17802 PyObject * obj0 = 0 ;
17803 char *kwnames[] = {
17804 (char *) "self", NULL
17805 };
17806
17807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17809 if (SWIG_arg_fail(1)) SWIG_fail;
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 {
17813 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17814 result = (wxCursor *) &_result_ref;
17815 }
17816
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 wxCursor* resultptr = new wxCursor(*result);
17822 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17823 }
17824 return resultobj;
17825 fail:
17826 return NULL;
17827 }
17828
17829
17830 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17831 PyObject *resultobj;
17832 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17833 bool result;
17834 PyObject * obj0 = 0 ;
17835 char *kwnames[] = {
17836 (char *) "self", NULL
17837 };
17838
17839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17841 if (SWIG_arg_fail(1)) SWIG_fail;
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17845
17846 wxPyEndAllowThreads(__tstate);
17847 if (PyErr_Occurred()) SWIG_fail;
17848 }
17849 {
17850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17851 }
17852 return resultobj;
17853 fail:
17854 return NULL;
17855 }
17856
17857
17858 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17859 PyObject *obj;
17860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17861 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17862 Py_INCREF(obj);
17863 return Py_BuildValue((char *)"");
17864 }
17865 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17866 PyObject *resultobj;
17867 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17868 wxKeyEvent *result;
17869 PyObject * obj0 = 0 ;
17870 char *kwnames[] = {
17871 (char *) "keyType", NULL
17872 };
17873
17874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17875 if (obj0) {
17876 {
17877 arg1 = (wxEventType)(SWIG_As_int(obj0));
17878 if (SWIG_arg_fail(1)) SWIG_fail;
17879 }
17880 }
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17884
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17889 return resultobj;
17890 fail:
17891 return NULL;
17892 }
17893
17894
17895 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17896 PyObject *resultobj;
17897 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17898 bool result;
17899 PyObject * obj0 = 0 ;
17900 char *kwnames[] = {
17901 (char *) "self", NULL
17902 };
17903
17904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17906 if (SWIG_arg_fail(1)) SWIG_fail;
17907 {
17908 PyThreadState* __tstate = wxPyBeginAllowThreads();
17909 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17910
17911 wxPyEndAllowThreads(__tstate);
17912 if (PyErr_Occurred()) SWIG_fail;
17913 }
17914 {
17915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17916 }
17917 return resultobj;
17918 fail:
17919 return NULL;
17920 }
17921
17922
17923 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17924 PyObject *resultobj;
17925 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17926 bool result;
17927 PyObject * obj0 = 0 ;
17928 char *kwnames[] = {
17929 (char *) "self", NULL
17930 };
17931
17932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17934 if (SWIG_arg_fail(1)) SWIG_fail;
17935 {
17936 PyThreadState* __tstate = wxPyBeginAllowThreads();
17937 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17938
17939 wxPyEndAllowThreads(__tstate);
17940 if (PyErr_Occurred()) SWIG_fail;
17941 }
17942 {
17943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17944 }
17945 return resultobj;
17946 fail:
17947 return NULL;
17948 }
17949
17950
17951 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17952 PyObject *resultobj;
17953 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17954 bool result;
17955 PyObject * obj0 = 0 ;
17956 char *kwnames[] = {
17957 (char *) "self", NULL
17958 };
17959
17960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17962 if (SWIG_arg_fail(1)) SWIG_fail;
17963 {
17964 PyThreadState* __tstate = wxPyBeginAllowThreads();
17965 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17966
17967 wxPyEndAllowThreads(__tstate);
17968 if (PyErr_Occurred()) SWIG_fail;
17969 }
17970 {
17971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17972 }
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17980 PyObject *resultobj;
17981 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17982 bool result;
17983 PyObject * obj0 = 0 ;
17984 char *kwnames[] = {
17985 (char *) "self", NULL
17986 };
17987
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17990 if (SWIG_arg_fail(1)) SWIG_fail;
17991 {
17992 PyThreadState* __tstate = wxPyBeginAllowThreads();
17993 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17994
17995 wxPyEndAllowThreads(__tstate);
17996 if (PyErr_Occurred()) SWIG_fail;
17997 }
17998 {
17999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18000 }
18001 return resultobj;
18002 fail:
18003 return NULL;
18004 }
18005
18006
18007 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18008 PyObject *resultobj;
18009 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18010 bool result;
18011 PyObject * obj0 = 0 ;
18012 char *kwnames[] = {
18013 (char *) "self", NULL
18014 };
18015
18016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18018 if (SWIG_arg_fail(1)) SWIG_fail;
18019 {
18020 PyThreadState* __tstate = wxPyBeginAllowThreads();
18021 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18022
18023 wxPyEndAllowThreads(__tstate);
18024 if (PyErr_Occurred()) SWIG_fail;
18025 }
18026 {
18027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18028 }
18029 return resultobj;
18030 fail:
18031 return NULL;
18032 }
18033
18034
18035 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18036 PyObject *resultobj;
18037 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18038 bool result;
18039 PyObject * obj0 = 0 ;
18040 char *kwnames[] = {
18041 (char *) "self", NULL
18042 };
18043
18044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18046 if (SWIG_arg_fail(1)) SWIG_fail;
18047 {
18048 PyThreadState* __tstate = wxPyBeginAllowThreads();
18049 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18050
18051 wxPyEndAllowThreads(__tstate);
18052 if (PyErr_Occurred()) SWIG_fail;
18053 }
18054 {
18055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18056 }
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18064 PyObject *resultobj;
18065 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18066 int result;
18067 PyObject * obj0 = 0 ;
18068 char *kwnames[] = {
18069 (char *) "self", NULL
18070 };
18071
18072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18074 if (SWIG_arg_fail(1)) SWIG_fail;
18075 {
18076 PyThreadState* __tstate = wxPyBeginAllowThreads();
18077 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18078
18079 wxPyEndAllowThreads(__tstate);
18080 if (PyErr_Occurred()) SWIG_fail;
18081 }
18082 {
18083 resultobj = SWIG_From_int((int)(result));
18084 }
18085 return resultobj;
18086 fail:
18087 return NULL;
18088 }
18089
18090
18091 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18092 PyObject *resultobj;
18093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18094 int result;
18095 PyObject * obj0 = 0 ;
18096 char *kwnames[] = {
18097 (char *) "self", NULL
18098 };
18099
18100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18102 if (SWIG_arg_fail(1)) SWIG_fail;
18103 {
18104 PyThreadState* __tstate = wxPyBeginAllowThreads();
18105 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18106
18107 wxPyEndAllowThreads(__tstate);
18108 if (PyErr_Occurred()) SWIG_fail;
18109 }
18110 {
18111 resultobj = SWIG_From_int((int)(result));
18112 }
18113 return resultobj;
18114 fail:
18115 return NULL;
18116 }
18117
18118
18119 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18120 PyObject *resultobj;
18121 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18122 unsigned int result;
18123 PyObject * obj0 = 0 ;
18124 char *kwnames[] = {
18125 (char *) "self", NULL
18126 };
18127
18128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18130 if (SWIG_arg_fail(1)) SWIG_fail;
18131 {
18132 PyThreadState* __tstate = wxPyBeginAllowThreads();
18133 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18134
18135 wxPyEndAllowThreads(__tstate);
18136 if (PyErr_Occurred()) SWIG_fail;
18137 }
18138 {
18139 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18140 }
18141 return resultobj;
18142 fail:
18143 return NULL;
18144 }
18145
18146
18147 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18148 PyObject *resultobj;
18149 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18150 unsigned int result;
18151 PyObject * obj0 = 0 ;
18152 char *kwnames[] = {
18153 (char *) "self", NULL
18154 };
18155
18156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18158 if (SWIG_arg_fail(1)) SWIG_fail;
18159 {
18160 PyThreadState* __tstate = wxPyBeginAllowThreads();
18161 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18162
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 {
18167 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18168 }
18169 return resultobj;
18170 fail:
18171 return NULL;
18172 }
18173
18174
18175 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18176 PyObject *resultobj;
18177 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18178 wxPoint result;
18179 PyObject * obj0 = 0 ;
18180 char *kwnames[] = {
18181 (char *) "self", NULL
18182 };
18183
18184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18186 if (SWIG_arg_fail(1)) SWIG_fail;
18187 {
18188 PyThreadState* __tstate = wxPyBeginAllowThreads();
18189 result = (arg1)->GetPosition();
18190
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 {
18195 wxPoint * resultptr;
18196 resultptr = new wxPoint((wxPoint &)(result));
18197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18198 }
18199 return resultobj;
18200 fail:
18201 return NULL;
18202 }
18203
18204
18205 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18206 PyObject *resultobj;
18207 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18208 long *arg2 = (long *) 0 ;
18209 long *arg3 = (long *) 0 ;
18210 long temp2 ;
18211 int res2 = 0 ;
18212 long temp3 ;
18213 int res3 = 0 ;
18214 PyObject * obj0 = 0 ;
18215 char *kwnames[] = {
18216 (char *) "self", NULL
18217 };
18218
18219 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18220 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18223 if (SWIG_arg_fail(1)) SWIG_fail;
18224 {
18225 PyThreadState* __tstate = wxPyBeginAllowThreads();
18226 (arg1)->GetPosition(arg2,arg3);
18227
18228 wxPyEndAllowThreads(__tstate);
18229 if (PyErr_Occurred()) SWIG_fail;
18230 }
18231 Py_INCREF(Py_None); resultobj = Py_None;
18232 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18233 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18234 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18235 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18236 return resultobj;
18237 fail:
18238 return NULL;
18239 }
18240
18241
18242 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18243 PyObject *resultobj;
18244 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18245 int result;
18246 PyObject * obj0 = 0 ;
18247 char *kwnames[] = {
18248 (char *) "self", NULL
18249 };
18250
18251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18253 if (SWIG_arg_fail(1)) SWIG_fail;
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 result = (int)((wxKeyEvent const *)arg1)->GetX();
18257
18258 wxPyEndAllowThreads(__tstate);
18259 if (PyErr_Occurred()) SWIG_fail;
18260 }
18261 {
18262 resultobj = SWIG_From_int((int)(result));
18263 }
18264 return resultobj;
18265 fail:
18266 return NULL;
18267 }
18268
18269
18270 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18271 PyObject *resultobj;
18272 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18273 int result;
18274 PyObject * obj0 = 0 ;
18275 char *kwnames[] = {
18276 (char *) "self", NULL
18277 };
18278
18279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18281 if (SWIG_arg_fail(1)) SWIG_fail;
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (int)((wxKeyEvent const *)arg1)->GetY();
18285
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 {
18290 resultobj = SWIG_From_int((int)(result));
18291 }
18292 return resultobj;
18293 fail:
18294 return NULL;
18295 }
18296
18297
18298 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18299 PyObject *resultobj;
18300 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18301 int arg2 ;
18302 PyObject * obj0 = 0 ;
18303 PyObject * obj1 = 0 ;
18304 char *kwnames[] = {
18305 (char *) "self",(char *) "m_x", NULL
18306 };
18307
18308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18310 if (SWIG_arg_fail(1)) SWIG_fail;
18311 {
18312 arg2 = (int)(SWIG_As_int(obj1));
18313 if (SWIG_arg_fail(2)) SWIG_fail;
18314 }
18315 if (arg1) (arg1)->m_x = arg2;
18316
18317 Py_INCREF(Py_None); resultobj = Py_None;
18318 return resultobj;
18319 fail:
18320 return NULL;
18321 }
18322
18323
18324 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18325 PyObject *resultobj;
18326 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18327 int result;
18328 PyObject * obj0 = 0 ;
18329 char *kwnames[] = {
18330 (char *) "self", NULL
18331 };
18332
18333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18335 if (SWIG_arg_fail(1)) SWIG_fail;
18336 result = (int) ((arg1)->m_x);
18337
18338 {
18339 resultobj = SWIG_From_int((int)(result));
18340 }
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj;
18349 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18350 int arg2 ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 char *kwnames[] = {
18354 (char *) "self",(char *) "m_y", NULL
18355 };
18356
18357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18359 if (SWIG_arg_fail(1)) SWIG_fail;
18360 {
18361 arg2 = (int)(SWIG_As_int(obj1));
18362 if (SWIG_arg_fail(2)) SWIG_fail;
18363 }
18364 if (arg1) (arg1)->m_y = arg2;
18365
18366 Py_INCREF(Py_None); resultobj = Py_None;
18367 return resultobj;
18368 fail:
18369 return NULL;
18370 }
18371
18372
18373 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18374 PyObject *resultobj;
18375 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18376 int result;
18377 PyObject * obj0 = 0 ;
18378 char *kwnames[] = {
18379 (char *) "self", NULL
18380 };
18381
18382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",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 result = (int) ((arg1)->m_y);
18386
18387 {
18388 resultobj = SWIG_From_int((int)(result));
18389 }
18390 return resultobj;
18391 fail:
18392 return NULL;
18393 }
18394
18395
18396 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18397 PyObject *resultobj;
18398 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18399 long arg2 ;
18400 PyObject * obj0 = 0 ;
18401 PyObject * obj1 = 0 ;
18402 char *kwnames[] = {
18403 (char *) "self",(char *) "m_keyCode", NULL
18404 };
18405
18406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18408 if (SWIG_arg_fail(1)) SWIG_fail;
18409 {
18410 arg2 = (long)(SWIG_As_long(obj1));
18411 if (SWIG_arg_fail(2)) SWIG_fail;
18412 }
18413 if (arg1) (arg1)->m_keyCode = arg2;
18414
18415 Py_INCREF(Py_None); resultobj = Py_None;
18416 return resultobj;
18417 fail:
18418 return NULL;
18419 }
18420
18421
18422 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18423 PyObject *resultobj;
18424 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18425 long result;
18426 PyObject * obj0 = 0 ;
18427 char *kwnames[] = {
18428 (char *) "self", NULL
18429 };
18430
18431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18433 if (SWIG_arg_fail(1)) SWIG_fail;
18434 result = (long) ((arg1)->m_keyCode);
18435
18436 {
18437 resultobj = SWIG_From_long((long)(result));
18438 }
18439 return resultobj;
18440 fail:
18441 return NULL;
18442 }
18443
18444
18445 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18446 PyObject *resultobj;
18447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18448 bool arg2 ;
18449 PyObject * obj0 = 0 ;
18450 PyObject * obj1 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self",(char *) "m_controlDown", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18457 if (SWIG_arg_fail(1)) SWIG_fail;
18458 {
18459 arg2 = (bool)(SWIG_As_bool(obj1));
18460 if (SWIG_arg_fail(2)) SWIG_fail;
18461 }
18462 if (arg1) (arg1)->m_controlDown = arg2;
18463
18464 Py_INCREF(Py_None); resultobj = Py_None;
18465 return resultobj;
18466 fail:
18467 return NULL;
18468 }
18469
18470
18471 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18472 PyObject *resultobj;
18473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18474 bool result;
18475 PyObject * obj0 = 0 ;
18476 char *kwnames[] = {
18477 (char *) "self", NULL
18478 };
18479
18480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18482 if (SWIG_arg_fail(1)) SWIG_fail;
18483 result = (bool) ((arg1)->m_controlDown);
18484
18485 {
18486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18487 }
18488 return resultobj;
18489 fail:
18490 return NULL;
18491 }
18492
18493
18494 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18495 PyObject *resultobj;
18496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18497 bool arg2 ;
18498 PyObject * obj0 = 0 ;
18499 PyObject * obj1 = 0 ;
18500 char *kwnames[] = {
18501 (char *) "self",(char *) "m_shiftDown", NULL
18502 };
18503
18504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18506 if (SWIG_arg_fail(1)) SWIG_fail;
18507 {
18508 arg2 = (bool)(SWIG_As_bool(obj1));
18509 if (SWIG_arg_fail(2)) SWIG_fail;
18510 }
18511 if (arg1) (arg1)->m_shiftDown = arg2;
18512
18513 Py_INCREF(Py_None); resultobj = Py_None;
18514 return resultobj;
18515 fail:
18516 return NULL;
18517 }
18518
18519
18520 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18521 PyObject *resultobj;
18522 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18523 bool result;
18524 PyObject * obj0 = 0 ;
18525 char *kwnames[] = {
18526 (char *) "self", NULL
18527 };
18528
18529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18531 if (SWIG_arg_fail(1)) SWIG_fail;
18532 result = (bool) ((arg1)->m_shiftDown);
18533
18534 {
18535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18536 }
18537 return resultobj;
18538 fail:
18539 return NULL;
18540 }
18541
18542
18543 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18544 PyObject *resultobj;
18545 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18546 bool arg2 ;
18547 PyObject * obj0 = 0 ;
18548 PyObject * obj1 = 0 ;
18549 char *kwnames[] = {
18550 (char *) "self",(char *) "m_altDown", NULL
18551 };
18552
18553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18555 if (SWIG_arg_fail(1)) SWIG_fail;
18556 {
18557 arg2 = (bool)(SWIG_As_bool(obj1));
18558 if (SWIG_arg_fail(2)) SWIG_fail;
18559 }
18560 if (arg1) (arg1)->m_altDown = arg2;
18561
18562 Py_INCREF(Py_None); resultobj = Py_None;
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18570 PyObject *resultobj;
18571 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18572 bool result;
18573 PyObject * obj0 = 0 ;
18574 char *kwnames[] = {
18575 (char *) "self", NULL
18576 };
18577
18578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",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 result = (bool) ((arg1)->m_altDown);
18582
18583 {
18584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18585 }
18586 return resultobj;
18587 fail:
18588 return NULL;
18589 }
18590
18591
18592 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18593 PyObject *resultobj;
18594 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18595 bool arg2 ;
18596 PyObject * obj0 = 0 ;
18597 PyObject * obj1 = 0 ;
18598 char *kwnames[] = {
18599 (char *) "self",(char *) "m_metaDown", NULL
18600 };
18601
18602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18604 if (SWIG_arg_fail(1)) SWIG_fail;
18605 {
18606 arg2 = (bool)(SWIG_As_bool(obj1));
18607 if (SWIG_arg_fail(2)) SWIG_fail;
18608 }
18609 if (arg1) (arg1)->m_metaDown = arg2;
18610
18611 Py_INCREF(Py_None); resultobj = Py_None;
18612 return resultobj;
18613 fail:
18614 return NULL;
18615 }
18616
18617
18618 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18619 PyObject *resultobj;
18620 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18621 bool result;
18622 PyObject * obj0 = 0 ;
18623 char *kwnames[] = {
18624 (char *) "self", NULL
18625 };
18626
18627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18629 if (SWIG_arg_fail(1)) SWIG_fail;
18630 result = (bool) ((arg1)->m_metaDown);
18631
18632 {
18633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18634 }
18635 return resultobj;
18636 fail:
18637 return NULL;
18638 }
18639
18640
18641 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18642 PyObject *resultobj;
18643 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18644 bool arg2 ;
18645 PyObject * obj0 = 0 ;
18646 PyObject * obj1 = 0 ;
18647 char *kwnames[] = {
18648 (char *) "self",(char *) "m_scanCode", NULL
18649 };
18650
18651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18653 if (SWIG_arg_fail(1)) SWIG_fail;
18654 {
18655 arg2 = (bool)(SWIG_As_bool(obj1));
18656 if (SWIG_arg_fail(2)) SWIG_fail;
18657 }
18658 if (arg1) (arg1)->m_scanCode = arg2;
18659
18660 Py_INCREF(Py_None); resultobj = Py_None;
18661 return resultobj;
18662 fail:
18663 return NULL;
18664 }
18665
18666
18667 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18668 PyObject *resultobj;
18669 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18670 bool result;
18671 PyObject * obj0 = 0 ;
18672 char *kwnames[] = {
18673 (char *) "self", NULL
18674 };
18675
18676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18678 if (SWIG_arg_fail(1)) SWIG_fail;
18679 result = (bool) ((arg1)->m_scanCode);
18680
18681 {
18682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18683 }
18684 return resultobj;
18685 fail:
18686 return NULL;
18687 }
18688
18689
18690 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18691 PyObject *resultobj;
18692 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18693 unsigned int arg2 ;
18694 PyObject * obj0 = 0 ;
18695 PyObject * obj1 = 0 ;
18696 char *kwnames[] = {
18697 (char *) "self",(char *) "m_rawCode", NULL
18698 };
18699
18700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18702 if (SWIG_arg_fail(1)) SWIG_fail;
18703 {
18704 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18705 if (SWIG_arg_fail(2)) SWIG_fail;
18706 }
18707 if (arg1) (arg1)->m_rawCode = arg2;
18708
18709 Py_INCREF(Py_None); resultobj = Py_None;
18710 return resultobj;
18711 fail:
18712 return NULL;
18713 }
18714
18715
18716 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18717 PyObject *resultobj;
18718 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18719 unsigned int result;
18720 PyObject * obj0 = 0 ;
18721 char *kwnames[] = {
18722 (char *) "self", NULL
18723 };
18724
18725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18727 if (SWIG_arg_fail(1)) SWIG_fail;
18728 result = (unsigned int) ((arg1)->m_rawCode);
18729
18730 {
18731 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18732 }
18733 return resultobj;
18734 fail:
18735 return NULL;
18736 }
18737
18738
18739 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18740 PyObject *resultobj;
18741 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18742 unsigned int arg2 ;
18743 PyObject * obj0 = 0 ;
18744 PyObject * obj1 = 0 ;
18745 char *kwnames[] = {
18746 (char *) "self",(char *) "m_rawFlags", NULL
18747 };
18748
18749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18751 if (SWIG_arg_fail(1)) SWIG_fail;
18752 {
18753 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18754 if (SWIG_arg_fail(2)) SWIG_fail;
18755 }
18756 if (arg1) (arg1)->m_rawFlags = arg2;
18757
18758 Py_INCREF(Py_None); resultobj = Py_None;
18759 return resultobj;
18760 fail:
18761 return NULL;
18762 }
18763
18764
18765 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18766 PyObject *resultobj;
18767 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18768 unsigned int result;
18769 PyObject * obj0 = 0 ;
18770 char *kwnames[] = {
18771 (char *) "self", NULL
18772 };
18773
18774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18776 if (SWIG_arg_fail(1)) SWIG_fail;
18777 result = (unsigned int) ((arg1)->m_rawFlags);
18778
18779 {
18780 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18781 }
18782 return resultobj;
18783 fail:
18784 return NULL;
18785 }
18786
18787
18788 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18789 PyObject *obj;
18790 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18791 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18792 Py_INCREF(obj);
18793 return Py_BuildValue((char *)"");
18794 }
18795 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18796 PyObject *resultobj;
18797 wxSize const &arg1_defvalue = wxDefaultSize ;
18798 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18799 int arg2 = (int) 0 ;
18800 wxSizeEvent *result;
18801 wxSize temp1 ;
18802 PyObject * obj0 = 0 ;
18803 PyObject * obj1 = 0 ;
18804 char *kwnames[] = {
18805 (char *) "sz",(char *) "winid", NULL
18806 };
18807
18808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18809 if (obj0) {
18810 {
18811 arg1 = &temp1;
18812 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18813 }
18814 }
18815 if (obj1) {
18816 {
18817 arg2 = (int)(SWIG_As_int(obj1));
18818 if (SWIG_arg_fail(2)) SWIG_fail;
18819 }
18820 }
18821 {
18822 PyThreadState* __tstate = wxPyBeginAllowThreads();
18823 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18824
18825 wxPyEndAllowThreads(__tstate);
18826 if (PyErr_Occurred()) SWIG_fail;
18827 }
18828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18829 return resultobj;
18830 fail:
18831 return NULL;
18832 }
18833
18834
18835 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18836 PyObject *resultobj;
18837 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18838 wxSize result;
18839 PyObject * obj0 = 0 ;
18840 char *kwnames[] = {
18841 (char *) "self", NULL
18842 };
18843
18844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18846 if (SWIG_arg_fail(1)) SWIG_fail;
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 result = ((wxSizeEvent const *)arg1)->GetSize();
18850
18851 wxPyEndAllowThreads(__tstate);
18852 if (PyErr_Occurred()) SWIG_fail;
18853 }
18854 {
18855 wxSize * resultptr;
18856 resultptr = new wxSize((wxSize &)(result));
18857 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18858 }
18859 return resultobj;
18860 fail:
18861 return NULL;
18862 }
18863
18864
18865 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18866 PyObject *resultobj;
18867 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18868 wxRect result;
18869 PyObject * obj0 = 0 ;
18870 char *kwnames[] = {
18871 (char *) "self", NULL
18872 };
18873
18874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18876 if (SWIG_arg_fail(1)) SWIG_fail;
18877 {
18878 PyThreadState* __tstate = wxPyBeginAllowThreads();
18879 result = ((wxSizeEvent const *)arg1)->GetRect();
18880
18881 wxPyEndAllowThreads(__tstate);
18882 if (PyErr_Occurred()) SWIG_fail;
18883 }
18884 {
18885 wxRect * resultptr;
18886 resultptr = new wxRect((wxRect &)(result));
18887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18888 }
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj;
18897 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18898 wxRect arg2 ;
18899 PyObject * obj0 = 0 ;
18900 PyObject * obj1 = 0 ;
18901 char *kwnames[] = {
18902 (char *) "self",(char *) "rect", NULL
18903 };
18904
18905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 {
18909 wxRect * argp;
18910 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18911 if (SWIG_arg_fail(2)) SWIG_fail;
18912 if (argp == NULL) {
18913 SWIG_null_ref("wxRect");
18914 }
18915 if (SWIG_arg_fail(2)) SWIG_fail;
18916 arg2 = *argp;
18917 }
18918 {
18919 PyThreadState* __tstate = wxPyBeginAllowThreads();
18920 (arg1)->SetRect(arg2);
18921
18922 wxPyEndAllowThreads(__tstate);
18923 if (PyErr_Occurred()) SWIG_fail;
18924 }
18925 Py_INCREF(Py_None); resultobj = Py_None;
18926 return resultobj;
18927 fail:
18928 return NULL;
18929 }
18930
18931
18932 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18933 PyObject *resultobj;
18934 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18935 wxSize arg2 ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 char *kwnames[] = {
18939 (char *) "self",(char *) "size", NULL
18940 };
18941
18942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18944 if (SWIG_arg_fail(1)) SWIG_fail;
18945 {
18946 wxSize * argp;
18947 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18948 if (SWIG_arg_fail(2)) SWIG_fail;
18949 if (argp == NULL) {
18950 SWIG_null_ref("wxSize");
18951 }
18952 if (SWIG_arg_fail(2)) SWIG_fail;
18953 arg2 = *argp;
18954 }
18955 {
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 wxSizeEvent_SetSize(arg1,arg2);
18958
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 Py_INCREF(Py_None); resultobj = Py_None;
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18970 PyObject *resultobj;
18971 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18972 wxSize *arg2 = (wxSize *) 0 ;
18973 PyObject * obj0 = 0 ;
18974 PyObject * obj1 = 0 ;
18975 char *kwnames[] = {
18976 (char *) "self",(char *) "m_size", NULL
18977 };
18978
18979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18981 if (SWIG_arg_fail(1)) SWIG_fail;
18982 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18983 if (SWIG_arg_fail(2)) SWIG_fail;
18984 if (arg1) (arg1)->m_size = *arg2;
18985
18986 Py_INCREF(Py_None); resultobj = Py_None;
18987 return resultobj;
18988 fail:
18989 return NULL;
18990 }
18991
18992
18993 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj;
18995 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18996 wxSize *result;
18997 PyObject * obj0 = 0 ;
18998 char *kwnames[] = {
18999 (char *) "self", NULL
19000 };
19001
19002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19004 if (SWIG_arg_fail(1)) SWIG_fail;
19005 result = (wxSize *)& ((arg1)->m_size);
19006
19007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19008 return resultobj;
19009 fail:
19010 return NULL;
19011 }
19012
19013
19014 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19015 PyObject *resultobj;
19016 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19017 wxRect *arg2 = (wxRect *) 0 ;
19018 PyObject * obj0 = 0 ;
19019 PyObject * obj1 = 0 ;
19020 char *kwnames[] = {
19021 (char *) "self",(char *) "m_rect", NULL
19022 };
19023
19024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19026 if (SWIG_arg_fail(1)) SWIG_fail;
19027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19028 if (SWIG_arg_fail(2)) SWIG_fail;
19029 if (arg1) (arg1)->m_rect = *arg2;
19030
19031 Py_INCREF(Py_None); resultobj = Py_None;
19032 return resultobj;
19033 fail:
19034 return NULL;
19035 }
19036
19037
19038 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19039 PyObject *resultobj;
19040 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19041 wxRect *result;
19042 PyObject * obj0 = 0 ;
19043 char *kwnames[] = {
19044 (char *) "self", NULL
19045 };
19046
19047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19049 if (SWIG_arg_fail(1)) SWIG_fail;
19050 result = (wxRect *)& ((arg1)->m_rect);
19051
19052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19060 PyObject *obj;
19061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19062 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19063 Py_INCREF(obj);
19064 return Py_BuildValue((char *)"");
19065 }
19066 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19067 PyObject *resultobj;
19068 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19069 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19070 int arg2 = (int) 0 ;
19071 wxMoveEvent *result;
19072 wxPoint temp1 ;
19073 PyObject * obj0 = 0 ;
19074 PyObject * obj1 = 0 ;
19075 char *kwnames[] = {
19076 (char *) "pos",(char *) "winid", NULL
19077 };
19078
19079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19080 if (obj0) {
19081 {
19082 arg1 = &temp1;
19083 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19084 }
19085 }
19086 if (obj1) {
19087 {
19088 arg2 = (int)(SWIG_As_int(obj1));
19089 if (SWIG_arg_fail(2)) SWIG_fail;
19090 }
19091 }
19092 {
19093 PyThreadState* __tstate = wxPyBeginAllowThreads();
19094 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19095
19096 wxPyEndAllowThreads(__tstate);
19097 if (PyErr_Occurred()) SWIG_fail;
19098 }
19099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19100 return resultobj;
19101 fail:
19102 return NULL;
19103 }
19104
19105
19106 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj;
19108 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19109 wxPoint result;
19110 PyObject * obj0 = 0 ;
19111 char *kwnames[] = {
19112 (char *) "self", NULL
19113 };
19114
19115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19117 if (SWIG_arg_fail(1)) SWIG_fail;
19118 {
19119 PyThreadState* __tstate = wxPyBeginAllowThreads();
19120 result = ((wxMoveEvent const *)arg1)->GetPosition();
19121
19122 wxPyEndAllowThreads(__tstate);
19123 if (PyErr_Occurred()) SWIG_fail;
19124 }
19125 {
19126 wxPoint * resultptr;
19127 resultptr = new wxPoint((wxPoint &)(result));
19128 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19129 }
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj;
19138 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19139 wxRect result;
19140 PyObject * obj0 = 0 ;
19141 char *kwnames[] = {
19142 (char *) "self", NULL
19143 };
19144
19145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19147 if (SWIG_arg_fail(1)) SWIG_fail;
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 result = ((wxMoveEvent const *)arg1)->GetRect();
19151
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 {
19156 wxRect * resultptr;
19157 resultptr = new wxRect((wxRect &)(result));
19158 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19159 }
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19167 PyObject *resultobj;
19168 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19169 wxRect *arg2 = 0 ;
19170 wxRect temp2 ;
19171 PyObject * obj0 = 0 ;
19172 PyObject * obj1 = 0 ;
19173 char *kwnames[] = {
19174 (char *) "self",(char *) "rect", NULL
19175 };
19176
19177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19179 if (SWIG_arg_fail(1)) SWIG_fail;
19180 {
19181 arg2 = &temp2;
19182 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19183 }
19184 {
19185 PyThreadState* __tstate = wxPyBeginAllowThreads();
19186 (arg1)->SetRect((wxRect const &)*arg2);
19187
19188 wxPyEndAllowThreads(__tstate);
19189 if (PyErr_Occurred()) SWIG_fail;
19190 }
19191 Py_INCREF(Py_None); resultobj = Py_None;
19192 return resultobj;
19193 fail:
19194 return NULL;
19195 }
19196
19197
19198 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19199 PyObject *resultobj;
19200 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19201 wxPoint *arg2 = 0 ;
19202 wxPoint temp2 ;
19203 PyObject * obj0 = 0 ;
19204 PyObject * obj1 = 0 ;
19205 char *kwnames[] = {
19206 (char *) "self",(char *) "pos", NULL
19207 };
19208
19209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19211 if (SWIG_arg_fail(1)) SWIG_fail;
19212 {
19213 arg2 = &temp2;
19214 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19215 }
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 (arg1)->SetPosition((wxPoint const &)*arg2);
19219
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 Py_INCREF(Py_None); resultobj = Py_None;
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19231 PyObject *obj;
19232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19233 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19234 Py_INCREF(obj);
19235 return Py_BuildValue((char *)"");
19236 }
19237 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19238 PyObject *resultobj;
19239 int arg1 = (int) 0 ;
19240 wxPaintEvent *result;
19241 PyObject * obj0 = 0 ;
19242 char *kwnames[] = {
19243 (char *) "Id", NULL
19244 };
19245
19246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19247 if (obj0) {
19248 {
19249 arg1 = (int)(SWIG_As_int(obj0));
19250 if (SWIG_arg_fail(1)) SWIG_fail;
19251 }
19252 }
19253 {
19254 PyThreadState* __tstate = wxPyBeginAllowThreads();
19255 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19256
19257 wxPyEndAllowThreads(__tstate);
19258 if (PyErr_Occurred()) SWIG_fail;
19259 }
19260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19261 return resultobj;
19262 fail:
19263 return NULL;
19264 }
19265
19266
19267 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19268 PyObject *obj;
19269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19270 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19271 Py_INCREF(obj);
19272 return Py_BuildValue((char *)"");
19273 }
19274 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19275 PyObject *resultobj;
19276 int arg1 = (int) 0 ;
19277 wxNcPaintEvent *result;
19278 PyObject * obj0 = 0 ;
19279 char *kwnames[] = {
19280 (char *) "winid", NULL
19281 };
19282
19283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19284 if (obj0) {
19285 {
19286 arg1 = (int)(SWIG_As_int(obj0));
19287 if (SWIG_arg_fail(1)) SWIG_fail;
19288 }
19289 }
19290 {
19291 PyThreadState* __tstate = wxPyBeginAllowThreads();
19292 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19293
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19298 return resultobj;
19299 fail:
19300 return NULL;
19301 }
19302
19303
19304 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19305 PyObject *obj;
19306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19307 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19308 Py_INCREF(obj);
19309 return Py_BuildValue((char *)"");
19310 }
19311 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19312 PyObject *resultobj;
19313 int arg1 = (int) 0 ;
19314 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19315 wxEraseEvent *result;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char *kwnames[] = {
19319 (char *) "Id",(char *) "dc", NULL
19320 };
19321
19322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19323 if (obj0) {
19324 {
19325 arg1 = (int)(SWIG_As_int(obj0));
19326 if (SWIG_arg_fail(1)) SWIG_fail;
19327 }
19328 }
19329 if (obj1) {
19330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19331 if (SWIG_arg_fail(2)) SWIG_fail;
19332 }
19333 {
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19336
19337 wxPyEndAllowThreads(__tstate);
19338 if (PyErr_Occurred()) SWIG_fail;
19339 }
19340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19341 return resultobj;
19342 fail:
19343 return NULL;
19344 }
19345
19346
19347 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19348 PyObject *resultobj;
19349 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19350 wxDC *result;
19351 PyObject * obj0 = 0 ;
19352 char *kwnames[] = {
19353 (char *) "self", NULL
19354 };
19355
19356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19358 if (SWIG_arg_fail(1)) SWIG_fail;
19359 {
19360 PyThreadState* __tstate = wxPyBeginAllowThreads();
19361 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19362
19363 wxPyEndAllowThreads(__tstate);
19364 if (PyErr_Occurred()) SWIG_fail;
19365 }
19366 {
19367 resultobj = wxPyMake_wxObject(result, 0);
19368 }
19369 return resultobj;
19370 fail:
19371 return NULL;
19372 }
19373
19374
19375 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19376 PyObject *obj;
19377 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19378 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19379 Py_INCREF(obj);
19380 return Py_BuildValue((char *)"");
19381 }
19382 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19383 PyObject *resultobj;
19384 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19385 int arg2 = (int) 0 ;
19386 wxFocusEvent *result;
19387 PyObject * obj0 = 0 ;
19388 PyObject * obj1 = 0 ;
19389 char *kwnames[] = {
19390 (char *) "type",(char *) "winid", NULL
19391 };
19392
19393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19394 if (obj0) {
19395 {
19396 arg1 = (wxEventType)(SWIG_As_int(obj0));
19397 if (SWIG_arg_fail(1)) SWIG_fail;
19398 }
19399 }
19400 if (obj1) {
19401 {
19402 arg2 = (int)(SWIG_As_int(obj1));
19403 if (SWIG_arg_fail(2)) SWIG_fail;
19404 }
19405 }
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19409
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19414 return resultobj;
19415 fail:
19416 return NULL;
19417 }
19418
19419
19420 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19421 PyObject *resultobj;
19422 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19423 wxWindow *result;
19424 PyObject * obj0 = 0 ;
19425 char *kwnames[] = {
19426 (char *) "self", NULL
19427 };
19428
19429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19431 if (SWIG_arg_fail(1)) SWIG_fail;
19432 {
19433 PyThreadState* __tstate = wxPyBeginAllowThreads();
19434 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19435
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 {
19440 resultobj = wxPyMake_wxObject(result, 0);
19441 }
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19449 PyObject *resultobj;
19450 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19451 wxWindow *arg2 = (wxWindow *) 0 ;
19452 PyObject * obj0 = 0 ;
19453 PyObject * obj1 = 0 ;
19454 char *kwnames[] = {
19455 (char *) "self",(char *) "win", NULL
19456 };
19457
19458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19460 if (SWIG_arg_fail(1)) SWIG_fail;
19461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19462 if (SWIG_arg_fail(2)) SWIG_fail;
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 (arg1)->SetWindow(arg2);
19466
19467 wxPyEndAllowThreads(__tstate);
19468 if (PyErr_Occurred()) SWIG_fail;
19469 }
19470 Py_INCREF(Py_None); resultobj = Py_None;
19471 return resultobj;
19472 fail:
19473 return NULL;
19474 }
19475
19476
19477 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19478 PyObject *obj;
19479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19480 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19481 Py_INCREF(obj);
19482 return Py_BuildValue((char *)"");
19483 }
19484 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19485 PyObject *resultobj;
19486 wxWindow *arg1 = (wxWindow *) NULL ;
19487 wxChildFocusEvent *result;
19488 PyObject * obj0 = 0 ;
19489 char *kwnames[] = {
19490 (char *) "win", NULL
19491 };
19492
19493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19494 if (obj0) {
19495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19496 if (SWIG_arg_fail(1)) SWIG_fail;
19497 }
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19501
19502 wxPyEndAllowThreads(__tstate);
19503 if (PyErr_Occurred()) SWIG_fail;
19504 }
19505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19506 return resultobj;
19507 fail:
19508 return NULL;
19509 }
19510
19511
19512 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19513 PyObject *resultobj;
19514 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19515 wxWindow *result;
19516 PyObject * obj0 = 0 ;
19517 char *kwnames[] = {
19518 (char *) "self", NULL
19519 };
19520
19521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19523 if (SWIG_arg_fail(1)) SWIG_fail;
19524 {
19525 PyThreadState* __tstate = wxPyBeginAllowThreads();
19526 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19527
19528 wxPyEndAllowThreads(__tstate);
19529 if (PyErr_Occurred()) SWIG_fail;
19530 }
19531 {
19532 resultobj = wxPyMake_wxObject(result, 0);
19533 }
19534 return resultobj;
19535 fail:
19536 return NULL;
19537 }
19538
19539
19540 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19541 PyObject *obj;
19542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19543 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19544 Py_INCREF(obj);
19545 return Py_BuildValue((char *)"");
19546 }
19547 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19548 PyObject *resultobj;
19549 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19550 bool arg2 = (bool) true ;
19551 int arg3 = (int) 0 ;
19552 wxActivateEvent *result;
19553 PyObject * obj0 = 0 ;
19554 PyObject * obj1 = 0 ;
19555 PyObject * obj2 = 0 ;
19556 char *kwnames[] = {
19557 (char *) "type",(char *) "active",(char *) "Id", NULL
19558 };
19559
19560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19561 if (obj0) {
19562 {
19563 arg1 = (wxEventType)(SWIG_As_int(obj0));
19564 if (SWIG_arg_fail(1)) SWIG_fail;
19565 }
19566 }
19567 if (obj1) {
19568 {
19569 arg2 = (bool)(SWIG_As_bool(obj1));
19570 if (SWIG_arg_fail(2)) SWIG_fail;
19571 }
19572 }
19573 if (obj2) {
19574 {
19575 arg3 = (int)(SWIG_As_int(obj2));
19576 if (SWIG_arg_fail(3)) SWIG_fail;
19577 }
19578 }
19579 {
19580 PyThreadState* __tstate = wxPyBeginAllowThreads();
19581 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19582
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19587 return resultobj;
19588 fail:
19589 return NULL;
19590 }
19591
19592
19593 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19594 PyObject *resultobj;
19595 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19596 bool result;
19597 PyObject * obj0 = 0 ;
19598 char *kwnames[] = {
19599 (char *) "self", NULL
19600 };
19601
19602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19604 if (SWIG_arg_fail(1)) SWIG_fail;
19605 {
19606 PyThreadState* __tstate = wxPyBeginAllowThreads();
19607 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19608
19609 wxPyEndAllowThreads(__tstate);
19610 if (PyErr_Occurred()) SWIG_fail;
19611 }
19612 {
19613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19614 }
19615 return resultobj;
19616 fail:
19617 return NULL;
19618 }
19619
19620
19621 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19622 PyObject *obj;
19623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19624 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19625 Py_INCREF(obj);
19626 return Py_BuildValue((char *)"");
19627 }
19628 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19629 PyObject *resultobj;
19630 int arg1 = (int) 0 ;
19631 wxInitDialogEvent *result;
19632 PyObject * obj0 = 0 ;
19633 char *kwnames[] = {
19634 (char *) "Id", NULL
19635 };
19636
19637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19638 if (obj0) {
19639 {
19640 arg1 = (int)(SWIG_As_int(obj0));
19641 if (SWIG_arg_fail(1)) SWIG_fail;
19642 }
19643 }
19644 {
19645 PyThreadState* __tstate = wxPyBeginAllowThreads();
19646 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19647
19648 wxPyEndAllowThreads(__tstate);
19649 if (PyErr_Occurred()) SWIG_fail;
19650 }
19651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19652 return resultobj;
19653 fail:
19654 return NULL;
19655 }
19656
19657
19658 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19659 PyObject *obj;
19660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19661 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19662 Py_INCREF(obj);
19663 return Py_BuildValue((char *)"");
19664 }
19665 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19666 PyObject *resultobj;
19667 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19668 int arg2 = (int) 0 ;
19669 wxMenu *arg3 = (wxMenu *) NULL ;
19670 wxMenuEvent *result;
19671 PyObject * obj0 = 0 ;
19672 PyObject * obj1 = 0 ;
19673 PyObject * obj2 = 0 ;
19674 char *kwnames[] = {
19675 (char *) "type",(char *) "winid",(char *) "menu", NULL
19676 };
19677
19678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19679 if (obj0) {
19680 {
19681 arg1 = (wxEventType)(SWIG_As_int(obj0));
19682 if (SWIG_arg_fail(1)) SWIG_fail;
19683 }
19684 }
19685 if (obj1) {
19686 {
19687 arg2 = (int)(SWIG_As_int(obj1));
19688 if (SWIG_arg_fail(2)) SWIG_fail;
19689 }
19690 }
19691 if (obj2) {
19692 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19693 if (SWIG_arg_fail(3)) SWIG_fail;
19694 }
19695 {
19696 PyThreadState* __tstate = wxPyBeginAllowThreads();
19697 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19698
19699 wxPyEndAllowThreads(__tstate);
19700 if (PyErr_Occurred()) SWIG_fail;
19701 }
19702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19703 return resultobj;
19704 fail:
19705 return NULL;
19706 }
19707
19708
19709 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19710 PyObject *resultobj;
19711 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19712 int result;
19713 PyObject * obj0 = 0 ;
19714 char *kwnames[] = {
19715 (char *) "self", NULL
19716 };
19717
19718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19720 if (SWIG_arg_fail(1)) SWIG_fail;
19721 {
19722 PyThreadState* __tstate = wxPyBeginAllowThreads();
19723 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19724
19725 wxPyEndAllowThreads(__tstate);
19726 if (PyErr_Occurred()) SWIG_fail;
19727 }
19728 {
19729 resultobj = SWIG_From_int((int)(result));
19730 }
19731 return resultobj;
19732 fail:
19733 return NULL;
19734 }
19735
19736
19737 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj;
19739 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19740 bool result;
19741 PyObject * obj0 = 0 ;
19742 char *kwnames[] = {
19743 (char *) "self", NULL
19744 };
19745
19746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19748 if (SWIG_arg_fail(1)) SWIG_fail;
19749 {
19750 PyThreadState* __tstate = wxPyBeginAllowThreads();
19751 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19752
19753 wxPyEndAllowThreads(__tstate);
19754 if (PyErr_Occurred()) SWIG_fail;
19755 }
19756 {
19757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19758 }
19759 return resultobj;
19760 fail:
19761 return NULL;
19762 }
19763
19764
19765 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19766 PyObject *resultobj;
19767 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19768 wxMenu *result;
19769 PyObject * obj0 = 0 ;
19770 char *kwnames[] = {
19771 (char *) "self", NULL
19772 };
19773
19774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19776 if (SWIG_arg_fail(1)) SWIG_fail;
19777 {
19778 PyThreadState* __tstate = wxPyBeginAllowThreads();
19779 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19780
19781 wxPyEndAllowThreads(__tstate);
19782 if (PyErr_Occurred()) SWIG_fail;
19783 }
19784 {
19785 resultobj = wxPyMake_wxObject(result, 0);
19786 }
19787 return resultobj;
19788 fail:
19789 return NULL;
19790 }
19791
19792
19793 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19794 PyObject *obj;
19795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19796 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19797 Py_INCREF(obj);
19798 return Py_BuildValue((char *)"");
19799 }
19800 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19801 PyObject *resultobj;
19802 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19803 int arg2 = (int) 0 ;
19804 wxCloseEvent *result;
19805 PyObject * obj0 = 0 ;
19806 PyObject * obj1 = 0 ;
19807 char *kwnames[] = {
19808 (char *) "type",(char *) "winid", NULL
19809 };
19810
19811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19812 if (obj0) {
19813 {
19814 arg1 = (wxEventType)(SWIG_As_int(obj0));
19815 if (SWIG_arg_fail(1)) SWIG_fail;
19816 }
19817 }
19818 if (obj1) {
19819 {
19820 arg2 = (int)(SWIG_As_int(obj1));
19821 if (SWIG_arg_fail(2)) SWIG_fail;
19822 }
19823 }
19824 {
19825 PyThreadState* __tstate = wxPyBeginAllowThreads();
19826 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19827
19828 wxPyEndAllowThreads(__tstate);
19829 if (PyErr_Occurred()) SWIG_fail;
19830 }
19831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19832 return resultobj;
19833 fail:
19834 return NULL;
19835 }
19836
19837
19838 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19839 PyObject *resultobj;
19840 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19841 bool arg2 ;
19842 PyObject * obj0 = 0 ;
19843 PyObject * obj1 = 0 ;
19844 char *kwnames[] = {
19845 (char *) "self",(char *) "logOff", NULL
19846 };
19847
19848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19850 if (SWIG_arg_fail(1)) SWIG_fail;
19851 {
19852 arg2 = (bool)(SWIG_As_bool(obj1));
19853 if (SWIG_arg_fail(2)) SWIG_fail;
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 (arg1)->SetLoggingOff(arg2);
19858
19859 wxPyEndAllowThreads(__tstate);
19860 if (PyErr_Occurred()) SWIG_fail;
19861 }
19862 Py_INCREF(Py_None); resultobj = Py_None;
19863 return resultobj;
19864 fail:
19865 return NULL;
19866 }
19867
19868
19869 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19870 PyObject *resultobj;
19871 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19872 bool result;
19873 PyObject * obj0 = 0 ;
19874 char *kwnames[] = {
19875 (char *) "self", NULL
19876 };
19877
19878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19880 if (SWIG_arg_fail(1)) SWIG_fail;
19881 {
19882 PyThreadState* __tstate = wxPyBeginAllowThreads();
19883 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19884
19885 wxPyEndAllowThreads(__tstate);
19886 if (PyErr_Occurred()) SWIG_fail;
19887 }
19888 {
19889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19890 }
19891 return resultobj;
19892 fail:
19893 return NULL;
19894 }
19895
19896
19897 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19898 PyObject *resultobj;
19899 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19900 bool arg2 = (bool) true ;
19901 PyObject * obj0 = 0 ;
19902 PyObject * obj1 = 0 ;
19903 char *kwnames[] = {
19904 (char *) "self",(char *) "veto", NULL
19905 };
19906
19907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19909 if (SWIG_arg_fail(1)) SWIG_fail;
19910 if (obj1) {
19911 {
19912 arg2 = (bool)(SWIG_As_bool(obj1));
19913 if (SWIG_arg_fail(2)) SWIG_fail;
19914 }
19915 }
19916 {
19917 PyThreadState* __tstate = wxPyBeginAllowThreads();
19918 (arg1)->Veto(arg2);
19919
19920 wxPyEndAllowThreads(__tstate);
19921 if (PyErr_Occurred()) SWIG_fail;
19922 }
19923 Py_INCREF(Py_None); resultobj = Py_None;
19924 return resultobj;
19925 fail:
19926 return NULL;
19927 }
19928
19929
19930 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj;
19932 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19933 bool arg2 ;
19934 PyObject * obj0 = 0 ;
19935 PyObject * obj1 = 0 ;
19936 char *kwnames[] = {
19937 (char *) "self",(char *) "canVeto", NULL
19938 };
19939
19940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19942 if (SWIG_arg_fail(1)) SWIG_fail;
19943 {
19944 arg2 = (bool)(SWIG_As_bool(obj1));
19945 if (SWIG_arg_fail(2)) SWIG_fail;
19946 }
19947 {
19948 PyThreadState* __tstate = wxPyBeginAllowThreads();
19949 (arg1)->SetCanVeto(arg2);
19950
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 Py_INCREF(Py_None); resultobj = Py_None;
19955 return resultobj;
19956 fail:
19957 return NULL;
19958 }
19959
19960
19961 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19962 PyObject *resultobj;
19963 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19964 bool result;
19965 PyObject * obj0 = 0 ;
19966 char *kwnames[] = {
19967 (char *) "self", NULL
19968 };
19969
19970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19972 if (SWIG_arg_fail(1)) SWIG_fail;
19973 {
19974 PyThreadState* __tstate = wxPyBeginAllowThreads();
19975 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19976
19977 wxPyEndAllowThreads(__tstate);
19978 if (PyErr_Occurred()) SWIG_fail;
19979 }
19980 {
19981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19982 }
19983 return resultobj;
19984 fail:
19985 return NULL;
19986 }
19987
19988
19989 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19990 PyObject *resultobj;
19991 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19992 bool result;
19993 PyObject * obj0 = 0 ;
19994 char *kwnames[] = {
19995 (char *) "self", NULL
19996 };
19997
19998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20000 if (SWIG_arg_fail(1)) SWIG_fail;
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20004
20005 wxPyEndAllowThreads(__tstate);
20006 if (PyErr_Occurred()) SWIG_fail;
20007 }
20008 {
20009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20010 }
20011 return resultobj;
20012 fail:
20013 return NULL;
20014 }
20015
20016
20017 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20018 PyObject *obj;
20019 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20020 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20021 Py_INCREF(obj);
20022 return Py_BuildValue((char *)"");
20023 }
20024 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20025 PyObject *resultobj;
20026 int arg1 = (int) 0 ;
20027 bool arg2 = (bool) false ;
20028 wxShowEvent *result;
20029 PyObject * obj0 = 0 ;
20030 PyObject * obj1 = 0 ;
20031 char *kwnames[] = {
20032 (char *) "winid",(char *) "show", NULL
20033 };
20034
20035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20036 if (obj0) {
20037 {
20038 arg1 = (int)(SWIG_As_int(obj0));
20039 if (SWIG_arg_fail(1)) SWIG_fail;
20040 }
20041 }
20042 if (obj1) {
20043 {
20044 arg2 = (bool)(SWIG_As_bool(obj1));
20045 if (SWIG_arg_fail(2)) SWIG_fail;
20046 }
20047 }
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20051
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20063 PyObject *resultobj;
20064 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20065 bool arg2 ;
20066 PyObject * obj0 = 0 ;
20067 PyObject * obj1 = 0 ;
20068 char *kwnames[] = {
20069 (char *) "self",(char *) "show", NULL
20070 };
20071
20072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20074 if (SWIG_arg_fail(1)) SWIG_fail;
20075 {
20076 arg2 = (bool)(SWIG_As_bool(obj1));
20077 if (SWIG_arg_fail(2)) SWIG_fail;
20078 }
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 (arg1)->SetShow(arg2);
20082
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 Py_INCREF(Py_None); resultobj = Py_None;
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20094 PyObject *resultobj;
20095 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20096 bool result;
20097 PyObject * obj0 = 0 ;
20098 char *kwnames[] = {
20099 (char *) "self", NULL
20100 };
20101
20102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20104 if (SWIG_arg_fail(1)) SWIG_fail;
20105 {
20106 PyThreadState* __tstate = wxPyBeginAllowThreads();
20107 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20108
20109 wxPyEndAllowThreads(__tstate);
20110 if (PyErr_Occurred()) SWIG_fail;
20111 }
20112 {
20113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20114 }
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20122 PyObject *obj;
20123 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20124 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20125 Py_INCREF(obj);
20126 return Py_BuildValue((char *)"");
20127 }
20128 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20129 PyObject *resultobj;
20130 int arg1 = (int) 0 ;
20131 bool arg2 = (bool) true ;
20132 wxIconizeEvent *result;
20133 PyObject * obj0 = 0 ;
20134 PyObject * obj1 = 0 ;
20135 char *kwnames[] = {
20136 (char *) "id",(char *) "iconized", NULL
20137 };
20138
20139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20140 if (obj0) {
20141 {
20142 arg1 = (int)(SWIG_As_int(obj0));
20143 if (SWIG_arg_fail(1)) SWIG_fail;
20144 }
20145 }
20146 if (obj1) {
20147 {
20148 arg2 = (bool)(SWIG_As_bool(obj1));
20149 if (SWIG_arg_fail(2)) SWIG_fail;
20150 }
20151 }
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20155
20156 wxPyEndAllowThreads(__tstate);
20157 if (PyErr_Occurred()) SWIG_fail;
20158 }
20159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj;
20168 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20169 bool result;
20170 PyObject * obj0 = 0 ;
20171 char *kwnames[] = {
20172 (char *) "self", NULL
20173 };
20174
20175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20177 if (SWIG_arg_fail(1)) SWIG_fail;
20178 {
20179 PyThreadState* __tstate = wxPyBeginAllowThreads();
20180 result = (bool)(arg1)->Iconized();
20181
20182 wxPyEndAllowThreads(__tstate);
20183 if (PyErr_Occurred()) SWIG_fail;
20184 }
20185 {
20186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20187 }
20188 return resultobj;
20189 fail:
20190 return NULL;
20191 }
20192
20193
20194 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20195 PyObject *obj;
20196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20197 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20198 Py_INCREF(obj);
20199 return Py_BuildValue((char *)"");
20200 }
20201 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20202 PyObject *resultobj;
20203 int arg1 = (int) 0 ;
20204 wxMaximizeEvent *result;
20205 PyObject * obj0 = 0 ;
20206 char *kwnames[] = {
20207 (char *) "id", NULL
20208 };
20209
20210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20211 if (obj0) {
20212 {
20213 arg1 = (int)(SWIG_As_int(obj0));
20214 if (SWIG_arg_fail(1)) SWIG_fail;
20215 }
20216 }
20217 {
20218 PyThreadState* __tstate = wxPyBeginAllowThreads();
20219 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20220
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20232 PyObject *obj;
20233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20234 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20235 Py_INCREF(obj);
20236 return Py_BuildValue((char *)"");
20237 }
20238 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20239 PyObject *resultobj;
20240 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20241 wxPoint result;
20242 PyObject * obj0 = 0 ;
20243 char *kwnames[] = {
20244 (char *) "self", NULL
20245 };
20246
20247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20249 if (SWIG_arg_fail(1)) SWIG_fail;
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (arg1)->GetPosition();
20253
20254 wxPyEndAllowThreads(__tstate);
20255 if (PyErr_Occurred()) SWIG_fail;
20256 }
20257 {
20258 wxPoint * resultptr;
20259 resultptr = new wxPoint((wxPoint &)(result));
20260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20261 }
20262 return resultobj;
20263 fail:
20264 return NULL;
20265 }
20266
20267
20268 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20269 PyObject *resultobj;
20270 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20271 int result;
20272 PyObject * obj0 = 0 ;
20273 char *kwnames[] = {
20274 (char *) "self", NULL
20275 };
20276
20277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20279 if (SWIG_arg_fail(1)) SWIG_fail;
20280 {
20281 PyThreadState* __tstate = wxPyBeginAllowThreads();
20282 result = (int)(arg1)->GetNumberOfFiles();
20283
20284 wxPyEndAllowThreads(__tstate);
20285 if (PyErr_Occurred()) SWIG_fail;
20286 }
20287 {
20288 resultobj = SWIG_From_int((int)(result));
20289 }
20290 return resultobj;
20291 fail:
20292 return NULL;
20293 }
20294
20295
20296 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20297 PyObject *resultobj;
20298 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20299 PyObject *result;
20300 PyObject * obj0 = 0 ;
20301 char *kwnames[] = {
20302 (char *) "self", NULL
20303 };
20304
20305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20307 if (SWIG_arg_fail(1)) SWIG_fail;
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20311
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 resultobj = result;
20316 return resultobj;
20317 fail:
20318 return NULL;
20319 }
20320
20321
20322 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20323 PyObject *obj;
20324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20325 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20326 Py_INCREF(obj);
20327 return Py_BuildValue((char *)"");
20328 }
20329 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj;
20331 int arg1 = (int) 0 ;
20332 wxUpdateUIEvent *result;
20333 PyObject * obj0 = 0 ;
20334 char *kwnames[] = {
20335 (char *) "commandId", NULL
20336 };
20337
20338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20339 if (obj0) {
20340 {
20341 arg1 = (int)(SWIG_As_int(obj0));
20342 if (SWIG_arg_fail(1)) SWIG_fail;
20343 }
20344 }
20345 {
20346 PyThreadState* __tstate = wxPyBeginAllowThreads();
20347 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20348
20349 wxPyEndAllowThreads(__tstate);
20350 if (PyErr_Occurred()) SWIG_fail;
20351 }
20352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20360 PyObject *resultobj;
20361 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20362 bool result;
20363 PyObject * obj0 = 0 ;
20364 char *kwnames[] = {
20365 (char *) "self", NULL
20366 };
20367
20368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20370 if (SWIG_arg_fail(1)) SWIG_fail;
20371 {
20372 PyThreadState* __tstate = wxPyBeginAllowThreads();
20373 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20374
20375 wxPyEndAllowThreads(__tstate);
20376 if (PyErr_Occurred()) SWIG_fail;
20377 }
20378 {
20379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20380 }
20381 return resultobj;
20382 fail:
20383 return NULL;
20384 }
20385
20386
20387 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20388 PyObject *resultobj;
20389 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20390 bool result;
20391 PyObject * obj0 = 0 ;
20392 char *kwnames[] = {
20393 (char *) "self", NULL
20394 };
20395
20396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20398 if (SWIG_arg_fail(1)) SWIG_fail;
20399 {
20400 PyThreadState* __tstate = wxPyBeginAllowThreads();
20401 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20402
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 {
20407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20408 }
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20416 PyObject *resultobj;
20417 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20418 wxString result;
20419 PyObject * obj0 = 0 ;
20420 char *kwnames[] = {
20421 (char *) "self", NULL
20422 };
20423
20424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20426 if (SWIG_arg_fail(1)) SWIG_fail;
20427 {
20428 PyThreadState* __tstate = wxPyBeginAllowThreads();
20429 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20430
20431 wxPyEndAllowThreads(__tstate);
20432 if (PyErr_Occurred()) SWIG_fail;
20433 }
20434 {
20435 #if wxUSE_UNICODE
20436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20437 #else
20438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20439 #endif
20440 }
20441 return resultobj;
20442 fail:
20443 return NULL;
20444 }
20445
20446
20447 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20448 PyObject *resultobj;
20449 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20450 bool result;
20451 PyObject * obj0 = 0 ;
20452 char *kwnames[] = {
20453 (char *) "self", NULL
20454 };
20455
20456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20458 if (SWIG_arg_fail(1)) SWIG_fail;
20459 {
20460 PyThreadState* __tstate = wxPyBeginAllowThreads();
20461 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20462
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 {
20467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20468 }
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20476 PyObject *resultobj;
20477 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20478 bool result;
20479 PyObject * obj0 = 0 ;
20480 char *kwnames[] = {
20481 (char *) "self", NULL
20482 };
20483
20484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20486 if (SWIG_arg_fail(1)) SWIG_fail;
20487 {
20488 PyThreadState* __tstate = wxPyBeginAllowThreads();
20489 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20490
20491 wxPyEndAllowThreads(__tstate);
20492 if (PyErr_Occurred()) SWIG_fail;
20493 }
20494 {
20495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20496 }
20497 return resultobj;
20498 fail:
20499 return NULL;
20500 }
20501
20502
20503 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20504 PyObject *resultobj;
20505 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20506 bool result;
20507 PyObject * obj0 = 0 ;
20508 char *kwnames[] = {
20509 (char *) "self", NULL
20510 };
20511
20512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20514 if (SWIG_arg_fail(1)) SWIG_fail;
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20518
20519 wxPyEndAllowThreads(__tstate);
20520 if (PyErr_Occurred()) SWIG_fail;
20521 }
20522 {
20523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20524 }
20525 return resultobj;
20526 fail:
20527 return NULL;
20528 }
20529
20530
20531 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20532 PyObject *resultobj;
20533 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20534 bool arg2 ;
20535 PyObject * obj0 = 0 ;
20536 PyObject * obj1 = 0 ;
20537 char *kwnames[] = {
20538 (char *) "self",(char *) "check", NULL
20539 };
20540
20541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20543 if (SWIG_arg_fail(1)) SWIG_fail;
20544 {
20545 arg2 = (bool)(SWIG_As_bool(obj1));
20546 if (SWIG_arg_fail(2)) SWIG_fail;
20547 }
20548 {
20549 PyThreadState* __tstate = wxPyBeginAllowThreads();
20550 (arg1)->Check(arg2);
20551
20552 wxPyEndAllowThreads(__tstate);
20553 if (PyErr_Occurred()) SWIG_fail;
20554 }
20555 Py_INCREF(Py_None); resultobj = Py_None;
20556 return resultobj;
20557 fail:
20558 return NULL;
20559 }
20560
20561
20562 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20563 PyObject *resultobj;
20564 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20565 bool arg2 ;
20566 PyObject * obj0 = 0 ;
20567 PyObject * obj1 = 0 ;
20568 char *kwnames[] = {
20569 (char *) "self",(char *) "enable", NULL
20570 };
20571
20572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20574 if (SWIG_arg_fail(1)) SWIG_fail;
20575 {
20576 arg2 = (bool)(SWIG_As_bool(obj1));
20577 if (SWIG_arg_fail(2)) SWIG_fail;
20578 }
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 (arg1)->Enable(arg2);
20582
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 Py_INCREF(Py_None); resultobj = Py_None;
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20594 PyObject *resultobj;
20595 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20596 wxString *arg2 = 0 ;
20597 bool temp2 = false ;
20598 PyObject * obj0 = 0 ;
20599 PyObject * obj1 = 0 ;
20600 char *kwnames[] = {
20601 (char *) "self",(char *) "text", NULL
20602 };
20603
20604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20606 if (SWIG_arg_fail(1)) SWIG_fail;
20607 {
20608 arg2 = wxString_in_helper(obj1);
20609 if (arg2 == NULL) SWIG_fail;
20610 temp2 = true;
20611 }
20612 {
20613 PyThreadState* __tstate = wxPyBeginAllowThreads();
20614 (arg1)->SetText((wxString const &)*arg2);
20615
20616 wxPyEndAllowThreads(__tstate);
20617 if (PyErr_Occurred()) SWIG_fail;
20618 }
20619 Py_INCREF(Py_None); resultobj = Py_None;
20620 {
20621 if (temp2)
20622 delete arg2;
20623 }
20624 return resultobj;
20625 fail:
20626 {
20627 if (temp2)
20628 delete arg2;
20629 }
20630 return NULL;
20631 }
20632
20633
20634 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20635 PyObject *resultobj;
20636 long arg1 ;
20637 PyObject * obj0 = 0 ;
20638 char *kwnames[] = {
20639 (char *) "updateInterval", NULL
20640 };
20641
20642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20643 {
20644 arg1 = (long)(SWIG_As_long(obj0));
20645 if (SWIG_arg_fail(1)) SWIG_fail;
20646 }
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 wxUpdateUIEvent::SetUpdateInterval(arg1);
20650
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 Py_INCREF(Py_None); resultobj = Py_None;
20655 return resultobj;
20656 fail:
20657 return NULL;
20658 }
20659
20660
20661 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20662 PyObject *resultobj;
20663 long result;
20664 char *kwnames[] = {
20665 NULL
20666 };
20667
20668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20669 {
20670 PyThreadState* __tstate = wxPyBeginAllowThreads();
20671 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20672
20673 wxPyEndAllowThreads(__tstate);
20674 if (PyErr_Occurred()) SWIG_fail;
20675 }
20676 {
20677 resultobj = SWIG_From_long((long)(result));
20678 }
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20686 PyObject *resultobj;
20687 wxWindow *arg1 = (wxWindow *) 0 ;
20688 bool result;
20689 PyObject * obj0 = 0 ;
20690 char *kwnames[] = {
20691 (char *) "win", NULL
20692 };
20693
20694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20696 if (SWIG_arg_fail(1)) SWIG_fail;
20697 {
20698 PyThreadState* __tstate = wxPyBeginAllowThreads();
20699 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20700
20701 wxPyEndAllowThreads(__tstate);
20702 if (PyErr_Occurred()) SWIG_fail;
20703 }
20704 {
20705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20706 }
20707 return resultobj;
20708 fail:
20709 return NULL;
20710 }
20711
20712
20713 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20714 PyObject *resultobj;
20715 char *kwnames[] = {
20716 NULL
20717 };
20718
20719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20720 {
20721 PyThreadState* __tstate = wxPyBeginAllowThreads();
20722 wxUpdateUIEvent::ResetUpdateTime();
20723
20724 wxPyEndAllowThreads(__tstate);
20725 if (PyErr_Occurred()) SWIG_fail;
20726 }
20727 Py_INCREF(Py_None); resultobj = Py_None;
20728 return resultobj;
20729 fail:
20730 return NULL;
20731 }
20732
20733
20734 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj;
20736 wxUpdateUIMode arg1 ;
20737 PyObject * obj0 = 0 ;
20738 char *kwnames[] = {
20739 (char *) "mode", NULL
20740 };
20741
20742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20743 {
20744 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20745 if (SWIG_arg_fail(1)) SWIG_fail;
20746 }
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20750
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 Py_INCREF(Py_None); resultobj = Py_None;
20755 return resultobj;
20756 fail:
20757 return NULL;
20758 }
20759
20760
20761 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20762 PyObject *resultobj;
20763 wxUpdateUIMode result;
20764 char *kwnames[] = {
20765 NULL
20766 };
20767
20768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20769 {
20770 PyThreadState* __tstate = wxPyBeginAllowThreads();
20771 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20772
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 resultobj = SWIG_From_int((result));
20777 return resultobj;
20778 fail:
20779 return NULL;
20780 }
20781
20782
20783 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20784 PyObject *obj;
20785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20786 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20787 Py_INCREF(obj);
20788 return Py_BuildValue((char *)"");
20789 }
20790 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20791 PyObject *resultobj;
20792 wxSysColourChangedEvent *result;
20793 char *kwnames[] = {
20794 NULL
20795 };
20796
20797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20798 {
20799 PyThreadState* __tstate = wxPyBeginAllowThreads();
20800 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20801
20802 wxPyEndAllowThreads(__tstate);
20803 if (PyErr_Occurred()) SWIG_fail;
20804 }
20805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20806 return resultobj;
20807 fail:
20808 return NULL;
20809 }
20810
20811
20812 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20813 PyObject *obj;
20814 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20815 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20816 Py_INCREF(obj);
20817 return Py_BuildValue((char *)"");
20818 }
20819 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20820 PyObject *resultobj;
20821 int arg1 = (int) 0 ;
20822 wxWindow *arg2 = (wxWindow *) NULL ;
20823 wxMouseCaptureChangedEvent *result;
20824 PyObject * obj0 = 0 ;
20825 PyObject * obj1 = 0 ;
20826 char *kwnames[] = {
20827 (char *) "winid",(char *) "gainedCapture", NULL
20828 };
20829
20830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20831 if (obj0) {
20832 {
20833 arg1 = (int)(SWIG_As_int(obj0));
20834 if (SWIG_arg_fail(1)) SWIG_fail;
20835 }
20836 }
20837 if (obj1) {
20838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20839 if (SWIG_arg_fail(2)) SWIG_fail;
20840 }
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20844
20845 wxPyEndAllowThreads(__tstate);
20846 if (PyErr_Occurred()) SWIG_fail;
20847 }
20848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20849 return resultobj;
20850 fail:
20851 return NULL;
20852 }
20853
20854
20855 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20856 PyObject *resultobj;
20857 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20858 wxWindow *result;
20859 PyObject * obj0 = 0 ;
20860 char *kwnames[] = {
20861 (char *) "self", NULL
20862 };
20863
20864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20866 if (SWIG_arg_fail(1)) SWIG_fail;
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20870
20871 wxPyEndAllowThreads(__tstate);
20872 if (PyErr_Occurred()) SWIG_fail;
20873 }
20874 {
20875 resultobj = wxPyMake_wxObject(result, 0);
20876 }
20877 return resultobj;
20878 fail:
20879 return NULL;
20880 }
20881
20882
20883 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20884 PyObject *obj;
20885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20886 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20887 Py_INCREF(obj);
20888 return Py_BuildValue((char *)"");
20889 }
20890 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20891 PyObject *resultobj;
20892 wxDisplayChangedEvent *result;
20893 char *kwnames[] = {
20894 NULL
20895 };
20896
20897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20898 {
20899 PyThreadState* __tstate = wxPyBeginAllowThreads();
20900 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20901
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20906 return resultobj;
20907 fail:
20908 return NULL;
20909 }
20910
20911
20912 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20913 PyObject *obj;
20914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20915 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20916 Py_INCREF(obj);
20917 return Py_BuildValue((char *)"");
20918 }
20919 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20920 PyObject *resultobj;
20921 int arg1 = (int) 0 ;
20922 wxPaletteChangedEvent *result;
20923 PyObject * obj0 = 0 ;
20924 char *kwnames[] = {
20925 (char *) "id", NULL
20926 };
20927
20928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20929 if (obj0) {
20930 {
20931 arg1 = (int)(SWIG_As_int(obj0));
20932 if (SWIG_arg_fail(1)) SWIG_fail;
20933 }
20934 }
20935 {
20936 PyThreadState* __tstate = wxPyBeginAllowThreads();
20937 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20938
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20950 PyObject *resultobj;
20951 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20952 wxWindow *arg2 = (wxWindow *) 0 ;
20953 PyObject * obj0 = 0 ;
20954 PyObject * obj1 = 0 ;
20955 char *kwnames[] = {
20956 (char *) "self",(char *) "win", NULL
20957 };
20958
20959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20961 if (SWIG_arg_fail(1)) SWIG_fail;
20962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20963 if (SWIG_arg_fail(2)) SWIG_fail;
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 (arg1)->SetChangedWindow(arg2);
20967
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 Py_INCREF(Py_None); resultobj = Py_None;
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20979 PyObject *resultobj;
20980 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20981 wxWindow *result;
20982 PyObject * obj0 = 0 ;
20983 char *kwnames[] = {
20984 (char *) "self", NULL
20985 };
20986
20987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20989 if (SWIG_arg_fail(1)) SWIG_fail;
20990 {
20991 PyThreadState* __tstate = wxPyBeginAllowThreads();
20992 result = (wxWindow *)(arg1)->GetChangedWindow();
20993
20994 wxPyEndAllowThreads(__tstate);
20995 if (PyErr_Occurred()) SWIG_fail;
20996 }
20997 {
20998 resultobj = wxPyMake_wxObject(result, 0);
20999 }
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21007 PyObject *obj;
21008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21009 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21010 Py_INCREF(obj);
21011 return Py_BuildValue((char *)"");
21012 }
21013 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21014 PyObject *resultobj;
21015 int arg1 = (int) 0 ;
21016 wxQueryNewPaletteEvent *result;
21017 PyObject * obj0 = 0 ;
21018 char *kwnames[] = {
21019 (char *) "winid", NULL
21020 };
21021
21022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21023 if (obj0) {
21024 {
21025 arg1 = (int)(SWIG_As_int(obj0));
21026 if (SWIG_arg_fail(1)) SWIG_fail;
21027 }
21028 }
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21032
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21044 PyObject *resultobj;
21045 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21046 bool arg2 ;
21047 PyObject * obj0 = 0 ;
21048 PyObject * obj1 = 0 ;
21049 char *kwnames[] = {
21050 (char *) "self",(char *) "realized", NULL
21051 };
21052
21053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21055 if (SWIG_arg_fail(1)) SWIG_fail;
21056 {
21057 arg2 = (bool)(SWIG_As_bool(obj1));
21058 if (SWIG_arg_fail(2)) SWIG_fail;
21059 }
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 (arg1)->SetPaletteRealized(arg2);
21063
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 Py_INCREF(Py_None); resultobj = Py_None;
21068 return resultobj;
21069 fail:
21070 return NULL;
21071 }
21072
21073
21074 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21075 PyObject *resultobj;
21076 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21077 bool result;
21078 PyObject * obj0 = 0 ;
21079 char *kwnames[] = {
21080 (char *) "self", NULL
21081 };
21082
21083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21085 if (SWIG_arg_fail(1)) SWIG_fail;
21086 {
21087 PyThreadState* __tstate = wxPyBeginAllowThreads();
21088 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21089
21090 wxPyEndAllowThreads(__tstate);
21091 if (PyErr_Occurred()) SWIG_fail;
21092 }
21093 {
21094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21095 }
21096 return resultobj;
21097 fail:
21098 return NULL;
21099 }
21100
21101
21102 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21103 PyObject *obj;
21104 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21105 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21106 Py_INCREF(obj);
21107 return Py_BuildValue((char *)"");
21108 }
21109 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21110 PyObject *resultobj;
21111 wxNavigationKeyEvent *result;
21112 char *kwnames[] = {
21113 NULL
21114 };
21115
21116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21117 {
21118 PyThreadState* __tstate = wxPyBeginAllowThreads();
21119 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21120
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21132 PyObject *resultobj;
21133 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21134 bool result;
21135 PyObject * obj0 = 0 ;
21136 char *kwnames[] = {
21137 (char *) "self", NULL
21138 };
21139
21140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21142 if (SWIG_arg_fail(1)) SWIG_fail;
21143 {
21144 PyThreadState* __tstate = wxPyBeginAllowThreads();
21145 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21146
21147 wxPyEndAllowThreads(__tstate);
21148 if (PyErr_Occurred()) SWIG_fail;
21149 }
21150 {
21151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21152 }
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21160 PyObject *resultobj;
21161 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21162 bool arg2 ;
21163 PyObject * obj0 = 0 ;
21164 PyObject * obj1 = 0 ;
21165 char *kwnames[] = {
21166 (char *) "self",(char *) "forward", NULL
21167 };
21168
21169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21171 if (SWIG_arg_fail(1)) SWIG_fail;
21172 {
21173 arg2 = (bool)(SWIG_As_bool(obj1));
21174 if (SWIG_arg_fail(2)) SWIG_fail;
21175 }
21176 {
21177 PyThreadState* __tstate = wxPyBeginAllowThreads();
21178 (arg1)->SetDirection(arg2);
21179
21180 wxPyEndAllowThreads(__tstate);
21181 if (PyErr_Occurred()) SWIG_fail;
21182 }
21183 Py_INCREF(Py_None); resultobj = Py_None;
21184 return resultobj;
21185 fail:
21186 return NULL;
21187 }
21188
21189
21190 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21191 PyObject *resultobj;
21192 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21193 bool result;
21194 PyObject * obj0 = 0 ;
21195 char *kwnames[] = {
21196 (char *) "self", NULL
21197 };
21198
21199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21201 if (SWIG_arg_fail(1)) SWIG_fail;
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21205
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 {
21210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21211 }
21212 return resultobj;
21213 fail:
21214 return NULL;
21215 }
21216
21217
21218 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21219 PyObject *resultobj;
21220 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21221 bool arg2 ;
21222 PyObject * obj0 = 0 ;
21223 PyObject * obj1 = 0 ;
21224 char *kwnames[] = {
21225 (char *) "self",(char *) "ischange", NULL
21226 };
21227
21228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21230 if (SWIG_arg_fail(1)) SWIG_fail;
21231 {
21232 arg2 = (bool)(SWIG_As_bool(obj1));
21233 if (SWIG_arg_fail(2)) SWIG_fail;
21234 }
21235 {
21236 PyThreadState* __tstate = wxPyBeginAllowThreads();
21237 (arg1)->SetWindowChange(arg2);
21238
21239 wxPyEndAllowThreads(__tstate);
21240 if (PyErr_Occurred()) SWIG_fail;
21241 }
21242 Py_INCREF(Py_None); resultobj = Py_None;
21243 return resultobj;
21244 fail:
21245 return NULL;
21246 }
21247
21248
21249 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21250 PyObject *resultobj;
21251 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21252 bool result;
21253 PyObject * obj0 = 0 ;
21254 char *kwnames[] = {
21255 (char *) "self", NULL
21256 };
21257
21258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21260 if (SWIG_arg_fail(1)) SWIG_fail;
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21264
21265 wxPyEndAllowThreads(__tstate);
21266 if (PyErr_Occurred()) SWIG_fail;
21267 }
21268 {
21269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21270 }
21271 return resultobj;
21272 fail:
21273 return NULL;
21274 }
21275
21276
21277 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21278 PyObject *resultobj;
21279 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21280 bool arg2 ;
21281 PyObject * obj0 = 0 ;
21282 PyObject * obj1 = 0 ;
21283 char *kwnames[] = {
21284 (char *) "self",(char *) "bIs", NULL
21285 };
21286
21287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21289 if (SWIG_arg_fail(1)) SWIG_fail;
21290 {
21291 arg2 = (bool)(SWIG_As_bool(obj1));
21292 if (SWIG_arg_fail(2)) SWIG_fail;
21293 }
21294 {
21295 PyThreadState* __tstate = wxPyBeginAllowThreads();
21296 (arg1)->SetFromTab(arg2);
21297
21298 wxPyEndAllowThreads(__tstate);
21299 if (PyErr_Occurred()) SWIG_fail;
21300 }
21301 Py_INCREF(Py_None); resultobj = Py_None;
21302 return resultobj;
21303 fail:
21304 return NULL;
21305 }
21306
21307
21308 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21309 PyObject *resultobj;
21310 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21311 long arg2 ;
21312 PyObject * obj0 = 0 ;
21313 PyObject * obj1 = 0 ;
21314 char *kwnames[] = {
21315 (char *) "self",(char *) "flags", NULL
21316 };
21317
21318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21320 if (SWIG_arg_fail(1)) SWIG_fail;
21321 {
21322 arg2 = (long)(SWIG_As_long(obj1));
21323 if (SWIG_arg_fail(2)) SWIG_fail;
21324 }
21325 {
21326 PyThreadState* __tstate = wxPyBeginAllowThreads();
21327 (arg1)->SetFlags(arg2);
21328
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 Py_INCREF(Py_None); resultobj = Py_None;
21333 return resultobj;
21334 fail:
21335 return NULL;
21336 }
21337
21338
21339 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj;
21341 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21342 wxWindow *result;
21343 PyObject * obj0 = 0 ;
21344 char *kwnames[] = {
21345 (char *) "self", NULL
21346 };
21347
21348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21350 if (SWIG_arg_fail(1)) SWIG_fail;
21351 {
21352 PyThreadState* __tstate = wxPyBeginAllowThreads();
21353 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21354
21355 wxPyEndAllowThreads(__tstate);
21356 if (PyErr_Occurred()) SWIG_fail;
21357 }
21358 {
21359 resultobj = wxPyMake_wxObject(result, 0);
21360 }
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj;
21369 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21370 wxWindow *arg2 = (wxWindow *) 0 ;
21371 PyObject * obj0 = 0 ;
21372 PyObject * obj1 = 0 ;
21373 char *kwnames[] = {
21374 (char *) "self",(char *) "win", NULL
21375 };
21376
21377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21379 if (SWIG_arg_fail(1)) SWIG_fail;
21380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21381 if (SWIG_arg_fail(2)) SWIG_fail;
21382 {
21383 PyThreadState* __tstate = wxPyBeginAllowThreads();
21384 (arg1)->SetCurrentFocus(arg2);
21385
21386 wxPyEndAllowThreads(__tstate);
21387 if (PyErr_Occurred()) SWIG_fail;
21388 }
21389 Py_INCREF(Py_None); resultobj = Py_None;
21390 return resultobj;
21391 fail:
21392 return NULL;
21393 }
21394
21395
21396 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21397 PyObject *obj;
21398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21399 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21400 Py_INCREF(obj);
21401 return Py_BuildValue((char *)"");
21402 }
21403 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21404 PyObject *resultobj;
21405 wxWindow *arg1 = (wxWindow *) NULL ;
21406 wxWindowCreateEvent *result;
21407 PyObject * obj0 = 0 ;
21408 char *kwnames[] = {
21409 (char *) "win", NULL
21410 };
21411
21412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21413 if (obj0) {
21414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21415 if (SWIG_arg_fail(1)) SWIG_fail;
21416 }
21417 {
21418 PyThreadState* __tstate = wxPyBeginAllowThreads();
21419 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21420
21421 wxPyEndAllowThreads(__tstate);
21422 if (PyErr_Occurred()) SWIG_fail;
21423 }
21424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21432 PyObject *resultobj;
21433 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21434 wxWindow *result;
21435 PyObject * obj0 = 0 ;
21436 char *kwnames[] = {
21437 (char *) "self", NULL
21438 };
21439
21440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21442 if (SWIG_arg_fail(1)) SWIG_fail;
21443 {
21444 PyThreadState* __tstate = wxPyBeginAllowThreads();
21445 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21446
21447 wxPyEndAllowThreads(__tstate);
21448 if (PyErr_Occurred()) SWIG_fail;
21449 }
21450 {
21451 resultobj = wxPyMake_wxObject(result, 0);
21452 }
21453 return resultobj;
21454 fail:
21455 return NULL;
21456 }
21457
21458
21459 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21460 PyObject *obj;
21461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21462 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21463 Py_INCREF(obj);
21464 return Py_BuildValue((char *)"");
21465 }
21466 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21467 PyObject *resultobj;
21468 wxWindow *arg1 = (wxWindow *) NULL ;
21469 wxWindowDestroyEvent *result;
21470 PyObject * obj0 = 0 ;
21471 char *kwnames[] = {
21472 (char *) "win", NULL
21473 };
21474
21475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21476 if (obj0) {
21477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21478 if (SWIG_arg_fail(1)) SWIG_fail;
21479 }
21480 {
21481 PyThreadState* __tstate = wxPyBeginAllowThreads();
21482 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21483
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21495 PyObject *resultobj;
21496 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21497 wxWindow *result;
21498 PyObject * obj0 = 0 ;
21499 char *kwnames[] = {
21500 (char *) "self", NULL
21501 };
21502
21503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21505 if (SWIG_arg_fail(1)) SWIG_fail;
21506 {
21507 PyThreadState* __tstate = wxPyBeginAllowThreads();
21508 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21509
21510 wxPyEndAllowThreads(__tstate);
21511 if (PyErr_Occurred()) SWIG_fail;
21512 }
21513 {
21514 resultobj = wxPyMake_wxObject(result, 0);
21515 }
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21523 PyObject *obj;
21524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21525 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21526 Py_INCREF(obj);
21527 return Py_BuildValue((char *)"");
21528 }
21529 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21530 PyObject *resultobj;
21531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21532 int arg2 = (int) 0 ;
21533 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21534 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21535 wxContextMenuEvent *result;
21536 wxPoint temp3 ;
21537 PyObject * obj0 = 0 ;
21538 PyObject * obj1 = 0 ;
21539 PyObject * obj2 = 0 ;
21540 char *kwnames[] = {
21541 (char *) "type",(char *) "winid",(char *) "pt", NULL
21542 };
21543
21544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21545 if (obj0) {
21546 {
21547 arg1 = (wxEventType)(SWIG_As_int(obj0));
21548 if (SWIG_arg_fail(1)) SWIG_fail;
21549 }
21550 }
21551 if (obj1) {
21552 {
21553 arg2 = (int)(SWIG_As_int(obj1));
21554 if (SWIG_arg_fail(2)) SWIG_fail;
21555 }
21556 }
21557 if (obj2) {
21558 {
21559 arg3 = &temp3;
21560 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21561 }
21562 }
21563 {
21564 PyThreadState* __tstate = wxPyBeginAllowThreads();
21565 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21566
21567 wxPyEndAllowThreads(__tstate);
21568 if (PyErr_Occurred()) SWIG_fail;
21569 }
21570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21578 PyObject *resultobj;
21579 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21580 wxPoint *result;
21581 PyObject * obj0 = 0 ;
21582 char *kwnames[] = {
21583 (char *) "self", NULL
21584 };
21585
21586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21588 if (SWIG_arg_fail(1)) SWIG_fail;
21589 {
21590 PyThreadState* __tstate = wxPyBeginAllowThreads();
21591 {
21592 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21593 result = (wxPoint *) &_result_ref;
21594 }
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21607 PyObject *resultobj;
21608 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21609 wxPoint *arg2 = 0 ;
21610 wxPoint temp2 ;
21611 PyObject * obj0 = 0 ;
21612 PyObject * obj1 = 0 ;
21613 char *kwnames[] = {
21614 (char *) "self",(char *) "pos", NULL
21615 };
21616
21617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21619 if (SWIG_arg_fail(1)) SWIG_fail;
21620 {
21621 arg2 = &temp2;
21622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21623 }
21624 {
21625 PyThreadState* __tstate = wxPyBeginAllowThreads();
21626 (arg1)->SetPosition((wxPoint const &)*arg2);
21627
21628 wxPyEndAllowThreads(__tstate);
21629 if (PyErr_Occurred()) SWIG_fail;
21630 }
21631 Py_INCREF(Py_None); resultobj = Py_None;
21632 return resultobj;
21633 fail:
21634 return NULL;
21635 }
21636
21637
21638 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21639 PyObject *obj;
21640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21641 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21642 Py_INCREF(obj);
21643 return Py_BuildValue((char *)"");
21644 }
21645 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21646 PyObject *resultobj;
21647 wxIdleEvent *result;
21648 char *kwnames[] = {
21649 NULL
21650 };
21651
21652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21653 {
21654 PyThreadState* __tstate = wxPyBeginAllowThreads();
21655 result = (wxIdleEvent *)new wxIdleEvent();
21656
21657 wxPyEndAllowThreads(__tstate);
21658 if (PyErr_Occurred()) SWIG_fail;
21659 }
21660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj;
21669 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21670 bool arg2 = (bool) true ;
21671 PyObject * obj0 = 0 ;
21672 PyObject * obj1 = 0 ;
21673 char *kwnames[] = {
21674 (char *) "self",(char *) "needMore", NULL
21675 };
21676
21677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21679 if (SWIG_arg_fail(1)) SWIG_fail;
21680 if (obj1) {
21681 {
21682 arg2 = (bool)(SWIG_As_bool(obj1));
21683 if (SWIG_arg_fail(2)) SWIG_fail;
21684 }
21685 }
21686 {
21687 PyThreadState* __tstate = wxPyBeginAllowThreads();
21688 (arg1)->RequestMore(arg2);
21689
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 Py_INCREF(Py_None); resultobj = Py_None;
21694 return resultobj;
21695 fail:
21696 return NULL;
21697 }
21698
21699
21700 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21701 PyObject *resultobj;
21702 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21703 bool result;
21704 PyObject * obj0 = 0 ;
21705 char *kwnames[] = {
21706 (char *) "self", NULL
21707 };
21708
21709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21711 if (SWIG_arg_fail(1)) SWIG_fail;
21712 {
21713 PyThreadState* __tstate = wxPyBeginAllowThreads();
21714 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21715
21716 wxPyEndAllowThreads(__tstate);
21717 if (PyErr_Occurred()) SWIG_fail;
21718 }
21719 {
21720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21721 }
21722 return resultobj;
21723 fail:
21724 return NULL;
21725 }
21726
21727
21728 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21729 PyObject *resultobj;
21730 wxIdleMode arg1 ;
21731 PyObject * obj0 = 0 ;
21732 char *kwnames[] = {
21733 (char *) "mode", NULL
21734 };
21735
21736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21737 {
21738 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21739 if (SWIG_arg_fail(1)) SWIG_fail;
21740 }
21741 {
21742 PyThreadState* __tstate = wxPyBeginAllowThreads();
21743 wxIdleEvent::SetMode((wxIdleMode )arg1);
21744
21745 wxPyEndAllowThreads(__tstate);
21746 if (PyErr_Occurred()) SWIG_fail;
21747 }
21748 Py_INCREF(Py_None); resultobj = Py_None;
21749 return resultobj;
21750 fail:
21751 return NULL;
21752 }
21753
21754
21755 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21756 PyObject *resultobj;
21757 wxIdleMode result;
21758 char *kwnames[] = {
21759 NULL
21760 };
21761
21762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21763 {
21764 PyThreadState* __tstate = wxPyBeginAllowThreads();
21765 result = (wxIdleMode)wxIdleEvent::GetMode();
21766
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_From_int((result));
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21778 PyObject *resultobj;
21779 wxWindow *arg1 = (wxWindow *) 0 ;
21780 bool result;
21781 PyObject * obj0 = 0 ;
21782 char *kwnames[] = {
21783 (char *) "win", NULL
21784 };
21785
21786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21788 if (SWIG_arg_fail(1)) SWIG_fail;
21789 {
21790 PyThreadState* __tstate = wxPyBeginAllowThreads();
21791 result = (bool)wxIdleEvent::CanSend(arg1);
21792
21793 wxPyEndAllowThreads(__tstate);
21794 if (PyErr_Occurred()) SWIG_fail;
21795 }
21796 {
21797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21798 }
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21806 PyObject *obj;
21807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21808 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21809 Py_INCREF(obj);
21810 return Py_BuildValue((char *)"");
21811 }
21812 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21813 PyObject *resultobj;
21814 int arg1 = (int) 0 ;
21815 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21816 wxPyEvent *result;
21817 PyObject * obj0 = 0 ;
21818 PyObject * obj1 = 0 ;
21819 char *kwnames[] = {
21820 (char *) "winid",(char *) "commandType", NULL
21821 };
21822
21823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21824 if (obj0) {
21825 {
21826 arg1 = (int)(SWIG_As_int(obj0));
21827 if (SWIG_arg_fail(1)) SWIG_fail;
21828 }
21829 }
21830 if (obj1) {
21831 {
21832 arg2 = (wxEventType)(SWIG_As_int(obj1));
21833 if (SWIG_arg_fail(2)) SWIG_fail;
21834 }
21835 }
21836 {
21837 PyThreadState* __tstate = wxPyBeginAllowThreads();
21838 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21839
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21851 PyObject *resultobj;
21852 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21853 PyObject * obj0 = 0 ;
21854 char *kwnames[] = {
21855 (char *) "self", NULL
21856 };
21857
21858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21860 if (SWIG_arg_fail(1)) SWIG_fail;
21861 {
21862 PyThreadState* __tstate = wxPyBeginAllowThreads();
21863 delete arg1;
21864
21865 wxPyEndAllowThreads(__tstate);
21866 if (PyErr_Occurred()) SWIG_fail;
21867 }
21868 Py_INCREF(Py_None); resultobj = Py_None;
21869 return resultobj;
21870 fail:
21871 return NULL;
21872 }
21873
21874
21875 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21876 PyObject *resultobj;
21877 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21878 PyObject *arg2 = (PyObject *) 0 ;
21879 PyObject * obj0 = 0 ;
21880 PyObject * obj1 = 0 ;
21881 char *kwnames[] = {
21882 (char *) "self",(char *) "self", NULL
21883 };
21884
21885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21887 if (SWIG_arg_fail(1)) SWIG_fail;
21888 arg2 = obj1;
21889 {
21890 PyThreadState* __tstate = wxPyBeginAllowThreads();
21891 (arg1)->SetSelf(arg2);
21892
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 Py_INCREF(Py_None); resultobj = Py_None;
21897 return resultobj;
21898 fail:
21899 return NULL;
21900 }
21901
21902
21903 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21904 PyObject *resultobj;
21905 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21906 PyObject *result;
21907 PyObject * obj0 = 0 ;
21908 char *kwnames[] = {
21909 (char *) "self", NULL
21910 };
21911
21912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21914 if (SWIG_arg_fail(1)) SWIG_fail;
21915 {
21916 PyThreadState* __tstate = wxPyBeginAllowThreads();
21917 result = (PyObject *)(arg1)->GetSelf();
21918
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 resultobj = result;
21923 return resultobj;
21924 fail:
21925 return NULL;
21926 }
21927
21928
21929 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21930 PyObject *obj;
21931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21932 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21933 Py_INCREF(obj);
21934 return Py_BuildValue((char *)"");
21935 }
21936 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21937 PyObject *resultobj;
21938 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21939 int arg2 = (int) 0 ;
21940 wxPyCommandEvent *result;
21941 PyObject * obj0 = 0 ;
21942 PyObject * obj1 = 0 ;
21943 char *kwnames[] = {
21944 (char *) "commandType",(char *) "id", NULL
21945 };
21946
21947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21948 if (obj0) {
21949 {
21950 arg1 = (wxEventType)(SWIG_As_int(obj0));
21951 if (SWIG_arg_fail(1)) SWIG_fail;
21952 }
21953 }
21954 if (obj1) {
21955 {
21956 arg2 = (int)(SWIG_As_int(obj1));
21957 if (SWIG_arg_fail(2)) SWIG_fail;
21958 }
21959 }
21960 {
21961 PyThreadState* __tstate = wxPyBeginAllowThreads();
21962 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21963
21964 wxPyEndAllowThreads(__tstate);
21965 if (PyErr_Occurred()) SWIG_fail;
21966 }
21967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21968 return resultobj;
21969 fail:
21970 return NULL;
21971 }
21972
21973
21974 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21975 PyObject *resultobj;
21976 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21977 PyObject * obj0 = 0 ;
21978 char *kwnames[] = {
21979 (char *) "self", NULL
21980 };
21981
21982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21984 if (SWIG_arg_fail(1)) SWIG_fail;
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 delete arg1;
21988
21989 wxPyEndAllowThreads(__tstate);
21990 if (PyErr_Occurred()) SWIG_fail;
21991 }
21992 Py_INCREF(Py_None); resultobj = Py_None;
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22000 PyObject *resultobj;
22001 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22002 PyObject *arg2 = (PyObject *) 0 ;
22003 PyObject * obj0 = 0 ;
22004 PyObject * obj1 = 0 ;
22005 char *kwnames[] = {
22006 (char *) "self",(char *) "self", NULL
22007 };
22008
22009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22011 if (SWIG_arg_fail(1)) SWIG_fail;
22012 arg2 = obj1;
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 (arg1)->SetSelf(arg2);
22016
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 Py_INCREF(Py_None); resultobj = Py_None;
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22028 PyObject *resultobj;
22029 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22030 PyObject *result;
22031 PyObject * obj0 = 0 ;
22032 char *kwnames[] = {
22033 (char *) "self", NULL
22034 };
22035
22036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22038 if (SWIG_arg_fail(1)) SWIG_fail;
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 result = (PyObject *)(arg1)->GetSelf();
22042
22043 wxPyEndAllowThreads(__tstate);
22044 if (PyErr_Occurred()) SWIG_fail;
22045 }
22046 resultobj = result;
22047 return resultobj;
22048 fail:
22049 return NULL;
22050 }
22051
22052
22053 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22054 PyObject *obj;
22055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22056 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22057 Py_INCREF(obj);
22058 return Py_BuildValue((char *)"");
22059 }
22060 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22061 PyObject *resultobj;
22062 wxWindow *arg1 = (wxWindow *) 0 ;
22063 wxDateTime *arg2 = 0 ;
22064 wxEventType arg3 ;
22065 wxDateEvent *result;
22066 PyObject * obj0 = 0 ;
22067 PyObject * obj1 = 0 ;
22068 PyObject * obj2 = 0 ;
22069 char *kwnames[] = {
22070 (char *) "win",(char *) "dt",(char *) "type", NULL
22071 };
22072
22073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22075 if (SWIG_arg_fail(1)) SWIG_fail;
22076 {
22077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(2)) SWIG_fail;
22079 if (arg2 == NULL) {
22080 SWIG_null_ref("wxDateTime");
22081 }
22082 if (SWIG_arg_fail(2)) SWIG_fail;
22083 }
22084 {
22085 arg3 = (wxEventType)(SWIG_As_int(obj2));
22086 if (SWIG_arg_fail(3)) SWIG_fail;
22087 }
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22091
22092 wxPyEndAllowThreads(__tstate);
22093 if (PyErr_Occurred()) SWIG_fail;
22094 }
22095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22103 PyObject *resultobj;
22104 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22105 wxDateTime *result;
22106 PyObject * obj0 = 0 ;
22107 char *kwnames[] = {
22108 (char *) "self", NULL
22109 };
22110
22111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22113 if (SWIG_arg_fail(1)) SWIG_fail;
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 {
22117 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22118 result = (wxDateTime *) &_result_ref;
22119 }
22120
22121 wxPyEndAllowThreads(__tstate);
22122 if (PyErr_Occurred()) SWIG_fail;
22123 }
22124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22125 return resultobj;
22126 fail:
22127 return NULL;
22128 }
22129
22130
22131 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22132 PyObject *resultobj;
22133 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22134 wxDateTime *arg2 = 0 ;
22135 PyObject * obj0 = 0 ;
22136 PyObject * obj1 = 0 ;
22137 char *kwnames[] = {
22138 (char *) "self",(char *) "date", NULL
22139 };
22140
22141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22143 if (SWIG_arg_fail(1)) SWIG_fail;
22144 {
22145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22146 if (SWIG_arg_fail(2)) SWIG_fail;
22147 if (arg2 == NULL) {
22148 SWIG_null_ref("wxDateTime");
22149 }
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 }
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 (arg1)->SetDate((wxDateTime const &)*arg2);
22155
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 Py_INCREF(Py_None); resultobj = Py_None;
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22167 PyObject *obj;
22168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22169 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22170 Py_INCREF(obj);
22171 return Py_BuildValue((char *)"");
22172 }
22173 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22174 PyObject *resultobj;
22175 wxPyApp *result;
22176 char *kwnames[] = {
22177 NULL
22178 };
22179
22180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22181 {
22182 PyThreadState* __tstate = wxPyBeginAllowThreads();
22183 result = (wxPyApp *)new_wxPyApp();
22184
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj;
22197 wxPyApp *arg1 = (wxPyApp *) 0 ;
22198 PyObject * obj0 = 0 ;
22199 char *kwnames[] = {
22200 (char *) "self", NULL
22201 };
22202
22203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22205 if (SWIG_arg_fail(1)) SWIG_fail;
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 delete arg1;
22209
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 Py_INCREF(Py_None); resultobj = Py_None;
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22221 PyObject *resultobj;
22222 wxPyApp *arg1 = (wxPyApp *) 0 ;
22223 PyObject *arg2 = (PyObject *) 0 ;
22224 PyObject *arg3 = (PyObject *) 0 ;
22225 PyObject * obj0 = 0 ;
22226 PyObject * obj1 = 0 ;
22227 PyObject * obj2 = 0 ;
22228 char *kwnames[] = {
22229 (char *) "self",(char *) "self",(char *) "_class", NULL
22230 };
22231
22232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22234 if (SWIG_arg_fail(1)) SWIG_fail;
22235 arg2 = obj1;
22236 arg3 = obj2;
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 (arg1)->_setCallbackInfo(arg2,arg3);
22240
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 Py_INCREF(Py_None); resultobj = Py_None;
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj;
22253 wxPyApp *arg1 = (wxPyApp *) 0 ;
22254 wxString result;
22255 PyObject * obj0 = 0 ;
22256 char *kwnames[] = {
22257 (char *) "self", NULL
22258 };
22259
22260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22262 if (SWIG_arg_fail(1)) SWIG_fail;
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 result = ((wxPyApp const *)arg1)->GetAppName();
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 {
22271 #if wxUSE_UNICODE
22272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22273 #else
22274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22275 #endif
22276 }
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22284 PyObject *resultobj;
22285 wxPyApp *arg1 = (wxPyApp *) 0 ;
22286 wxString *arg2 = 0 ;
22287 bool temp2 = false ;
22288 PyObject * obj0 = 0 ;
22289 PyObject * obj1 = 0 ;
22290 char *kwnames[] = {
22291 (char *) "self",(char *) "name", NULL
22292 };
22293
22294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22296 if (SWIG_arg_fail(1)) SWIG_fail;
22297 {
22298 arg2 = wxString_in_helper(obj1);
22299 if (arg2 == NULL) SWIG_fail;
22300 temp2 = true;
22301 }
22302 {
22303 PyThreadState* __tstate = wxPyBeginAllowThreads();
22304 (arg1)->SetAppName((wxString const &)*arg2);
22305
22306 wxPyEndAllowThreads(__tstate);
22307 if (PyErr_Occurred()) SWIG_fail;
22308 }
22309 Py_INCREF(Py_None); resultobj = Py_None;
22310 {
22311 if (temp2)
22312 delete arg2;
22313 }
22314 return resultobj;
22315 fail:
22316 {
22317 if (temp2)
22318 delete arg2;
22319 }
22320 return NULL;
22321 }
22322
22323
22324 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22325 PyObject *resultobj;
22326 wxPyApp *arg1 = (wxPyApp *) 0 ;
22327 wxString result;
22328 PyObject * obj0 = 0 ;
22329 char *kwnames[] = {
22330 (char *) "self", NULL
22331 };
22332
22333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22335 if (SWIG_arg_fail(1)) SWIG_fail;
22336 {
22337 PyThreadState* __tstate = wxPyBeginAllowThreads();
22338 result = ((wxPyApp const *)arg1)->GetClassName();
22339
22340 wxPyEndAllowThreads(__tstate);
22341 if (PyErr_Occurred()) SWIG_fail;
22342 }
22343 {
22344 #if wxUSE_UNICODE
22345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22346 #else
22347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22348 #endif
22349 }
22350 return resultobj;
22351 fail:
22352 return NULL;
22353 }
22354
22355
22356 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22357 PyObject *resultobj;
22358 wxPyApp *arg1 = (wxPyApp *) 0 ;
22359 wxString *arg2 = 0 ;
22360 bool temp2 = false ;
22361 PyObject * obj0 = 0 ;
22362 PyObject * obj1 = 0 ;
22363 char *kwnames[] = {
22364 (char *) "self",(char *) "name", NULL
22365 };
22366
22367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22369 if (SWIG_arg_fail(1)) SWIG_fail;
22370 {
22371 arg2 = wxString_in_helper(obj1);
22372 if (arg2 == NULL) SWIG_fail;
22373 temp2 = true;
22374 }
22375 {
22376 PyThreadState* __tstate = wxPyBeginAllowThreads();
22377 (arg1)->SetClassName((wxString const &)*arg2);
22378
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 Py_INCREF(Py_None); resultobj = Py_None;
22383 {
22384 if (temp2)
22385 delete arg2;
22386 }
22387 return resultobj;
22388 fail:
22389 {
22390 if (temp2)
22391 delete arg2;
22392 }
22393 return NULL;
22394 }
22395
22396
22397 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22398 PyObject *resultobj;
22399 wxPyApp *arg1 = (wxPyApp *) 0 ;
22400 wxString *result;
22401 PyObject * obj0 = 0 ;
22402 char *kwnames[] = {
22403 (char *) "self", NULL
22404 };
22405
22406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22408 if (SWIG_arg_fail(1)) SWIG_fail;
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 {
22412 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22413 result = (wxString *) &_result_ref;
22414 }
22415
22416 wxPyEndAllowThreads(__tstate);
22417 if (PyErr_Occurred()) SWIG_fail;
22418 }
22419 {
22420 #if wxUSE_UNICODE
22421 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22422 #else
22423 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22424 #endif
22425 }
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22433 PyObject *resultobj;
22434 wxPyApp *arg1 = (wxPyApp *) 0 ;
22435 wxString *arg2 = 0 ;
22436 bool temp2 = false ;
22437 PyObject * obj0 = 0 ;
22438 PyObject * obj1 = 0 ;
22439 char *kwnames[] = {
22440 (char *) "self",(char *) "name", NULL
22441 };
22442
22443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22445 if (SWIG_arg_fail(1)) SWIG_fail;
22446 {
22447 arg2 = wxString_in_helper(obj1);
22448 if (arg2 == NULL) SWIG_fail;
22449 temp2 = true;
22450 }
22451 {
22452 PyThreadState* __tstate = wxPyBeginAllowThreads();
22453 (arg1)->SetVendorName((wxString const &)*arg2);
22454
22455 wxPyEndAllowThreads(__tstate);
22456 if (PyErr_Occurred()) SWIG_fail;
22457 }
22458 Py_INCREF(Py_None); resultobj = Py_None;
22459 {
22460 if (temp2)
22461 delete arg2;
22462 }
22463 return resultobj;
22464 fail:
22465 {
22466 if (temp2)
22467 delete arg2;
22468 }
22469 return NULL;
22470 }
22471
22472
22473 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22474 PyObject *resultobj;
22475 wxPyApp *arg1 = (wxPyApp *) 0 ;
22476 wxAppTraits *result;
22477 PyObject * obj0 = 0 ;
22478 char *kwnames[] = {
22479 (char *) "self", NULL
22480 };
22481
22482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22484 if (SWIG_arg_fail(1)) SWIG_fail;
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 result = (wxAppTraits *)(arg1)->GetTraits();
22488
22489 wxPyEndAllowThreads(__tstate);
22490 if (PyErr_Occurred()) SWIG_fail;
22491 }
22492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22493 return resultobj;
22494 fail:
22495 return NULL;
22496 }
22497
22498
22499 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22500 PyObject *resultobj;
22501 wxPyApp *arg1 = (wxPyApp *) 0 ;
22502 PyObject * obj0 = 0 ;
22503 char *kwnames[] = {
22504 (char *) "self", NULL
22505 };
22506
22507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22509 if (SWIG_arg_fail(1)) SWIG_fail;
22510 {
22511 PyThreadState* __tstate = wxPyBeginAllowThreads();
22512 (arg1)->ProcessPendingEvents();
22513
22514 wxPyEndAllowThreads(__tstate);
22515 if (PyErr_Occurred()) SWIG_fail;
22516 }
22517 Py_INCREF(Py_None); resultobj = Py_None;
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22525 PyObject *resultobj;
22526 wxPyApp *arg1 = (wxPyApp *) 0 ;
22527 bool arg2 = (bool) false ;
22528 bool result;
22529 PyObject * obj0 = 0 ;
22530 PyObject * obj1 = 0 ;
22531 char *kwnames[] = {
22532 (char *) "self",(char *) "onlyIfNeeded", NULL
22533 };
22534
22535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22537 if (SWIG_arg_fail(1)) SWIG_fail;
22538 if (obj1) {
22539 {
22540 arg2 = (bool)(SWIG_As_bool(obj1));
22541 if (SWIG_arg_fail(2)) SWIG_fail;
22542 }
22543 }
22544 {
22545 PyThreadState* __tstate = wxPyBeginAllowThreads();
22546 result = (bool)(arg1)->Yield(arg2);
22547
22548 wxPyEndAllowThreads(__tstate);
22549 if (PyErr_Occurred()) SWIG_fail;
22550 }
22551 {
22552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22553 }
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj;
22562 wxPyApp *arg1 = (wxPyApp *) 0 ;
22563 PyObject * obj0 = 0 ;
22564 char *kwnames[] = {
22565 (char *) "self", NULL
22566 };
22567
22568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22570 if (SWIG_arg_fail(1)) SWIG_fail;
22571 {
22572 PyThreadState* __tstate = wxPyBeginAllowThreads();
22573 (arg1)->WakeUpIdle();
22574
22575 wxPyEndAllowThreads(__tstate);
22576 if (PyErr_Occurred()) SWIG_fail;
22577 }
22578 Py_INCREF(Py_None); resultobj = Py_None;
22579 return resultobj;
22580 fail:
22581 return NULL;
22582 }
22583
22584
22585 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22586 PyObject *resultobj;
22587 bool result;
22588 char *kwnames[] = {
22589 NULL
22590 };
22591
22592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22593 {
22594 PyThreadState* __tstate = wxPyBeginAllowThreads();
22595 result = (bool)wxPyApp::IsMainLoopRunning();
22596
22597 wxPyEndAllowThreads(__tstate);
22598 if (PyErr_Occurred()) SWIG_fail;
22599 }
22600 {
22601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22602 }
22603 return resultobj;
22604 fail:
22605 return NULL;
22606 }
22607
22608
22609 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22610 PyObject *resultobj;
22611 wxPyApp *arg1 = (wxPyApp *) 0 ;
22612 int result;
22613 PyObject * obj0 = 0 ;
22614 char *kwnames[] = {
22615 (char *) "self", NULL
22616 };
22617
22618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22620 if (SWIG_arg_fail(1)) SWIG_fail;
22621 {
22622 PyThreadState* __tstate = wxPyBeginAllowThreads();
22623 result = (int)(arg1)->MainLoop();
22624
22625 wxPyEndAllowThreads(__tstate);
22626 if (PyErr_Occurred()) SWIG_fail;
22627 }
22628 {
22629 resultobj = SWIG_From_int((int)(result));
22630 }
22631 return resultobj;
22632 fail:
22633 return NULL;
22634 }
22635
22636
22637 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22638 PyObject *resultobj;
22639 wxPyApp *arg1 = (wxPyApp *) 0 ;
22640 PyObject * obj0 = 0 ;
22641 char *kwnames[] = {
22642 (char *) "self", NULL
22643 };
22644
22645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22647 if (SWIG_arg_fail(1)) SWIG_fail;
22648 {
22649 PyThreadState* __tstate = wxPyBeginAllowThreads();
22650 (arg1)->Exit();
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 Py_INCREF(Py_None); resultobj = Py_None;
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22663 PyObject *resultobj;
22664 wxPyApp *arg1 = (wxPyApp *) 0 ;
22665 PyObject * obj0 = 0 ;
22666 char *kwnames[] = {
22667 (char *) "self", NULL
22668 };
22669
22670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22672 if (SWIG_arg_fail(1)) SWIG_fail;
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 (arg1)->ExitMainLoop();
22676
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 Py_INCREF(Py_None); resultobj = Py_None;
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22688 PyObject *resultobj;
22689 wxPyApp *arg1 = (wxPyApp *) 0 ;
22690 bool result;
22691 PyObject * obj0 = 0 ;
22692 char *kwnames[] = {
22693 (char *) "self", NULL
22694 };
22695
22696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22698 if (SWIG_arg_fail(1)) SWIG_fail;
22699 {
22700 PyThreadState* __tstate = wxPyBeginAllowThreads();
22701 result = (bool)(arg1)->Pending();
22702
22703 wxPyEndAllowThreads(__tstate);
22704 if (PyErr_Occurred()) SWIG_fail;
22705 }
22706 {
22707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22708 }
22709 return resultobj;
22710 fail:
22711 return NULL;
22712 }
22713
22714
22715 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22716 PyObject *resultobj;
22717 wxPyApp *arg1 = (wxPyApp *) 0 ;
22718 bool result;
22719 PyObject * obj0 = 0 ;
22720 char *kwnames[] = {
22721 (char *) "self", NULL
22722 };
22723
22724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22726 if (SWIG_arg_fail(1)) SWIG_fail;
22727 {
22728 PyThreadState* __tstate = wxPyBeginAllowThreads();
22729 result = (bool)(arg1)->Dispatch();
22730
22731 wxPyEndAllowThreads(__tstate);
22732 if (PyErr_Occurred()) SWIG_fail;
22733 }
22734 {
22735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22736 }
22737 return resultobj;
22738 fail:
22739 return NULL;
22740 }
22741
22742
22743 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22744 PyObject *resultobj;
22745 wxPyApp *arg1 = (wxPyApp *) 0 ;
22746 bool result;
22747 PyObject * obj0 = 0 ;
22748 char *kwnames[] = {
22749 (char *) "self", NULL
22750 };
22751
22752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22754 if (SWIG_arg_fail(1)) SWIG_fail;
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 result = (bool)(arg1)->ProcessIdle();
22758
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 {
22763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22764 }
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22772 PyObject *resultobj;
22773 wxPyApp *arg1 = (wxPyApp *) 0 ;
22774 wxWindow *arg2 = (wxWindow *) 0 ;
22775 wxIdleEvent *arg3 = 0 ;
22776 bool result;
22777 PyObject * obj0 = 0 ;
22778 PyObject * obj1 = 0 ;
22779 PyObject * obj2 = 0 ;
22780 char *kwnames[] = {
22781 (char *) "self",(char *) "win",(char *) "event", NULL
22782 };
22783
22784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22786 if (SWIG_arg_fail(1)) SWIG_fail;
22787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22788 if (SWIG_arg_fail(2)) SWIG_fail;
22789 {
22790 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22791 if (SWIG_arg_fail(3)) SWIG_fail;
22792 if (arg3 == NULL) {
22793 SWIG_null_ref("wxIdleEvent");
22794 }
22795 if (SWIG_arg_fail(3)) SWIG_fail;
22796 }
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22800
22801 wxPyEndAllowThreads(__tstate);
22802 if (PyErr_Occurred()) SWIG_fail;
22803 }
22804 {
22805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22806 }
22807 return resultobj;
22808 fail:
22809 return NULL;
22810 }
22811
22812
22813 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22814 PyObject *resultobj;
22815 wxPyApp *arg1 = (wxPyApp *) 0 ;
22816 bool result;
22817 PyObject * obj0 = 0 ;
22818 char *kwnames[] = {
22819 (char *) "self", NULL
22820 };
22821
22822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22824 if (SWIG_arg_fail(1)) SWIG_fail;
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (bool)((wxPyApp const *)arg1)->IsActive();
22828
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 {
22833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22834 }
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22842 PyObject *resultobj;
22843 wxPyApp *arg1 = (wxPyApp *) 0 ;
22844 wxWindow *arg2 = (wxWindow *) 0 ;
22845 PyObject * obj0 = 0 ;
22846 PyObject * obj1 = 0 ;
22847 char *kwnames[] = {
22848 (char *) "self",(char *) "win", NULL
22849 };
22850
22851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22853 if (SWIG_arg_fail(1)) SWIG_fail;
22854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22855 if (SWIG_arg_fail(2)) SWIG_fail;
22856 {
22857 PyThreadState* __tstate = wxPyBeginAllowThreads();
22858 (arg1)->SetTopWindow(arg2);
22859
22860 wxPyEndAllowThreads(__tstate);
22861 if (PyErr_Occurred()) SWIG_fail;
22862 }
22863 Py_INCREF(Py_None); resultobj = Py_None;
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22871 PyObject *resultobj;
22872 wxPyApp *arg1 = (wxPyApp *) 0 ;
22873 wxWindow *result;
22874 PyObject * obj0 = 0 ;
22875 char *kwnames[] = {
22876 (char *) "self", NULL
22877 };
22878
22879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22881 if (SWIG_arg_fail(1)) SWIG_fail;
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22885
22886 wxPyEndAllowThreads(__tstate);
22887 if (PyErr_Occurred()) SWIG_fail;
22888 }
22889 {
22890 resultobj = wxPyMake_wxObject(result, 0);
22891 }
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22899 PyObject *resultobj;
22900 wxPyApp *arg1 = (wxPyApp *) 0 ;
22901 bool arg2 ;
22902 PyObject * obj0 = 0 ;
22903 PyObject * obj1 = 0 ;
22904 char *kwnames[] = {
22905 (char *) "self",(char *) "flag", NULL
22906 };
22907
22908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22910 if (SWIG_arg_fail(1)) SWIG_fail;
22911 {
22912 arg2 = (bool)(SWIG_As_bool(obj1));
22913 if (SWIG_arg_fail(2)) SWIG_fail;
22914 }
22915 {
22916 PyThreadState* __tstate = wxPyBeginAllowThreads();
22917 (arg1)->SetExitOnFrameDelete(arg2);
22918
22919 wxPyEndAllowThreads(__tstate);
22920 if (PyErr_Occurred()) SWIG_fail;
22921 }
22922 Py_INCREF(Py_None); resultobj = Py_None;
22923 return resultobj;
22924 fail:
22925 return NULL;
22926 }
22927
22928
22929 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22930 PyObject *resultobj;
22931 wxPyApp *arg1 = (wxPyApp *) 0 ;
22932 bool result;
22933 PyObject * obj0 = 0 ;
22934 char *kwnames[] = {
22935 (char *) "self", NULL
22936 };
22937
22938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",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 = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22944
22945 wxPyEndAllowThreads(__tstate);
22946 if (PyErr_Occurred()) SWIG_fail;
22947 }
22948 {
22949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22950 }
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22958 PyObject *resultobj;
22959 wxPyApp *arg1 = (wxPyApp *) 0 ;
22960 bool arg2 ;
22961 PyObject * obj0 = 0 ;
22962 PyObject * obj1 = 0 ;
22963 char *kwnames[] = {
22964 (char *) "self",(char *) "flag", NULL
22965 };
22966
22967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22969 if (SWIG_arg_fail(1)) SWIG_fail;
22970 {
22971 arg2 = (bool)(SWIG_As_bool(obj1));
22972 if (SWIG_arg_fail(2)) SWIG_fail;
22973 }
22974 {
22975 PyThreadState* __tstate = wxPyBeginAllowThreads();
22976 (arg1)->SetUseBestVisual(arg2);
22977
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 Py_INCREF(Py_None); resultobj = Py_None;
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22989 PyObject *resultobj;
22990 wxPyApp *arg1 = (wxPyApp *) 0 ;
22991 bool result;
22992 PyObject * obj0 = 0 ;
22993 char *kwnames[] = {
22994 (char *) "self", NULL
22995 };
22996
22997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22999 if (SWIG_arg_fail(1)) SWIG_fail;
23000 {
23001 PyThreadState* __tstate = wxPyBeginAllowThreads();
23002 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
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_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23017 PyObject *resultobj;
23018 wxPyApp *arg1 = (wxPyApp *) 0 ;
23019 int arg2 ;
23020 PyObject * obj0 = 0 ;
23021 PyObject * obj1 = 0 ;
23022 char *kwnames[] = {
23023 (char *) "self",(char *) "mode", NULL
23024 };
23025
23026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23028 if (SWIG_arg_fail(1)) SWIG_fail;
23029 {
23030 arg2 = (int)(SWIG_As_int(obj1));
23031 if (SWIG_arg_fail(2)) SWIG_fail;
23032 }
23033 {
23034 PyThreadState* __tstate = wxPyBeginAllowThreads();
23035 (arg1)->SetPrintMode(arg2);
23036
23037 wxPyEndAllowThreads(__tstate);
23038 if (PyErr_Occurred()) SWIG_fail;
23039 }
23040 Py_INCREF(Py_None); resultobj = Py_None;
23041 return resultobj;
23042 fail:
23043 return NULL;
23044 }
23045
23046
23047 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23048 PyObject *resultobj;
23049 wxPyApp *arg1 = (wxPyApp *) 0 ;
23050 int result;
23051 PyObject * obj0 = 0 ;
23052 char *kwnames[] = {
23053 (char *) "self", NULL
23054 };
23055
23056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23058 if (SWIG_arg_fail(1)) SWIG_fail;
23059 {
23060 PyThreadState* __tstate = wxPyBeginAllowThreads();
23061 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23062
23063 wxPyEndAllowThreads(__tstate);
23064 if (PyErr_Occurred()) SWIG_fail;
23065 }
23066 {
23067 resultobj = SWIG_From_int((int)(result));
23068 }
23069 return resultobj;
23070 fail:
23071 return NULL;
23072 }
23073
23074
23075 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23076 PyObject *resultobj;
23077 wxPyApp *arg1 = (wxPyApp *) 0 ;
23078 int arg2 ;
23079 PyObject * obj0 = 0 ;
23080 PyObject * obj1 = 0 ;
23081 char *kwnames[] = {
23082 (char *) "self",(char *) "mode", NULL
23083 };
23084
23085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23087 if (SWIG_arg_fail(1)) SWIG_fail;
23088 {
23089 arg2 = (int)(SWIG_As_int(obj1));
23090 if (SWIG_arg_fail(2)) SWIG_fail;
23091 }
23092 {
23093 PyThreadState* __tstate = wxPyBeginAllowThreads();
23094 (arg1)->SetAssertMode(arg2);
23095
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 Py_INCREF(Py_None); resultobj = Py_None;
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23107 PyObject *resultobj;
23108 wxPyApp *arg1 = (wxPyApp *) 0 ;
23109 int result;
23110 PyObject * obj0 = 0 ;
23111 char *kwnames[] = {
23112 (char *) "self", NULL
23113 };
23114
23115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23117 if (SWIG_arg_fail(1)) SWIG_fail;
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 result = (int)(arg1)->GetAssertMode();
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 {
23126 resultobj = SWIG_From_int((int)(result));
23127 }
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23135 PyObject *resultobj;
23136 bool result;
23137 char *kwnames[] = {
23138 NULL
23139 };
23140
23141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23142 {
23143 PyThreadState* __tstate = wxPyBeginAllowThreads();
23144 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23145
23146 wxPyEndAllowThreads(__tstate);
23147 if (PyErr_Occurred()) SWIG_fail;
23148 }
23149 {
23150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23151 }
23152 return resultobj;
23153 fail:
23154 return NULL;
23155 }
23156
23157
23158 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23159 PyObject *resultobj;
23160 long result;
23161 char *kwnames[] = {
23162 NULL
23163 };
23164
23165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23166 {
23167 PyThreadState* __tstate = wxPyBeginAllowThreads();
23168 result = (long)wxPyApp::GetMacAboutMenuItemId();
23169
23170 wxPyEndAllowThreads(__tstate);
23171 if (PyErr_Occurred()) SWIG_fail;
23172 }
23173 {
23174 resultobj = SWIG_From_long((long)(result));
23175 }
23176 return resultobj;
23177 fail:
23178 return NULL;
23179 }
23180
23181
23182 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23183 PyObject *resultobj;
23184 long result;
23185 char *kwnames[] = {
23186 NULL
23187 };
23188
23189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23190 {
23191 PyThreadState* __tstate = wxPyBeginAllowThreads();
23192 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23193
23194 wxPyEndAllowThreads(__tstate);
23195 if (PyErr_Occurred()) SWIG_fail;
23196 }
23197 {
23198 resultobj = SWIG_From_long((long)(result));
23199 }
23200 return resultobj;
23201 fail:
23202 return NULL;
23203 }
23204
23205
23206 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23207 PyObject *resultobj;
23208 long result;
23209 char *kwnames[] = {
23210 NULL
23211 };
23212
23213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23214 {
23215 PyThreadState* __tstate = wxPyBeginAllowThreads();
23216 result = (long)wxPyApp::GetMacExitMenuItemId();
23217
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 {
23222 resultobj = SWIG_From_long((long)(result));
23223 }
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23231 PyObject *resultobj;
23232 wxString result;
23233 char *kwnames[] = {
23234 NULL
23235 };
23236
23237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23238 {
23239 PyThreadState* __tstate = wxPyBeginAllowThreads();
23240 result = wxPyApp::GetMacHelpMenuTitleName();
23241
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 {
23246 #if wxUSE_UNICODE
23247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23248 #else
23249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23250 #endif
23251 }
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj;
23260 bool arg1 ;
23261 PyObject * obj0 = 0 ;
23262 char *kwnames[] = {
23263 (char *) "val", NULL
23264 };
23265
23266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23267 {
23268 arg1 = (bool)(SWIG_As_bool(obj0));
23269 if (SWIG_arg_fail(1)) SWIG_fail;
23270 }
23271 {
23272 PyThreadState* __tstate = wxPyBeginAllowThreads();
23273 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23274
23275 wxPyEndAllowThreads(__tstate);
23276 if (PyErr_Occurred()) SWIG_fail;
23277 }
23278 Py_INCREF(Py_None); resultobj = Py_None;
23279 return resultobj;
23280 fail:
23281 return NULL;
23282 }
23283
23284
23285 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23286 PyObject *resultobj;
23287 long arg1 ;
23288 PyObject * obj0 = 0 ;
23289 char *kwnames[] = {
23290 (char *) "val", NULL
23291 };
23292
23293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23294 {
23295 arg1 = (long)(SWIG_As_long(obj0));
23296 if (SWIG_arg_fail(1)) SWIG_fail;
23297 }
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 wxPyApp::SetMacAboutMenuItemId(arg1);
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 Py_INCREF(Py_None); resultobj = Py_None;
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj;
23314 long arg1 ;
23315 PyObject * obj0 = 0 ;
23316 char *kwnames[] = {
23317 (char *) "val", NULL
23318 };
23319
23320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23321 {
23322 arg1 = (long)(SWIG_As_long(obj0));
23323 if (SWIG_arg_fail(1)) SWIG_fail;
23324 }
23325 {
23326 PyThreadState* __tstate = wxPyBeginAllowThreads();
23327 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23328
23329 wxPyEndAllowThreads(__tstate);
23330 if (PyErr_Occurred()) SWIG_fail;
23331 }
23332 Py_INCREF(Py_None); resultobj = Py_None;
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23340 PyObject *resultobj;
23341 long arg1 ;
23342 PyObject * obj0 = 0 ;
23343 char *kwnames[] = {
23344 (char *) "val", NULL
23345 };
23346
23347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23348 {
23349 arg1 = (long)(SWIG_As_long(obj0));
23350 if (SWIG_arg_fail(1)) SWIG_fail;
23351 }
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 wxPyApp::SetMacExitMenuItemId(arg1);
23355
23356 wxPyEndAllowThreads(__tstate);
23357 if (PyErr_Occurred()) SWIG_fail;
23358 }
23359 Py_INCREF(Py_None); resultobj = Py_None;
23360 return resultobj;
23361 fail:
23362 return NULL;
23363 }
23364
23365
23366 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23367 PyObject *resultobj;
23368 wxString *arg1 = 0 ;
23369 bool temp1 = false ;
23370 PyObject * obj0 = 0 ;
23371 char *kwnames[] = {
23372 (char *) "val", NULL
23373 };
23374
23375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23376 {
23377 arg1 = wxString_in_helper(obj0);
23378 if (arg1 == NULL) SWIG_fail;
23379 temp1 = true;
23380 }
23381 {
23382 PyThreadState* __tstate = wxPyBeginAllowThreads();
23383 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23384
23385 wxPyEndAllowThreads(__tstate);
23386 if (PyErr_Occurred()) SWIG_fail;
23387 }
23388 Py_INCREF(Py_None); resultobj = Py_None;
23389 {
23390 if (temp1)
23391 delete arg1;
23392 }
23393 return resultobj;
23394 fail:
23395 {
23396 if (temp1)
23397 delete arg1;
23398 }
23399 return NULL;
23400 }
23401
23402
23403 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23404 PyObject *resultobj;
23405 wxPyApp *arg1 = (wxPyApp *) 0 ;
23406 PyObject * obj0 = 0 ;
23407 char *kwnames[] = {
23408 (char *) "self", NULL
23409 };
23410
23411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23413 if (SWIG_arg_fail(1)) SWIG_fail;
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 (arg1)->_BootstrapApp();
23417
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 Py_INCREF(Py_None); resultobj = Py_None;
23422 return resultobj;
23423 fail:
23424 return NULL;
23425 }
23426
23427
23428 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23429 PyObject *resultobj;
23430 int result;
23431 char *kwnames[] = {
23432 NULL
23433 };
23434
23435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23436 {
23437 PyThreadState* __tstate = wxPyBeginAllowThreads();
23438 result = (int)wxPyApp::GetComCtl32Version();
23439
23440 wxPyEndAllowThreads(__tstate);
23441 if (PyErr_Occurred()) SWIG_fail;
23442 }
23443 {
23444 resultobj = SWIG_From_int((int)(result));
23445 }
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23453 PyObject *obj;
23454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23455 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23456 Py_INCREF(obj);
23457 return Py_BuildValue((char *)"");
23458 }
23459 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23460 PyObject *resultobj;
23461 char *kwnames[] = {
23462 NULL
23463 };
23464
23465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23466 {
23467 PyThreadState* __tstate = wxPyBeginAllowThreads();
23468 wxExit();
23469
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 Py_INCREF(Py_None); resultobj = Py_None;
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj;
23482 bool result;
23483 char *kwnames[] = {
23484 NULL
23485 };
23486
23487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23488 {
23489 PyThreadState* __tstate = wxPyBeginAllowThreads();
23490 result = (bool)wxYield();
23491
23492 wxPyEndAllowThreads(__tstate);
23493 if (PyErr_Occurred()) SWIG_fail;
23494 }
23495 {
23496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23497 }
23498 return resultobj;
23499 fail:
23500 return NULL;
23501 }
23502
23503
23504 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23505 PyObject *resultobj;
23506 bool result;
23507 char *kwnames[] = {
23508 NULL
23509 };
23510
23511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23512 {
23513 PyThreadState* __tstate = wxPyBeginAllowThreads();
23514 result = (bool)wxYieldIfNeeded();
23515
23516 wxPyEndAllowThreads(__tstate);
23517 if (PyErr_Occurred()) SWIG_fail;
23518 }
23519 {
23520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23521 }
23522 return resultobj;
23523 fail:
23524 return NULL;
23525 }
23526
23527
23528 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23529 PyObject *resultobj;
23530 wxWindow *arg1 = (wxWindow *) NULL ;
23531 bool arg2 = (bool) false ;
23532 bool result;
23533 PyObject * obj0 = 0 ;
23534 PyObject * obj1 = 0 ;
23535 char *kwnames[] = {
23536 (char *) "win",(char *) "onlyIfNeeded", NULL
23537 };
23538
23539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23540 if (obj0) {
23541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23542 if (SWIG_arg_fail(1)) SWIG_fail;
23543 }
23544 if (obj1) {
23545 {
23546 arg2 = (bool)(SWIG_As_bool(obj1));
23547 if (SWIG_arg_fail(2)) SWIG_fail;
23548 }
23549 }
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = (bool)wxSafeYield(arg1,arg2);
23553
23554 wxPyEndAllowThreads(__tstate);
23555 if (PyErr_Occurred()) SWIG_fail;
23556 }
23557 {
23558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23559 }
23560 return resultobj;
23561 fail:
23562 return NULL;
23563 }
23564
23565
23566 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23567 PyObject *resultobj;
23568 char *kwnames[] = {
23569 NULL
23570 };
23571
23572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 wxWakeUpIdle();
23576
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 Py_INCREF(Py_None); resultobj = Py_None;
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23588 PyObject *resultobj;
23589 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23590 wxEvent *arg2 = 0 ;
23591 PyObject * obj0 = 0 ;
23592 PyObject * obj1 = 0 ;
23593 char *kwnames[] = {
23594 (char *) "dest",(char *) "event", NULL
23595 };
23596
23597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23599 if (SWIG_arg_fail(1)) SWIG_fail;
23600 {
23601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23602 if (SWIG_arg_fail(2)) SWIG_fail;
23603 if (arg2 == NULL) {
23604 SWIG_null_ref("wxEvent");
23605 }
23606 if (SWIG_arg_fail(2)) SWIG_fail;
23607 }
23608 {
23609 PyThreadState* __tstate = wxPyBeginAllowThreads();
23610 wxPostEvent(arg1,*arg2);
23611
23612 wxPyEndAllowThreads(__tstate);
23613 if (PyErr_Occurred()) SWIG_fail;
23614 }
23615 Py_INCREF(Py_None); resultobj = Py_None;
23616 return resultobj;
23617 fail:
23618 return NULL;
23619 }
23620
23621
23622 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23623 PyObject *resultobj;
23624 char *kwnames[] = {
23625 NULL
23626 };
23627
23628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 wxApp_CleanUp();
23632
23633 wxPyEndAllowThreads(__tstate);
23634 if (PyErr_Occurred()) SWIG_fail;
23635 }
23636 Py_INCREF(Py_None); resultobj = Py_None;
23637 return resultobj;
23638 fail:
23639 return NULL;
23640 }
23641
23642
23643 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23644 PyObject *resultobj;
23645 wxPyApp *result;
23646 char *kwnames[] = {
23647 NULL
23648 };
23649
23650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23651 {
23652 PyThreadState* __tstate = wxPyBeginAllowThreads();
23653 result = (wxPyApp *)wxPyGetApp();
23654
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 {
23659 resultobj = wxPyMake_wxObject(result, 0);
23660 }
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23668 PyObject *resultobj;
23669 char *arg1 = (char *) 0 ;
23670 PyObject * obj0 = 0 ;
23671 char *kwnames[] = {
23672 (char *) "encoding", NULL
23673 };
23674
23675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23676 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23677 SWIG_arg_fail(1);SWIG_fail;
23678 }
23679 {
23680 PyThreadState* __tstate = wxPyBeginAllowThreads();
23681 wxSetDefaultPyEncoding((char const *)arg1);
23682
23683 wxPyEndAllowThreads(__tstate);
23684 if (PyErr_Occurred()) SWIG_fail;
23685 }
23686 Py_INCREF(Py_None); resultobj = Py_None;
23687 return resultobj;
23688 fail:
23689 return NULL;
23690 }
23691
23692
23693 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23694 PyObject *resultobj;
23695 char *result;
23696 char *kwnames[] = {
23697 NULL
23698 };
23699
23700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 result = (char *)wxGetDefaultPyEncoding();
23704
23705 wxPyEndAllowThreads(__tstate);
23706 if (PyErr_Occurred()) SWIG_fail;
23707 }
23708 resultobj = SWIG_FromCharPtr(result);
23709 return resultobj;
23710 fail:
23711 return NULL;
23712 }
23713
23714
23715 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23716 PyObject *resultobj;
23717 wxEventLoop *result;
23718 char *kwnames[] = {
23719 NULL
23720 };
23721
23722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23723 {
23724 PyThreadState* __tstate = wxPyBeginAllowThreads();
23725 result = (wxEventLoop *)new wxEventLoop();
23726
23727 wxPyEndAllowThreads(__tstate);
23728 if (PyErr_Occurred()) SWIG_fail;
23729 }
23730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj;
23739 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23740 PyObject * obj0 = 0 ;
23741 char *kwnames[] = {
23742 (char *) "self", NULL
23743 };
23744
23745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23747 if (SWIG_arg_fail(1)) SWIG_fail;
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 delete arg1;
23751
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 Py_INCREF(Py_None); resultobj = Py_None;
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23763 PyObject *resultobj;
23764 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23765 int result;
23766 PyObject * obj0 = 0 ;
23767 char *kwnames[] = {
23768 (char *) "self", NULL
23769 };
23770
23771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23773 if (SWIG_arg_fail(1)) SWIG_fail;
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 result = (int)(arg1)->Run();
23777
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 {
23782 resultobj = SWIG_From_int((int)(result));
23783 }
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23791 PyObject *resultobj;
23792 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23793 int arg2 = (int) 0 ;
23794 PyObject * obj0 = 0 ;
23795 PyObject * obj1 = 0 ;
23796 char *kwnames[] = {
23797 (char *) "self",(char *) "rc", NULL
23798 };
23799
23800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23802 if (SWIG_arg_fail(1)) SWIG_fail;
23803 if (obj1) {
23804 {
23805 arg2 = (int)(SWIG_As_int(obj1));
23806 if (SWIG_arg_fail(2)) SWIG_fail;
23807 }
23808 }
23809 {
23810 PyThreadState* __tstate = wxPyBeginAllowThreads();
23811 (arg1)->Exit(arg2);
23812
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 Py_INCREF(Py_None); resultobj = Py_None;
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj;
23825 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23826 bool result;
23827 PyObject * obj0 = 0 ;
23828 char *kwnames[] = {
23829 (char *) "self", NULL
23830 };
23831
23832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23834 if (SWIG_arg_fail(1)) SWIG_fail;
23835 {
23836 PyThreadState* __tstate = wxPyBeginAllowThreads();
23837 result = (bool)((wxEventLoop const *)arg1)->Pending();
23838
23839 wxPyEndAllowThreads(__tstate);
23840 if (PyErr_Occurred()) SWIG_fail;
23841 }
23842 {
23843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23844 }
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23852 PyObject *resultobj;
23853 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23854 bool result;
23855 PyObject * obj0 = 0 ;
23856 char *kwnames[] = {
23857 (char *) "self", NULL
23858 };
23859
23860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23862 if (SWIG_arg_fail(1)) SWIG_fail;
23863 {
23864 PyThreadState* __tstate = wxPyBeginAllowThreads();
23865 result = (bool)(arg1)->Dispatch();
23866
23867 wxPyEndAllowThreads(__tstate);
23868 if (PyErr_Occurred()) SWIG_fail;
23869 }
23870 {
23871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23872 }
23873 return resultobj;
23874 fail:
23875 return NULL;
23876 }
23877
23878
23879 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj;
23881 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23882 bool result;
23883 PyObject * obj0 = 0 ;
23884 char *kwnames[] = {
23885 (char *) "self", NULL
23886 };
23887
23888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23890 if (SWIG_arg_fail(1)) SWIG_fail;
23891 {
23892 PyThreadState* __tstate = wxPyBeginAllowThreads();
23893 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23894
23895 wxPyEndAllowThreads(__tstate);
23896 if (PyErr_Occurred()) SWIG_fail;
23897 }
23898 {
23899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23900 }
23901 return resultobj;
23902 fail:
23903 return NULL;
23904 }
23905
23906
23907 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23908 PyObject *resultobj;
23909 wxEventLoop *result;
23910 char *kwnames[] = {
23911 NULL
23912 };
23913
23914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23915 {
23916 PyThreadState* __tstate = wxPyBeginAllowThreads();
23917 result = (wxEventLoop *)wxEventLoop::GetActive();
23918
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj;
23931 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23932 PyObject * obj0 = 0 ;
23933 char *kwnames[] = {
23934 (char *) "loop", NULL
23935 };
23936
23937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23939 if (SWIG_arg_fail(1)) SWIG_fail;
23940 {
23941 PyThreadState* __tstate = wxPyBeginAllowThreads();
23942 wxEventLoop::SetActive(arg1);
23943
23944 wxPyEndAllowThreads(__tstate);
23945 if (PyErr_Occurred()) SWIG_fail;
23946 }
23947 Py_INCREF(Py_None); resultobj = Py_None;
23948 return resultobj;
23949 fail:
23950 return NULL;
23951 }
23952
23953
23954 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23955 PyObject *obj;
23956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23957 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23958 Py_INCREF(obj);
23959 return Py_BuildValue((char *)"");
23960 }
23961 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23962 PyObject *resultobj;
23963 int arg1 = (int) 0 ;
23964 int arg2 = (int) 0 ;
23965 int arg3 = (int) 0 ;
23966 wxAcceleratorEntry *result;
23967 PyObject * obj0 = 0 ;
23968 PyObject * obj1 = 0 ;
23969 PyObject * obj2 = 0 ;
23970 char *kwnames[] = {
23971 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23972 };
23973
23974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23975 if (obj0) {
23976 {
23977 arg1 = (int)(SWIG_As_int(obj0));
23978 if (SWIG_arg_fail(1)) SWIG_fail;
23979 }
23980 }
23981 if (obj1) {
23982 {
23983 arg2 = (int)(SWIG_As_int(obj1));
23984 if (SWIG_arg_fail(2)) SWIG_fail;
23985 }
23986 }
23987 if (obj2) {
23988 {
23989 arg3 = (int)(SWIG_As_int(obj2));
23990 if (SWIG_arg_fail(3)) SWIG_fail;
23991 }
23992 }
23993 {
23994 PyThreadState* __tstate = wxPyBeginAllowThreads();
23995 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23996
23997 wxPyEndAllowThreads(__tstate);
23998 if (PyErr_Occurred()) SWIG_fail;
23999 }
24000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24008 PyObject *resultobj;
24009 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24010 PyObject * obj0 = 0 ;
24011 char *kwnames[] = {
24012 (char *) "self", NULL
24013 };
24014
24015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24017 if (SWIG_arg_fail(1)) SWIG_fail;
24018 {
24019 PyThreadState* __tstate = wxPyBeginAllowThreads();
24020 delete arg1;
24021
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 Py_INCREF(Py_None); resultobj = Py_None;
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj;
24034 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24035 int arg2 ;
24036 int arg3 ;
24037 int arg4 ;
24038 PyObject * obj0 = 0 ;
24039 PyObject * obj1 = 0 ;
24040 PyObject * obj2 = 0 ;
24041 PyObject * obj3 = 0 ;
24042 char *kwnames[] = {
24043 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24044 };
24045
24046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24048 if (SWIG_arg_fail(1)) SWIG_fail;
24049 {
24050 arg2 = (int)(SWIG_As_int(obj1));
24051 if (SWIG_arg_fail(2)) SWIG_fail;
24052 }
24053 {
24054 arg3 = (int)(SWIG_As_int(obj2));
24055 if (SWIG_arg_fail(3)) SWIG_fail;
24056 }
24057 {
24058 arg4 = (int)(SWIG_As_int(obj3));
24059 if (SWIG_arg_fail(4)) SWIG_fail;
24060 }
24061 {
24062 PyThreadState* __tstate = wxPyBeginAllowThreads();
24063 (arg1)->Set(arg2,arg3,arg4);
24064
24065 wxPyEndAllowThreads(__tstate);
24066 if (PyErr_Occurred()) SWIG_fail;
24067 }
24068 Py_INCREF(Py_None); resultobj = Py_None;
24069 return resultobj;
24070 fail:
24071 return NULL;
24072 }
24073
24074
24075 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24076 PyObject *resultobj;
24077 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24078 int result;
24079 PyObject * obj0 = 0 ;
24080 char *kwnames[] = {
24081 (char *) "self", NULL
24082 };
24083
24084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24086 if (SWIG_arg_fail(1)) SWIG_fail;
24087 {
24088 PyThreadState* __tstate = wxPyBeginAllowThreads();
24089 result = (int)(arg1)->GetFlags();
24090
24091 wxPyEndAllowThreads(__tstate);
24092 if (PyErr_Occurred()) SWIG_fail;
24093 }
24094 {
24095 resultobj = SWIG_From_int((int)(result));
24096 }
24097 return resultobj;
24098 fail:
24099 return NULL;
24100 }
24101
24102
24103 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24104 PyObject *resultobj;
24105 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24106 int result;
24107 PyObject * obj0 = 0 ;
24108 char *kwnames[] = {
24109 (char *) "self", NULL
24110 };
24111
24112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24114 if (SWIG_arg_fail(1)) SWIG_fail;
24115 {
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 result = (int)(arg1)->GetKeyCode();
24118
24119 wxPyEndAllowThreads(__tstate);
24120 if (PyErr_Occurred()) SWIG_fail;
24121 }
24122 {
24123 resultobj = SWIG_From_int((int)(result));
24124 }
24125 return resultobj;
24126 fail:
24127 return NULL;
24128 }
24129
24130
24131 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24132 PyObject *resultobj;
24133 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24134 int result;
24135 PyObject * obj0 = 0 ;
24136 char *kwnames[] = {
24137 (char *) "self", NULL
24138 };
24139
24140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24142 if (SWIG_arg_fail(1)) SWIG_fail;
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 result = (int)(arg1)->GetCommand();
24146
24147 wxPyEndAllowThreads(__tstate);
24148 if (PyErr_Occurred()) SWIG_fail;
24149 }
24150 {
24151 resultobj = SWIG_From_int((int)(result));
24152 }
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24160 PyObject *obj;
24161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24162 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24163 Py_INCREF(obj);
24164 return Py_BuildValue((char *)"");
24165 }
24166 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24167 PyObject *resultobj;
24168 int arg1 ;
24169 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24170 wxAcceleratorTable *result;
24171 PyObject * obj0 = 0 ;
24172 char *kwnames[] = {
24173 (char *) "n", NULL
24174 };
24175
24176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24177 {
24178 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24179 if (arg2) arg1 = PyList_Size(obj0);
24180 else arg1 = 0;
24181 }
24182 {
24183 PyThreadState* __tstate = wxPyBeginAllowThreads();
24184 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24185
24186 wxPyEndAllowThreads(__tstate);
24187 if (PyErr_Occurred()) SWIG_fail;
24188 }
24189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24190 {
24191 delete [] arg2;
24192 }
24193 return resultobj;
24194 fail:
24195 {
24196 delete [] arg2;
24197 }
24198 return NULL;
24199 }
24200
24201
24202 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24203 PyObject *resultobj;
24204 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24205 PyObject * obj0 = 0 ;
24206 char *kwnames[] = {
24207 (char *) "self", NULL
24208 };
24209
24210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24212 if (SWIG_arg_fail(1)) SWIG_fail;
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 delete arg1;
24216
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 Py_INCREF(Py_None); resultobj = Py_None;
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj;
24229 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24230 bool result;
24231 PyObject * obj0 = 0 ;
24232 char *kwnames[] = {
24233 (char *) "self", NULL
24234 };
24235
24236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24238 if (SWIG_arg_fail(1)) SWIG_fail;
24239 {
24240 PyThreadState* __tstate = wxPyBeginAllowThreads();
24241 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24242
24243 wxPyEndAllowThreads(__tstate);
24244 if (PyErr_Occurred()) SWIG_fail;
24245 }
24246 {
24247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24248 }
24249 return resultobj;
24250 fail:
24251 return NULL;
24252 }
24253
24254
24255 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24256 PyObject *obj;
24257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24258 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24259 Py_INCREF(obj);
24260 return Py_BuildValue((char *)"");
24261 }
24262 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24263 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24264 return 1;
24265 }
24266
24267
24268 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24269 PyObject *pyobj;
24270
24271 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24272 return pyobj;
24273 }
24274
24275
24276 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24277 PyObject *resultobj;
24278 wxString *arg1 = 0 ;
24279 wxAcceleratorEntry *result;
24280 bool temp1 = false ;
24281 PyObject * obj0 = 0 ;
24282 char *kwnames[] = {
24283 (char *) "label", NULL
24284 };
24285
24286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24287 {
24288 arg1 = wxString_in_helper(obj0);
24289 if (arg1 == NULL) SWIG_fail;
24290 temp1 = true;
24291 }
24292 {
24293 PyThreadState* __tstate = wxPyBeginAllowThreads();
24294 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24295
24296 wxPyEndAllowThreads(__tstate);
24297 if (PyErr_Occurred()) SWIG_fail;
24298 }
24299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24300 {
24301 if (temp1)
24302 delete arg1;
24303 }
24304 return resultobj;
24305 fail:
24306 {
24307 if (temp1)
24308 delete arg1;
24309 }
24310 return NULL;
24311 }
24312
24313
24314 static int _wrap_PanelNameStr_set(PyObject *) {
24315 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24316 return 1;
24317 }
24318
24319
24320 static PyObject *_wrap_PanelNameStr_get(void) {
24321 PyObject *pyobj;
24322
24323 {
24324 #if wxUSE_UNICODE
24325 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24326 #else
24327 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24328 #endif
24329 }
24330 return pyobj;
24331 }
24332
24333
24334 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24335 PyObject *resultobj;
24336 wxVisualAttributes *result;
24337 char *kwnames[] = {
24338 NULL
24339 };
24340
24341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24342 {
24343 PyThreadState* __tstate = wxPyBeginAllowThreads();
24344 result = (wxVisualAttributes *)new_wxVisualAttributes();
24345
24346 wxPyEndAllowThreads(__tstate);
24347 if (PyErr_Occurred()) SWIG_fail;
24348 }
24349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24350 return resultobj;
24351 fail:
24352 return NULL;
24353 }
24354
24355
24356 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24357 PyObject *resultobj;
24358 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24359 PyObject * obj0 = 0 ;
24360 char *kwnames[] = {
24361 (char *) "self", NULL
24362 };
24363
24364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24366 if (SWIG_arg_fail(1)) SWIG_fail;
24367 {
24368 PyThreadState* __tstate = wxPyBeginAllowThreads();
24369 delete_wxVisualAttributes(arg1);
24370
24371 wxPyEndAllowThreads(__tstate);
24372 if (PyErr_Occurred()) SWIG_fail;
24373 }
24374 Py_INCREF(Py_None); resultobj = Py_None;
24375 return resultobj;
24376 fail:
24377 return NULL;
24378 }
24379
24380
24381 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24382 PyObject *resultobj;
24383 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24384 wxFont *arg2 = (wxFont *) 0 ;
24385 PyObject * obj0 = 0 ;
24386 PyObject * obj1 = 0 ;
24387 char *kwnames[] = {
24388 (char *) "self",(char *) "font", NULL
24389 };
24390
24391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24393 if (SWIG_arg_fail(1)) SWIG_fail;
24394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24395 if (SWIG_arg_fail(2)) SWIG_fail;
24396 if (arg1) (arg1)->font = *arg2;
24397
24398 Py_INCREF(Py_None); resultobj = Py_None;
24399 return resultobj;
24400 fail:
24401 return NULL;
24402 }
24403
24404
24405 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24406 PyObject *resultobj;
24407 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24408 wxFont *result;
24409 PyObject * obj0 = 0 ;
24410 char *kwnames[] = {
24411 (char *) "self", NULL
24412 };
24413
24414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24416 if (SWIG_arg_fail(1)) SWIG_fail;
24417 result = (wxFont *)& ((arg1)->font);
24418
24419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24420 return resultobj;
24421 fail:
24422 return NULL;
24423 }
24424
24425
24426 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24427 PyObject *resultobj;
24428 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24429 wxColour *arg2 = (wxColour *) 0 ;
24430 PyObject * obj0 = 0 ;
24431 PyObject * obj1 = 0 ;
24432 char *kwnames[] = {
24433 (char *) "self",(char *) "colFg", NULL
24434 };
24435
24436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24438 if (SWIG_arg_fail(1)) SWIG_fail;
24439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24440 if (SWIG_arg_fail(2)) SWIG_fail;
24441 if (arg1) (arg1)->colFg = *arg2;
24442
24443 Py_INCREF(Py_None); resultobj = Py_None;
24444 return resultobj;
24445 fail:
24446 return NULL;
24447 }
24448
24449
24450 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24451 PyObject *resultobj;
24452 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24453 wxColour *result;
24454 PyObject * obj0 = 0 ;
24455 char *kwnames[] = {
24456 (char *) "self", NULL
24457 };
24458
24459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24461 if (SWIG_arg_fail(1)) SWIG_fail;
24462 result = (wxColour *)& ((arg1)->colFg);
24463
24464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24472 PyObject *resultobj;
24473 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24474 wxColour *arg2 = (wxColour *) 0 ;
24475 PyObject * obj0 = 0 ;
24476 PyObject * obj1 = 0 ;
24477 char *kwnames[] = {
24478 (char *) "self",(char *) "colBg", NULL
24479 };
24480
24481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24483 if (SWIG_arg_fail(1)) SWIG_fail;
24484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24485 if (SWIG_arg_fail(2)) SWIG_fail;
24486 if (arg1) (arg1)->colBg = *arg2;
24487
24488 Py_INCREF(Py_None); resultobj = Py_None;
24489 return resultobj;
24490 fail:
24491 return NULL;
24492 }
24493
24494
24495 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24496 PyObject *resultobj;
24497 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24498 wxColour *result;
24499 PyObject * obj0 = 0 ;
24500 char *kwnames[] = {
24501 (char *) "self", NULL
24502 };
24503
24504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24506 if (SWIG_arg_fail(1)) SWIG_fail;
24507 result = (wxColour *)& ((arg1)->colBg);
24508
24509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24517 PyObject *obj;
24518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24519 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24520 Py_INCREF(obj);
24521 return Py_BuildValue((char *)"");
24522 }
24523 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj;
24525 wxWindow *arg1 = (wxWindow *) 0 ;
24526 int arg2 = (int) (int)-1 ;
24527 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24528 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24529 wxSize const &arg4_defvalue = wxDefaultSize ;
24530 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24531 long arg5 = (long) 0 ;
24532 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24533 wxString *arg6 = (wxString *) &arg6_defvalue ;
24534 wxWindow *result;
24535 wxPoint temp3 ;
24536 wxSize temp4 ;
24537 bool temp6 = false ;
24538 PyObject * obj0 = 0 ;
24539 PyObject * obj1 = 0 ;
24540 PyObject * obj2 = 0 ;
24541 PyObject * obj3 = 0 ;
24542 PyObject * obj4 = 0 ;
24543 PyObject * obj5 = 0 ;
24544 char *kwnames[] = {
24545 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24546 };
24547
24548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24550 if (SWIG_arg_fail(1)) SWIG_fail;
24551 if (obj1) {
24552 {
24553 arg2 = (int const)(SWIG_As_int(obj1));
24554 if (SWIG_arg_fail(2)) SWIG_fail;
24555 }
24556 }
24557 if (obj2) {
24558 {
24559 arg3 = &temp3;
24560 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24561 }
24562 }
24563 if (obj3) {
24564 {
24565 arg4 = &temp4;
24566 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24567 }
24568 }
24569 if (obj4) {
24570 {
24571 arg5 = (long)(SWIG_As_long(obj4));
24572 if (SWIG_arg_fail(5)) SWIG_fail;
24573 }
24574 }
24575 if (obj5) {
24576 {
24577 arg6 = wxString_in_helper(obj5);
24578 if (arg6 == NULL) SWIG_fail;
24579 temp6 = true;
24580 }
24581 }
24582 {
24583 if (!wxPyCheckForApp()) SWIG_fail;
24584 PyThreadState* __tstate = wxPyBeginAllowThreads();
24585 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24586
24587 wxPyEndAllowThreads(__tstate);
24588 if (PyErr_Occurred()) SWIG_fail;
24589 }
24590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24591 {
24592 if (temp6)
24593 delete arg6;
24594 }
24595 return resultobj;
24596 fail:
24597 {
24598 if (temp6)
24599 delete arg6;
24600 }
24601 return NULL;
24602 }
24603
24604
24605 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24606 PyObject *resultobj;
24607 wxWindow *result;
24608 char *kwnames[] = {
24609 NULL
24610 };
24611
24612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24613 {
24614 if (!wxPyCheckForApp()) SWIG_fail;
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 result = (wxWindow *)new wxWindow();
24617
24618 wxPyEndAllowThreads(__tstate);
24619 if (PyErr_Occurred()) SWIG_fail;
24620 }
24621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24629 PyObject *resultobj;
24630 wxWindow *arg1 = (wxWindow *) 0 ;
24631 wxWindow *arg2 = (wxWindow *) 0 ;
24632 int arg3 = (int) (int)-1 ;
24633 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24634 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24635 wxSize const &arg5_defvalue = wxDefaultSize ;
24636 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24637 long arg6 = (long) 0 ;
24638 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24639 wxString *arg7 = (wxString *) &arg7_defvalue ;
24640 bool result;
24641 wxPoint temp4 ;
24642 wxSize temp5 ;
24643 bool temp7 = false ;
24644 PyObject * obj0 = 0 ;
24645 PyObject * obj1 = 0 ;
24646 PyObject * obj2 = 0 ;
24647 PyObject * obj3 = 0 ;
24648 PyObject * obj4 = 0 ;
24649 PyObject * obj5 = 0 ;
24650 PyObject * obj6 = 0 ;
24651 char *kwnames[] = {
24652 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24653 };
24654
24655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24657 if (SWIG_arg_fail(1)) SWIG_fail;
24658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24659 if (SWIG_arg_fail(2)) SWIG_fail;
24660 if (obj2) {
24661 {
24662 arg3 = (int const)(SWIG_As_int(obj2));
24663 if (SWIG_arg_fail(3)) SWIG_fail;
24664 }
24665 }
24666 if (obj3) {
24667 {
24668 arg4 = &temp4;
24669 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24670 }
24671 }
24672 if (obj4) {
24673 {
24674 arg5 = &temp5;
24675 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24676 }
24677 }
24678 if (obj5) {
24679 {
24680 arg6 = (long)(SWIG_As_long(obj5));
24681 if (SWIG_arg_fail(6)) SWIG_fail;
24682 }
24683 }
24684 if (obj6) {
24685 {
24686 arg7 = wxString_in_helper(obj6);
24687 if (arg7 == NULL) SWIG_fail;
24688 temp7 = true;
24689 }
24690 }
24691 {
24692 PyThreadState* __tstate = wxPyBeginAllowThreads();
24693 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24694
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 {
24699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24700 }
24701 {
24702 if (temp7)
24703 delete arg7;
24704 }
24705 return resultobj;
24706 fail:
24707 {
24708 if (temp7)
24709 delete arg7;
24710 }
24711 return NULL;
24712 }
24713
24714
24715 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24716 PyObject *resultobj;
24717 wxWindow *arg1 = (wxWindow *) 0 ;
24718 bool arg2 = (bool) false ;
24719 bool result;
24720 PyObject * obj0 = 0 ;
24721 PyObject * obj1 = 0 ;
24722 char *kwnames[] = {
24723 (char *) "self",(char *) "force", NULL
24724 };
24725
24726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24728 if (SWIG_arg_fail(1)) SWIG_fail;
24729 if (obj1) {
24730 {
24731 arg2 = (bool)(SWIG_As_bool(obj1));
24732 if (SWIG_arg_fail(2)) SWIG_fail;
24733 }
24734 }
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (bool)(arg1)->Close(arg2);
24738
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 {
24743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24744 }
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24752 PyObject *resultobj;
24753 wxWindow *arg1 = (wxWindow *) 0 ;
24754 bool result;
24755 PyObject * obj0 = 0 ;
24756 char *kwnames[] = {
24757 (char *) "self", NULL
24758 };
24759
24760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24762 if (SWIG_arg_fail(1)) SWIG_fail;
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (bool)(arg1)->Destroy();
24766
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 {
24771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24772 }
24773 return resultobj;
24774 fail:
24775 return NULL;
24776 }
24777
24778
24779 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24780 PyObject *resultobj;
24781 wxWindow *arg1 = (wxWindow *) 0 ;
24782 bool result;
24783 PyObject * obj0 = 0 ;
24784 char *kwnames[] = {
24785 (char *) "self", NULL
24786 };
24787
24788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24790 if (SWIG_arg_fail(1)) SWIG_fail;
24791 {
24792 PyThreadState* __tstate = wxPyBeginAllowThreads();
24793 result = (bool)(arg1)->DestroyChildren();
24794
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 {
24799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24800 }
24801 return resultobj;
24802 fail:
24803 return NULL;
24804 }
24805
24806
24807 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24808 PyObject *resultobj;
24809 wxWindow *arg1 = (wxWindow *) 0 ;
24810 bool result;
24811 PyObject * obj0 = 0 ;
24812 char *kwnames[] = {
24813 (char *) "self", NULL
24814 };
24815
24816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24818 if (SWIG_arg_fail(1)) SWIG_fail;
24819 {
24820 PyThreadState* __tstate = wxPyBeginAllowThreads();
24821 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24822
24823 wxPyEndAllowThreads(__tstate);
24824 if (PyErr_Occurred()) SWIG_fail;
24825 }
24826 {
24827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24828 }
24829 return resultobj;
24830 fail:
24831 return NULL;
24832 }
24833
24834
24835 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24836 PyObject *resultobj;
24837 wxWindow *arg1 = (wxWindow *) 0 ;
24838 wxString *arg2 = 0 ;
24839 bool temp2 = false ;
24840 PyObject * obj0 = 0 ;
24841 PyObject * obj1 = 0 ;
24842 char *kwnames[] = {
24843 (char *) "self",(char *) "title", NULL
24844 };
24845
24846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24848 if (SWIG_arg_fail(1)) SWIG_fail;
24849 {
24850 arg2 = wxString_in_helper(obj1);
24851 if (arg2 == NULL) SWIG_fail;
24852 temp2 = true;
24853 }
24854 {
24855 PyThreadState* __tstate = wxPyBeginAllowThreads();
24856 (arg1)->SetTitle((wxString const &)*arg2);
24857
24858 wxPyEndAllowThreads(__tstate);
24859 if (PyErr_Occurred()) SWIG_fail;
24860 }
24861 Py_INCREF(Py_None); resultobj = Py_None;
24862 {
24863 if (temp2)
24864 delete arg2;
24865 }
24866 return resultobj;
24867 fail:
24868 {
24869 if (temp2)
24870 delete arg2;
24871 }
24872 return NULL;
24873 }
24874
24875
24876 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24877 PyObject *resultobj;
24878 wxWindow *arg1 = (wxWindow *) 0 ;
24879 wxString result;
24880 PyObject * obj0 = 0 ;
24881 char *kwnames[] = {
24882 (char *) "self", NULL
24883 };
24884
24885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24887 if (SWIG_arg_fail(1)) SWIG_fail;
24888 {
24889 PyThreadState* __tstate = wxPyBeginAllowThreads();
24890 result = ((wxWindow const *)arg1)->GetTitle();
24891
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 {
24896 #if wxUSE_UNICODE
24897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24898 #else
24899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24900 #endif
24901 }
24902 return resultobj;
24903 fail:
24904 return NULL;
24905 }
24906
24907
24908 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24909 PyObject *resultobj;
24910 wxWindow *arg1 = (wxWindow *) 0 ;
24911 wxString *arg2 = 0 ;
24912 bool temp2 = false ;
24913 PyObject * obj0 = 0 ;
24914 PyObject * obj1 = 0 ;
24915 char *kwnames[] = {
24916 (char *) "self",(char *) "label", NULL
24917 };
24918
24919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24921 if (SWIG_arg_fail(1)) SWIG_fail;
24922 {
24923 arg2 = wxString_in_helper(obj1);
24924 if (arg2 == NULL) SWIG_fail;
24925 temp2 = true;
24926 }
24927 {
24928 PyThreadState* __tstate = wxPyBeginAllowThreads();
24929 (arg1)->SetLabel((wxString const &)*arg2);
24930
24931 wxPyEndAllowThreads(__tstate);
24932 if (PyErr_Occurred()) SWIG_fail;
24933 }
24934 Py_INCREF(Py_None); resultobj = Py_None;
24935 {
24936 if (temp2)
24937 delete arg2;
24938 }
24939 return resultobj;
24940 fail:
24941 {
24942 if (temp2)
24943 delete arg2;
24944 }
24945 return NULL;
24946 }
24947
24948
24949 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24950 PyObject *resultobj;
24951 wxWindow *arg1 = (wxWindow *) 0 ;
24952 wxString result;
24953 PyObject * obj0 = 0 ;
24954 char *kwnames[] = {
24955 (char *) "self", NULL
24956 };
24957
24958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24960 if (SWIG_arg_fail(1)) SWIG_fail;
24961 {
24962 PyThreadState* __tstate = wxPyBeginAllowThreads();
24963 result = ((wxWindow const *)arg1)->GetLabel();
24964
24965 wxPyEndAllowThreads(__tstate);
24966 if (PyErr_Occurred()) SWIG_fail;
24967 }
24968 {
24969 #if wxUSE_UNICODE
24970 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24971 #else
24972 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24973 #endif
24974 }
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24982 PyObject *resultobj;
24983 wxWindow *arg1 = (wxWindow *) 0 ;
24984 wxString *arg2 = 0 ;
24985 bool temp2 = false ;
24986 PyObject * obj0 = 0 ;
24987 PyObject * obj1 = 0 ;
24988 char *kwnames[] = {
24989 (char *) "self",(char *) "name", NULL
24990 };
24991
24992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24994 if (SWIG_arg_fail(1)) SWIG_fail;
24995 {
24996 arg2 = wxString_in_helper(obj1);
24997 if (arg2 == NULL) SWIG_fail;
24998 temp2 = true;
24999 }
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 (arg1)->SetName((wxString const &)*arg2);
25003
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 Py_INCREF(Py_None); resultobj = Py_None;
25008 {
25009 if (temp2)
25010 delete arg2;
25011 }
25012 return resultobj;
25013 fail:
25014 {
25015 if (temp2)
25016 delete arg2;
25017 }
25018 return NULL;
25019 }
25020
25021
25022 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj;
25024 wxWindow *arg1 = (wxWindow *) 0 ;
25025 wxString result;
25026 PyObject * obj0 = 0 ;
25027 char *kwnames[] = {
25028 (char *) "self", NULL
25029 };
25030
25031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25033 if (SWIG_arg_fail(1)) SWIG_fail;
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 result = ((wxWindow const *)arg1)->GetName();
25037
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 {
25042 #if wxUSE_UNICODE
25043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25044 #else
25045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25046 #endif
25047 }
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25055 PyObject *resultobj;
25056 wxWindow *arg1 = (wxWindow *) 0 ;
25057 wxWindowVariant arg2 ;
25058 PyObject * obj0 = 0 ;
25059 PyObject * obj1 = 0 ;
25060 char *kwnames[] = {
25061 (char *) "self",(char *) "variant", NULL
25062 };
25063
25064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25066 if (SWIG_arg_fail(1)) SWIG_fail;
25067 {
25068 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25069 if (SWIG_arg_fail(2)) SWIG_fail;
25070 }
25071 {
25072 PyThreadState* __tstate = wxPyBeginAllowThreads();
25073 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25074
25075 wxPyEndAllowThreads(__tstate);
25076 if (PyErr_Occurred()) SWIG_fail;
25077 }
25078 Py_INCREF(Py_None); resultobj = Py_None;
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25086 PyObject *resultobj;
25087 wxWindow *arg1 = (wxWindow *) 0 ;
25088 wxWindowVariant result;
25089 PyObject * obj0 = 0 ;
25090 char *kwnames[] = {
25091 (char *) "self", NULL
25092 };
25093
25094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25096 if (SWIG_arg_fail(1)) SWIG_fail;
25097 {
25098 PyThreadState* __tstate = wxPyBeginAllowThreads();
25099 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25100
25101 wxPyEndAllowThreads(__tstate);
25102 if (PyErr_Occurred()) SWIG_fail;
25103 }
25104 resultobj = SWIG_From_int((result));
25105 return resultobj;
25106 fail:
25107 return NULL;
25108 }
25109
25110
25111 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25112 PyObject *resultobj;
25113 wxWindow *arg1 = (wxWindow *) 0 ;
25114 int arg2 ;
25115 PyObject * obj0 = 0 ;
25116 PyObject * obj1 = 0 ;
25117 char *kwnames[] = {
25118 (char *) "self",(char *) "winid", NULL
25119 };
25120
25121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25123 if (SWIG_arg_fail(1)) SWIG_fail;
25124 {
25125 arg2 = (int)(SWIG_As_int(obj1));
25126 if (SWIG_arg_fail(2)) SWIG_fail;
25127 }
25128 {
25129 PyThreadState* __tstate = wxPyBeginAllowThreads();
25130 (arg1)->SetId(arg2);
25131
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 Py_INCREF(Py_None); resultobj = Py_None;
25136 return resultobj;
25137 fail:
25138 return NULL;
25139 }
25140
25141
25142 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25143 PyObject *resultobj;
25144 wxWindow *arg1 = (wxWindow *) 0 ;
25145 int result;
25146 PyObject * obj0 = 0 ;
25147 char *kwnames[] = {
25148 (char *) "self", NULL
25149 };
25150
25151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25153 if (SWIG_arg_fail(1)) SWIG_fail;
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (int)((wxWindow const *)arg1)->GetId();
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 resultobj = SWIG_From_int((int)(result));
25163 }
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj;
25172 int result;
25173 char *kwnames[] = {
25174 NULL
25175 };
25176
25177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25178 {
25179 PyThreadState* __tstate = wxPyBeginAllowThreads();
25180 result = (int)wxWindow::NewControlId();
25181
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 {
25186 resultobj = SWIG_From_int((int)(result));
25187 }
25188 return resultobj;
25189 fail:
25190 return NULL;
25191 }
25192
25193
25194 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25195 PyObject *resultobj;
25196 int arg1 ;
25197 int result;
25198 PyObject * obj0 = 0 ;
25199 char *kwnames[] = {
25200 (char *) "winid", NULL
25201 };
25202
25203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25204 {
25205 arg1 = (int)(SWIG_As_int(obj0));
25206 if (SWIG_arg_fail(1)) SWIG_fail;
25207 }
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 result = (int)wxWindow::NextControlId(arg1);
25211
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 {
25216 resultobj = SWIG_From_int((int)(result));
25217 }
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj;
25226 int arg1 ;
25227 int result;
25228 PyObject * obj0 = 0 ;
25229 char *kwnames[] = {
25230 (char *) "winid", NULL
25231 };
25232
25233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25234 {
25235 arg1 = (int)(SWIG_As_int(obj0));
25236 if (SWIG_arg_fail(1)) SWIG_fail;
25237 }
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 result = (int)wxWindow::PrevControlId(arg1);
25241
25242 wxPyEndAllowThreads(__tstate);
25243 if (PyErr_Occurred()) SWIG_fail;
25244 }
25245 {
25246 resultobj = SWIG_From_int((int)(result));
25247 }
25248 return resultobj;
25249 fail:
25250 return NULL;
25251 }
25252
25253
25254 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25255 PyObject *resultobj;
25256 wxWindow *arg1 = (wxWindow *) 0 ;
25257 wxSize *arg2 = 0 ;
25258 wxSize temp2 ;
25259 PyObject * obj0 = 0 ;
25260 PyObject * obj1 = 0 ;
25261 char *kwnames[] = {
25262 (char *) "self",(char *) "size", NULL
25263 };
25264
25265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25267 if (SWIG_arg_fail(1)) SWIG_fail;
25268 {
25269 arg2 = &temp2;
25270 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25271 }
25272 {
25273 PyThreadState* __tstate = wxPyBeginAllowThreads();
25274 (arg1)->SetSize((wxSize const &)*arg2);
25275
25276 wxPyEndAllowThreads(__tstate);
25277 if (PyErr_Occurred()) SWIG_fail;
25278 }
25279 Py_INCREF(Py_None); resultobj = Py_None;
25280 return resultobj;
25281 fail:
25282 return NULL;
25283 }
25284
25285
25286 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25287 PyObject *resultobj;
25288 wxWindow *arg1 = (wxWindow *) 0 ;
25289 int arg2 ;
25290 int arg3 ;
25291 int arg4 ;
25292 int arg5 ;
25293 int arg6 = (int) wxSIZE_AUTO ;
25294 PyObject * obj0 = 0 ;
25295 PyObject * obj1 = 0 ;
25296 PyObject * obj2 = 0 ;
25297 PyObject * obj3 = 0 ;
25298 PyObject * obj4 = 0 ;
25299 PyObject * obj5 = 0 ;
25300 char *kwnames[] = {
25301 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25302 };
25303
25304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25306 if (SWIG_arg_fail(1)) SWIG_fail;
25307 {
25308 arg2 = (int)(SWIG_As_int(obj1));
25309 if (SWIG_arg_fail(2)) SWIG_fail;
25310 }
25311 {
25312 arg3 = (int)(SWIG_As_int(obj2));
25313 if (SWIG_arg_fail(3)) SWIG_fail;
25314 }
25315 {
25316 arg4 = (int)(SWIG_As_int(obj3));
25317 if (SWIG_arg_fail(4)) SWIG_fail;
25318 }
25319 {
25320 arg5 = (int)(SWIG_As_int(obj4));
25321 if (SWIG_arg_fail(5)) SWIG_fail;
25322 }
25323 if (obj5) {
25324 {
25325 arg6 = (int)(SWIG_As_int(obj5));
25326 if (SWIG_arg_fail(6)) SWIG_fail;
25327 }
25328 }
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25332
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 Py_INCREF(Py_None); resultobj = Py_None;
25337 return resultobj;
25338 fail:
25339 return NULL;
25340 }
25341
25342
25343 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25344 PyObject *resultobj;
25345 wxWindow *arg1 = (wxWindow *) 0 ;
25346 wxRect *arg2 = 0 ;
25347 int arg3 = (int) wxSIZE_AUTO ;
25348 wxRect temp2 ;
25349 PyObject * obj0 = 0 ;
25350 PyObject * obj1 = 0 ;
25351 PyObject * obj2 = 0 ;
25352 char *kwnames[] = {
25353 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25354 };
25355
25356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25358 if (SWIG_arg_fail(1)) SWIG_fail;
25359 {
25360 arg2 = &temp2;
25361 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25362 }
25363 if (obj2) {
25364 {
25365 arg3 = (int)(SWIG_As_int(obj2));
25366 if (SWIG_arg_fail(3)) SWIG_fail;
25367 }
25368 }
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25372
25373 wxPyEndAllowThreads(__tstate);
25374 if (PyErr_Occurred()) SWIG_fail;
25375 }
25376 Py_INCREF(Py_None); resultobj = Py_None;
25377 return resultobj;
25378 fail:
25379 return NULL;
25380 }
25381
25382
25383 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25384 PyObject *resultobj;
25385 wxWindow *arg1 = (wxWindow *) 0 ;
25386 int arg2 ;
25387 int arg3 ;
25388 PyObject * obj0 = 0 ;
25389 PyObject * obj1 = 0 ;
25390 PyObject * obj2 = 0 ;
25391 char *kwnames[] = {
25392 (char *) "self",(char *) "width",(char *) "height", NULL
25393 };
25394
25395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25397 if (SWIG_arg_fail(1)) SWIG_fail;
25398 {
25399 arg2 = (int)(SWIG_As_int(obj1));
25400 if (SWIG_arg_fail(2)) SWIG_fail;
25401 }
25402 {
25403 arg3 = (int)(SWIG_As_int(obj2));
25404 if (SWIG_arg_fail(3)) SWIG_fail;
25405 }
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 (arg1)->SetSize(arg2,arg3);
25409
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 Py_INCREF(Py_None); resultobj = Py_None;
25414 return resultobj;
25415 fail:
25416 return NULL;
25417 }
25418
25419
25420 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25421 PyObject *resultobj;
25422 wxWindow *arg1 = (wxWindow *) 0 ;
25423 wxPoint *arg2 = 0 ;
25424 int arg3 = (int) wxSIZE_USE_EXISTING ;
25425 wxPoint temp2 ;
25426 PyObject * obj0 = 0 ;
25427 PyObject * obj1 = 0 ;
25428 PyObject * obj2 = 0 ;
25429 char *kwnames[] = {
25430 (char *) "self",(char *) "pt",(char *) "flags", NULL
25431 };
25432
25433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25435 if (SWIG_arg_fail(1)) SWIG_fail;
25436 {
25437 arg2 = &temp2;
25438 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25439 }
25440 if (obj2) {
25441 {
25442 arg3 = (int)(SWIG_As_int(obj2));
25443 if (SWIG_arg_fail(3)) SWIG_fail;
25444 }
25445 }
25446 {
25447 PyThreadState* __tstate = wxPyBeginAllowThreads();
25448 (arg1)->Move((wxPoint const &)*arg2,arg3);
25449
25450 wxPyEndAllowThreads(__tstate);
25451 if (PyErr_Occurred()) SWIG_fail;
25452 }
25453 Py_INCREF(Py_None); resultobj = Py_None;
25454 return resultobj;
25455 fail:
25456 return NULL;
25457 }
25458
25459
25460 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25461 PyObject *resultobj;
25462 wxWindow *arg1 = (wxWindow *) 0 ;
25463 int arg2 ;
25464 int arg3 ;
25465 int arg4 = (int) wxSIZE_USE_EXISTING ;
25466 PyObject * obj0 = 0 ;
25467 PyObject * obj1 = 0 ;
25468 PyObject * obj2 = 0 ;
25469 PyObject * obj3 = 0 ;
25470 char *kwnames[] = {
25471 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25472 };
25473
25474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25476 if (SWIG_arg_fail(1)) SWIG_fail;
25477 {
25478 arg2 = (int)(SWIG_As_int(obj1));
25479 if (SWIG_arg_fail(2)) SWIG_fail;
25480 }
25481 {
25482 arg3 = (int)(SWIG_As_int(obj2));
25483 if (SWIG_arg_fail(3)) SWIG_fail;
25484 }
25485 if (obj3) {
25486 {
25487 arg4 = (int)(SWIG_As_int(obj3));
25488 if (SWIG_arg_fail(4)) SWIG_fail;
25489 }
25490 }
25491 {
25492 PyThreadState* __tstate = wxPyBeginAllowThreads();
25493 (arg1)->Move(arg2,arg3,arg4);
25494
25495 wxPyEndAllowThreads(__tstate);
25496 if (PyErr_Occurred()) SWIG_fail;
25497 }
25498 Py_INCREF(Py_None); resultobj = Py_None;
25499 return resultobj;
25500 fail:
25501 return NULL;
25502 }
25503
25504
25505 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25506 PyObject *resultobj;
25507 wxWindow *arg1 = (wxWindow *) 0 ;
25508 wxSize const &arg2_defvalue = wxDefaultSize ;
25509 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25510 wxSize temp2 ;
25511 PyObject * obj0 = 0 ;
25512 PyObject * obj1 = 0 ;
25513 char *kwnames[] = {
25514 (char *) "self",(char *) "size", NULL
25515 };
25516
25517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25519 if (SWIG_arg_fail(1)) SWIG_fail;
25520 if (obj1) {
25521 {
25522 arg2 = &temp2;
25523 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25524 }
25525 }
25526 {
25527 PyThreadState* __tstate = wxPyBeginAllowThreads();
25528 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25529
25530 wxPyEndAllowThreads(__tstate);
25531 if (PyErr_Occurred()) SWIG_fail;
25532 }
25533 Py_INCREF(Py_None); resultobj = Py_None;
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25541 PyObject *resultobj;
25542 wxWindow *arg1 = (wxWindow *) 0 ;
25543 PyObject * obj0 = 0 ;
25544 char *kwnames[] = {
25545 (char *) "self", NULL
25546 };
25547
25548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25550 if (SWIG_arg_fail(1)) SWIG_fail;
25551 {
25552 PyThreadState* __tstate = wxPyBeginAllowThreads();
25553 (arg1)->Raise();
25554
25555 wxPyEndAllowThreads(__tstate);
25556 if (PyErr_Occurred()) SWIG_fail;
25557 }
25558 Py_INCREF(Py_None); resultobj = Py_None;
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25566 PyObject *resultobj;
25567 wxWindow *arg1 = (wxWindow *) 0 ;
25568 PyObject * obj0 = 0 ;
25569 char *kwnames[] = {
25570 (char *) "self", NULL
25571 };
25572
25573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25575 if (SWIG_arg_fail(1)) SWIG_fail;
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 (arg1)->Lower();
25579
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 Py_INCREF(Py_None); resultobj = Py_None;
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj;
25592 wxWindow *arg1 = (wxWindow *) 0 ;
25593 wxSize *arg2 = 0 ;
25594 wxSize temp2 ;
25595 PyObject * obj0 = 0 ;
25596 PyObject * obj1 = 0 ;
25597 char *kwnames[] = {
25598 (char *) "self",(char *) "size", NULL
25599 };
25600
25601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25603 if (SWIG_arg_fail(1)) SWIG_fail;
25604 {
25605 arg2 = &temp2;
25606 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25607 }
25608 {
25609 PyThreadState* __tstate = wxPyBeginAllowThreads();
25610 (arg1)->SetClientSize((wxSize const &)*arg2);
25611
25612 wxPyEndAllowThreads(__tstate);
25613 if (PyErr_Occurred()) SWIG_fail;
25614 }
25615 Py_INCREF(Py_None); resultobj = Py_None;
25616 return resultobj;
25617 fail:
25618 return NULL;
25619 }
25620
25621
25622 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25623 PyObject *resultobj;
25624 wxWindow *arg1 = (wxWindow *) 0 ;
25625 int arg2 ;
25626 int arg3 ;
25627 PyObject * obj0 = 0 ;
25628 PyObject * obj1 = 0 ;
25629 PyObject * obj2 = 0 ;
25630 char *kwnames[] = {
25631 (char *) "self",(char *) "width",(char *) "height", NULL
25632 };
25633
25634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25636 if (SWIG_arg_fail(1)) SWIG_fail;
25637 {
25638 arg2 = (int)(SWIG_As_int(obj1));
25639 if (SWIG_arg_fail(2)) SWIG_fail;
25640 }
25641 {
25642 arg3 = (int)(SWIG_As_int(obj2));
25643 if (SWIG_arg_fail(3)) SWIG_fail;
25644 }
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 (arg1)->SetClientSize(arg2,arg3);
25648
25649 wxPyEndAllowThreads(__tstate);
25650 if (PyErr_Occurred()) SWIG_fail;
25651 }
25652 Py_INCREF(Py_None); resultobj = Py_None;
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25660 PyObject *resultobj;
25661 wxWindow *arg1 = (wxWindow *) 0 ;
25662 wxRect *arg2 = 0 ;
25663 wxRect temp2 ;
25664 PyObject * obj0 = 0 ;
25665 PyObject * obj1 = 0 ;
25666 char *kwnames[] = {
25667 (char *) "self",(char *) "rect", NULL
25668 };
25669
25670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25672 if (SWIG_arg_fail(1)) SWIG_fail;
25673 {
25674 arg2 = &temp2;
25675 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25676 }
25677 {
25678 PyThreadState* __tstate = wxPyBeginAllowThreads();
25679 (arg1)->SetClientSize((wxRect const &)*arg2);
25680
25681 wxPyEndAllowThreads(__tstate);
25682 if (PyErr_Occurred()) SWIG_fail;
25683 }
25684 Py_INCREF(Py_None); resultobj = Py_None;
25685 return resultobj;
25686 fail:
25687 return NULL;
25688 }
25689
25690
25691 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25692 PyObject *resultobj;
25693 wxWindow *arg1 = (wxWindow *) 0 ;
25694 wxPoint result;
25695 PyObject * obj0 = 0 ;
25696 char *kwnames[] = {
25697 (char *) "self", NULL
25698 };
25699
25700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25702 if (SWIG_arg_fail(1)) SWIG_fail;
25703 {
25704 PyThreadState* __tstate = wxPyBeginAllowThreads();
25705 result = (arg1)->GetPosition();
25706
25707 wxPyEndAllowThreads(__tstate);
25708 if (PyErr_Occurred()) SWIG_fail;
25709 }
25710 {
25711 wxPoint * resultptr;
25712 resultptr = new wxPoint((wxPoint &)(result));
25713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25714 }
25715 return resultobj;
25716 fail:
25717 return NULL;
25718 }
25719
25720
25721 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25722 PyObject *resultobj;
25723 wxWindow *arg1 = (wxWindow *) 0 ;
25724 int *arg2 = (int *) 0 ;
25725 int *arg3 = (int *) 0 ;
25726 int temp2 ;
25727 int res2 = 0 ;
25728 int temp3 ;
25729 int res3 = 0 ;
25730 PyObject * obj0 = 0 ;
25731 char *kwnames[] = {
25732 (char *) "self", NULL
25733 };
25734
25735 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25736 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25739 if (SWIG_arg_fail(1)) SWIG_fail;
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 (arg1)->GetPosition(arg2,arg3);
25743
25744 wxPyEndAllowThreads(__tstate);
25745 if (PyErr_Occurred()) SWIG_fail;
25746 }
25747 Py_INCREF(Py_None); resultobj = Py_None;
25748 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25749 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25750 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25751 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25752 return resultobj;
25753 fail:
25754 return NULL;
25755 }
25756
25757
25758 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25759 PyObject *resultobj;
25760 wxWindow *arg1 = (wxWindow *) 0 ;
25761 wxSize result;
25762 PyObject * obj0 = 0 ;
25763 char *kwnames[] = {
25764 (char *) "self", NULL
25765 };
25766
25767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25769 if (SWIG_arg_fail(1)) SWIG_fail;
25770 {
25771 PyThreadState* __tstate = wxPyBeginAllowThreads();
25772 result = ((wxWindow const *)arg1)->GetSize();
25773
25774 wxPyEndAllowThreads(__tstate);
25775 if (PyErr_Occurred()) SWIG_fail;
25776 }
25777 {
25778 wxSize * resultptr;
25779 resultptr = new wxSize((wxSize &)(result));
25780 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25781 }
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25789 PyObject *resultobj;
25790 wxWindow *arg1 = (wxWindow *) 0 ;
25791 int *arg2 = (int *) 0 ;
25792 int *arg3 = (int *) 0 ;
25793 int temp2 ;
25794 int res2 = 0 ;
25795 int temp3 ;
25796 int res3 = 0 ;
25797 PyObject * obj0 = 0 ;
25798 char *kwnames[] = {
25799 (char *) "self", NULL
25800 };
25801
25802 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25803 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25806 if (SWIG_arg_fail(1)) SWIG_fail;
25807 {
25808 PyThreadState* __tstate = wxPyBeginAllowThreads();
25809 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25810
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 Py_INCREF(Py_None); resultobj = Py_None;
25815 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25816 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25817 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25818 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25819 return resultobj;
25820 fail:
25821 return NULL;
25822 }
25823
25824
25825 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25826 PyObject *resultobj;
25827 wxWindow *arg1 = (wxWindow *) 0 ;
25828 wxRect result;
25829 PyObject * obj0 = 0 ;
25830 char *kwnames[] = {
25831 (char *) "self", NULL
25832 };
25833
25834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25836 if (SWIG_arg_fail(1)) SWIG_fail;
25837 {
25838 PyThreadState* __tstate = wxPyBeginAllowThreads();
25839 result = ((wxWindow const *)arg1)->GetRect();
25840
25841 wxPyEndAllowThreads(__tstate);
25842 if (PyErr_Occurred()) SWIG_fail;
25843 }
25844 {
25845 wxRect * resultptr;
25846 resultptr = new wxRect((wxRect &)(result));
25847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25848 }
25849 return resultobj;
25850 fail:
25851 return NULL;
25852 }
25853
25854
25855 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25856 PyObject *resultobj;
25857 wxWindow *arg1 = (wxWindow *) 0 ;
25858 wxSize result;
25859 PyObject * obj0 = 0 ;
25860 char *kwnames[] = {
25861 (char *) "self", NULL
25862 };
25863
25864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25866 if (SWIG_arg_fail(1)) SWIG_fail;
25867 {
25868 PyThreadState* __tstate = wxPyBeginAllowThreads();
25869 result = ((wxWindow const *)arg1)->GetClientSize();
25870
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 {
25875 wxSize * resultptr;
25876 resultptr = new wxSize((wxSize &)(result));
25877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25878 }
25879 return resultobj;
25880 fail:
25881 return NULL;
25882 }
25883
25884
25885 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25886 PyObject *resultobj;
25887 wxWindow *arg1 = (wxWindow *) 0 ;
25888 int *arg2 = (int *) 0 ;
25889 int *arg3 = (int *) 0 ;
25890 int temp2 ;
25891 int res2 = 0 ;
25892 int temp3 ;
25893 int res3 = 0 ;
25894 PyObject * obj0 = 0 ;
25895 char *kwnames[] = {
25896 (char *) "self", NULL
25897 };
25898
25899 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25900 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25903 if (SWIG_arg_fail(1)) SWIG_fail;
25904 {
25905 PyThreadState* __tstate = wxPyBeginAllowThreads();
25906 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25907
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 Py_INCREF(Py_None); resultobj = Py_None;
25912 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25913 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25914 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25915 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25916 return resultobj;
25917 fail:
25918 return NULL;
25919 }
25920
25921
25922 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25923 PyObject *resultobj;
25924 wxWindow *arg1 = (wxWindow *) 0 ;
25925 wxPoint result;
25926 PyObject * obj0 = 0 ;
25927 char *kwnames[] = {
25928 (char *) "self", NULL
25929 };
25930
25931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25933 if (SWIG_arg_fail(1)) SWIG_fail;
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25937
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 {
25942 wxPoint * resultptr;
25943 resultptr = new wxPoint((wxPoint &)(result));
25944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25945 }
25946 return resultobj;
25947 fail:
25948 return NULL;
25949 }
25950
25951
25952 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25953 PyObject *resultobj;
25954 wxWindow *arg1 = (wxWindow *) 0 ;
25955 wxRect result;
25956 PyObject * obj0 = 0 ;
25957 char *kwnames[] = {
25958 (char *) "self", NULL
25959 };
25960
25961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25963 if (SWIG_arg_fail(1)) SWIG_fail;
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 result = ((wxWindow const *)arg1)->GetClientRect();
25967
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 {
25972 wxRect * resultptr;
25973 resultptr = new wxRect((wxRect &)(result));
25974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25975 }
25976 return resultobj;
25977 fail:
25978 return NULL;
25979 }
25980
25981
25982 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25983 PyObject *resultobj;
25984 wxWindow *arg1 = (wxWindow *) 0 ;
25985 wxSize result;
25986 PyObject * obj0 = 0 ;
25987 char *kwnames[] = {
25988 (char *) "self", NULL
25989 };
25990
25991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25993 if (SWIG_arg_fail(1)) SWIG_fail;
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 result = ((wxWindow const *)arg1)->GetBestSize();
25997
25998 wxPyEndAllowThreads(__tstate);
25999 if (PyErr_Occurred()) SWIG_fail;
26000 }
26001 {
26002 wxSize * resultptr;
26003 resultptr = new wxSize((wxSize &)(result));
26004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26005 }
26006 return resultobj;
26007 fail:
26008 return NULL;
26009 }
26010
26011
26012 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26013 PyObject *resultobj;
26014 wxWindow *arg1 = (wxWindow *) 0 ;
26015 int *arg2 = (int *) 0 ;
26016 int *arg3 = (int *) 0 ;
26017 int temp2 ;
26018 int res2 = 0 ;
26019 int temp3 ;
26020 int res3 = 0 ;
26021 PyObject * obj0 = 0 ;
26022 char *kwnames[] = {
26023 (char *) "self", NULL
26024 };
26025
26026 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26027 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26030 if (SWIG_arg_fail(1)) SWIG_fail;
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26034
26035 wxPyEndAllowThreads(__tstate);
26036 if (PyErr_Occurred()) SWIG_fail;
26037 }
26038 Py_INCREF(Py_None); resultobj = Py_None;
26039 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26040 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26041 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26042 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26043 return resultobj;
26044 fail:
26045 return NULL;
26046 }
26047
26048
26049 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26050 PyObject *resultobj;
26051 wxWindow *arg1 = (wxWindow *) 0 ;
26052 PyObject * obj0 = 0 ;
26053 char *kwnames[] = {
26054 (char *) "self", NULL
26055 };
26056
26057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26062 (arg1)->InvalidateBestSize();
26063
26064 wxPyEndAllowThreads(__tstate);
26065 if (PyErr_Occurred()) SWIG_fail;
26066 }
26067 Py_INCREF(Py_None); resultobj = Py_None;
26068 return resultobj;
26069 fail:
26070 return NULL;
26071 }
26072
26073
26074 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26075 PyObject *resultobj;
26076 wxWindow *arg1 = (wxWindow *) 0 ;
26077 wxSize result;
26078 PyObject * obj0 = 0 ;
26079 char *kwnames[] = {
26080 (char *) "self", NULL
26081 };
26082
26083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26085 if (SWIG_arg_fail(1)) SWIG_fail;
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26089
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 {
26094 wxSize * resultptr;
26095 resultptr = new wxSize((wxSize &)(result));
26096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26097 }
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26105 PyObject *resultobj;
26106 wxWindow *arg1 = (wxWindow *) 0 ;
26107 wxSize result;
26108 PyObject * obj0 = 0 ;
26109 char *kwnames[] = {
26110 (char *) "self", NULL
26111 };
26112
26113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26115 if (SWIG_arg_fail(1)) SWIG_fail;
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26119
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 {
26124 wxSize * resultptr;
26125 resultptr = new wxSize((wxSize &)(result));
26126 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26127 }
26128 return resultobj;
26129 fail:
26130 return NULL;
26131 }
26132
26133
26134 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26135 PyObject *resultobj;
26136 wxWindow *arg1 = (wxWindow *) 0 ;
26137 int arg2 = (int) wxBOTH ;
26138 PyObject * obj0 = 0 ;
26139 PyObject * obj1 = 0 ;
26140 char *kwnames[] = {
26141 (char *) "self",(char *) "direction", NULL
26142 };
26143
26144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26146 if (SWIG_arg_fail(1)) SWIG_fail;
26147 if (obj1) {
26148 {
26149 arg2 = (int)(SWIG_As_int(obj1));
26150 if (SWIG_arg_fail(2)) SWIG_fail;
26151 }
26152 }
26153 {
26154 PyThreadState* __tstate = wxPyBeginAllowThreads();
26155 (arg1)->Center(arg2);
26156
26157 wxPyEndAllowThreads(__tstate);
26158 if (PyErr_Occurred()) SWIG_fail;
26159 }
26160 Py_INCREF(Py_None); resultobj = Py_None;
26161 return resultobj;
26162 fail:
26163 return NULL;
26164 }
26165
26166
26167 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26168 PyObject *resultobj;
26169 wxWindow *arg1 = (wxWindow *) 0 ;
26170 int arg2 = (int) wxBOTH ;
26171 PyObject * obj0 = 0 ;
26172 PyObject * obj1 = 0 ;
26173 char *kwnames[] = {
26174 (char *) "self",(char *) "dir", NULL
26175 };
26176
26177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26179 if (SWIG_arg_fail(1)) SWIG_fail;
26180 if (obj1) {
26181 {
26182 arg2 = (int)(SWIG_As_int(obj1));
26183 if (SWIG_arg_fail(2)) SWIG_fail;
26184 }
26185 }
26186 {
26187 PyThreadState* __tstate = wxPyBeginAllowThreads();
26188 (arg1)->CenterOnScreen(arg2);
26189
26190 wxPyEndAllowThreads(__tstate);
26191 if (PyErr_Occurred()) SWIG_fail;
26192 }
26193 Py_INCREF(Py_None); resultobj = Py_None;
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj;
26202 wxWindow *arg1 = (wxWindow *) 0 ;
26203 int arg2 = (int) wxBOTH ;
26204 PyObject * obj0 = 0 ;
26205 PyObject * obj1 = 0 ;
26206 char *kwnames[] = {
26207 (char *) "self",(char *) "dir", NULL
26208 };
26209
26210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26212 if (SWIG_arg_fail(1)) SWIG_fail;
26213 if (obj1) {
26214 {
26215 arg2 = (int)(SWIG_As_int(obj1));
26216 if (SWIG_arg_fail(2)) SWIG_fail;
26217 }
26218 }
26219 {
26220 PyThreadState* __tstate = wxPyBeginAllowThreads();
26221 (arg1)->CenterOnParent(arg2);
26222
26223 wxPyEndAllowThreads(__tstate);
26224 if (PyErr_Occurred()) SWIG_fail;
26225 }
26226 Py_INCREF(Py_None); resultobj = Py_None;
26227 return resultobj;
26228 fail:
26229 return NULL;
26230 }
26231
26232
26233 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26234 PyObject *resultobj;
26235 wxWindow *arg1 = (wxWindow *) 0 ;
26236 PyObject * obj0 = 0 ;
26237 char *kwnames[] = {
26238 (char *) "self", NULL
26239 };
26240
26241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26243 if (SWIG_arg_fail(1)) SWIG_fail;
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 (arg1)->Fit();
26247
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 Py_INCREF(Py_None); resultobj = Py_None;
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26259 PyObject *resultobj;
26260 wxWindow *arg1 = (wxWindow *) 0 ;
26261 PyObject * obj0 = 0 ;
26262 char *kwnames[] = {
26263 (char *) "self", NULL
26264 };
26265
26266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26268 if (SWIG_arg_fail(1)) SWIG_fail;
26269 {
26270 PyThreadState* __tstate = wxPyBeginAllowThreads();
26271 (arg1)->FitInside();
26272
26273 wxPyEndAllowThreads(__tstate);
26274 if (PyErr_Occurred()) SWIG_fail;
26275 }
26276 Py_INCREF(Py_None); resultobj = Py_None;
26277 return resultobj;
26278 fail:
26279 return NULL;
26280 }
26281
26282
26283 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26284 PyObject *resultobj;
26285 wxWindow *arg1 = (wxWindow *) 0 ;
26286 int arg2 ;
26287 int arg3 ;
26288 int arg4 = (int) -1 ;
26289 int arg5 = (int) -1 ;
26290 int arg6 = (int) -1 ;
26291 int arg7 = (int) -1 ;
26292 PyObject * obj0 = 0 ;
26293 PyObject * obj1 = 0 ;
26294 PyObject * obj2 = 0 ;
26295 PyObject * obj3 = 0 ;
26296 PyObject * obj4 = 0 ;
26297 PyObject * obj5 = 0 ;
26298 PyObject * obj6 = 0 ;
26299 char *kwnames[] = {
26300 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26301 };
26302
26303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26305 if (SWIG_arg_fail(1)) SWIG_fail;
26306 {
26307 arg2 = (int)(SWIG_As_int(obj1));
26308 if (SWIG_arg_fail(2)) SWIG_fail;
26309 }
26310 {
26311 arg3 = (int)(SWIG_As_int(obj2));
26312 if (SWIG_arg_fail(3)) SWIG_fail;
26313 }
26314 if (obj3) {
26315 {
26316 arg4 = (int)(SWIG_As_int(obj3));
26317 if (SWIG_arg_fail(4)) SWIG_fail;
26318 }
26319 }
26320 if (obj4) {
26321 {
26322 arg5 = (int)(SWIG_As_int(obj4));
26323 if (SWIG_arg_fail(5)) SWIG_fail;
26324 }
26325 }
26326 if (obj5) {
26327 {
26328 arg6 = (int)(SWIG_As_int(obj5));
26329 if (SWIG_arg_fail(6)) SWIG_fail;
26330 }
26331 }
26332 if (obj6) {
26333 {
26334 arg7 = (int)(SWIG_As_int(obj6));
26335 if (SWIG_arg_fail(7)) SWIG_fail;
26336 }
26337 }
26338 {
26339 PyThreadState* __tstate = wxPyBeginAllowThreads();
26340 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26341
26342 wxPyEndAllowThreads(__tstate);
26343 if (PyErr_Occurred()) SWIG_fail;
26344 }
26345 Py_INCREF(Py_None); resultobj = Py_None;
26346 return resultobj;
26347 fail:
26348 return NULL;
26349 }
26350
26351
26352 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26353 PyObject *resultobj;
26354 wxWindow *arg1 = (wxWindow *) 0 ;
26355 wxSize *arg2 = 0 ;
26356 wxSize const &arg3_defvalue = wxDefaultSize ;
26357 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26358 wxSize const &arg4_defvalue = wxDefaultSize ;
26359 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26360 wxSize temp2 ;
26361 wxSize temp3 ;
26362 wxSize temp4 ;
26363 PyObject * obj0 = 0 ;
26364 PyObject * obj1 = 0 ;
26365 PyObject * obj2 = 0 ;
26366 PyObject * obj3 = 0 ;
26367 char *kwnames[] = {
26368 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26369 };
26370
26371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26373 if (SWIG_arg_fail(1)) SWIG_fail;
26374 {
26375 arg2 = &temp2;
26376 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26377 }
26378 if (obj2) {
26379 {
26380 arg3 = &temp3;
26381 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26382 }
26383 }
26384 if (obj3) {
26385 {
26386 arg4 = &temp4;
26387 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26388 }
26389 }
26390 {
26391 PyThreadState* __tstate = wxPyBeginAllowThreads();
26392 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26393
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 Py_INCREF(Py_None); resultobj = Py_None;
26398 return resultobj;
26399 fail:
26400 return NULL;
26401 }
26402
26403
26404 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26405 PyObject *resultobj;
26406 wxWindow *arg1 = (wxWindow *) 0 ;
26407 int arg2 ;
26408 int arg3 ;
26409 int arg4 = (int) -1 ;
26410 int arg5 = (int) -1 ;
26411 PyObject * obj0 = 0 ;
26412 PyObject * obj1 = 0 ;
26413 PyObject * obj2 = 0 ;
26414 PyObject * obj3 = 0 ;
26415 PyObject * obj4 = 0 ;
26416 char *kwnames[] = {
26417 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26418 };
26419
26420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26422 if (SWIG_arg_fail(1)) SWIG_fail;
26423 {
26424 arg2 = (int)(SWIG_As_int(obj1));
26425 if (SWIG_arg_fail(2)) SWIG_fail;
26426 }
26427 {
26428 arg3 = (int)(SWIG_As_int(obj2));
26429 if (SWIG_arg_fail(3)) SWIG_fail;
26430 }
26431 if (obj3) {
26432 {
26433 arg4 = (int)(SWIG_As_int(obj3));
26434 if (SWIG_arg_fail(4)) SWIG_fail;
26435 }
26436 }
26437 if (obj4) {
26438 {
26439 arg5 = (int)(SWIG_As_int(obj4));
26440 if (SWIG_arg_fail(5)) SWIG_fail;
26441 }
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 Py_INCREF(Py_None); resultobj = Py_None;
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxWindow *arg1 = (wxWindow *) 0 ;
26460 wxSize *arg2 = 0 ;
26461 wxSize const &arg3_defvalue = wxDefaultSize ;
26462 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26463 wxSize temp2 ;
26464 wxSize temp3 ;
26465 PyObject * obj0 = 0 ;
26466 PyObject * obj1 = 0 ;
26467 PyObject * obj2 = 0 ;
26468 char *kwnames[] = {
26469 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26470 };
26471
26472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26474 if (SWIG_arg_fail(1)) SWIG_fail;
26475 {
26476 arg2 = &temp2;
26477 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26478 }
26479 if (obj2) {
26480 {
26481 arg3 = &temp3;
26482 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26483 }
26484 }
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26488
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 Py_INCREF(Py_None); resultobj = Py_None;
26493 return resultobj;
26494 fail:
26495 return NULL;
26496 }
26497
26498
26499 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26500 PyObject *resultobj;
26501 wxWindow *arg1 = (wxWindow *) 0 ;
26502 wxSize result;
26503 PyObject * obj0 = 0 ;
26504 char *kwnames[] = {
26505 (char *) "self", NULL
26506 };
26507
26508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26510 if (SWIG_arg_fail(1)) SWIG_fail;
26511 {
26512 PyThreadState* __tstate = wxPyBeginAllowThreads();
26513 result = ((wxWindow const *)arg1)->GetMaxSize();
26514
26515 wxPyEndAllowThreads(__tstate);
26516 if (PyErr_Occurred()) SWIG_fail;
26517 }
26518 {
26519 wxSize * resultptr;
26520 resultptr = new wxSize((wxSize &)(result));
26521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26522 }
26523 return resultobj;
26524 fail:
26525 return NULL;
26526 }
26527
26528
26529 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26530 PyObject *resultobj;
26531 wxWindow *arg1 = (wxWindow *) 0 ;
26532 wxSize result;
26533 PyObject * obj0 = 0 ;
26534 char *kwnames[] = {
26535 (char *) "self", NULL
26536 };
26537
26538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26540 if (SWIG_arg_fail(1)) SWIG_fail;
26541 {
26542 PyThreadState* __tstate = wxPyBeginAllowThreads();
26543 result = ((wxWindow const *)arg1)->GetMinSize();
26544
26545 wxPyEndAllowThreads(__tstate);
26546 if (PyErr_Occurred()) SWIG_fail;
26547 }
26548 {
26549 wxSize * resultptr;
26550 resultptr = new wxSize((wxSize &)(result));
26551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26552 }
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj;
26561 wxWindow *arg1 = (wxWindow *) 0 ;
26562 wxSize *arg2 = 0 ;
26563 wxSize temp2 ;
26564 PyObject * obj0 = 0 ;
26565 PyObject * obj1 = 0 ;
26566 char *kwnames[] = {
26567 (char *) "self",(char *) "minSize", NULL
26568 };
26569
26570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26572 if (SWIG_arg_fail(1)) SWIG_fail;
26573 {
26574 arg2 = &temp2;
26575 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26576 }
26577 {
26578 PyThreadState* __tstate = wxPyBeginAllowThreads();
26579 (arg1)->SetMinSize((wxSize const &)*arg2);
26580
26581 wxPyEndAllowThreads(__tstate);
26582 if (PyErr_Occurred()) SWIG_fail;
26583 }
26584 Py_INCREF(Py_None); resultobj = Py_None;
26585 return resultobj;
26586 fail:
26587 return NULL;
26588 }
26589
26590
26591 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26592 PyObject *resultobj;
26593 wxWindow *arg1 = (wxWindow *) 0 ;
26594 wxSize *arg2 = 0 ;
26595 wxSize temp2 ;
26596 PyObject * obj0 = 0 ;
26597 PyObject * obj1 = 0 ;
26598 char *kwnames[] = {
26599 (char *) "self",(char *) "maxSize", NULL
26600 };
26601
26602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26604 if (SWIG_arg_fail(1)) SWIG_fail;
26605 {
26606 arg2 = &temp2;
26607 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26608 }
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 (arg1)->SetMaxSize((wxSize const &)*arg2);
26612
26613 wxPyEndAllowThreads(__tstate);
26614 if (PyErr_Occurred()) SWIG_fail;
26615 }
26616 Py_INCREF(Py_None); resultobj = Py_None;
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26624 PyObject *resultobj;
26625 wxWindow *arg1 = (wxWindow *) 0 ;
26626 int result;
26627 PyObject * obj0 = 0 ;
26628 char *kwnames[] = {
26629 (char *) "self", NULL
26630 };
26631
26632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) 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 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26638
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 {
26643 resultobj = SWIG_From_int((int)(result));
26644 }
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26652 PyObject *resultobj;
26653 wxWindow *arg1 = (wxWindow *) 0 ;
26654 int result;
26655 PyObject * obj0 = 0 ;
26656 char *kwnames[] = {
26657 (char *) "self", NULL
26658 };
26659
26660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26662 if (SWIG_arg_fail(1)) SWIG_fail;
26663 {
26664 PyThreadState* __tstate = wxPyBeginAllowThreads();
26665 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26666
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 {
26671 resultobj = SWIG_From_int((int)(result));
26672 }
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj;
26681 wxWindow *arg1 = (wxWindow *) 0 ;
26682 int result;
26683 PyObject * obj0 = 0 ;
26684 char *kwnames[] = {
26685 (char *) "self", NULL
26686 };
26687
26688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26690 if (SWIG_arg_fail(1)) SWIG_fail;
26691 {
26692 PyThreadState* __tstate = wxPyBeginAllowThreads();
26693 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26694
26695 wxPyEndAllowThreads(__tstate);
26696 if (PyErr_Occurred()) SWIG_fail;
26697 }
26698 {
26699 resultobj = SWIG_From_int((int)(result));
26700 }
26701 return resultobj;
26702 fail:
26703 return NULL;
26704 }
26705
26706
26707 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26708 PyObject *resultobj;
26709 wxWindow *arg1 = (wxWindow *) 0 ;
26710 int result;
26711 PyObject * obj0 = 0 ;
26712 char *kwnames[] = {
26713 (char *) "self", NULL
26714 };
26715
26716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26718 if (SWIG_arg_fail(1)) SWIG_fail;
26719 {
26720 PyThreadState* __tstate = wxPyBeginAllowThreads();
26721 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26722
26723 wxPyEndAllowThreads(__tstate);
26724 if (PyErr_Occurred()) SWIG_fail;
26725 }
26726 {
26727 resultobj = SWIG_From_int((int)(result));
26728 }
26729 return resultobj;
26730 fail:
26731 return NULL;
26732 }
26733
26734
26735 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26736 PyObject *resultobj;
26737 wxWindow *arg1 = (wxWindow *) 0 ;
26738 wxSize *arg2 = 0 ;
26739 wxSize temp2 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char *kwnames[] = {
26743 (char *) "self",(char *) "size", NULL
26744 };
26745
26746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26748 if (SWIG_arg_fail(1)) SWIG_fail;
26749 {
26750 arg2 = &temp2;
26751 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26752 }
26753 {
26754 PyThreadState* __tstate = wxPyBeginAllowThreads();
26755 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26756
26757 wxPyEndAllowThreads(__tstate);
26758 if (PyErr_Occurred()) SWIG_fail;
26759 }
26760 Py_INCREF(Py_None); resultobj = Py_None;
26761 return resultobj;
26762 fail:
26763 return NULL;
26764 }
26765
26766
26767 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26768 PyObject *resultobj;
26769 wxWindow *arg1 = (wxWindow *) 0 ;
26770 int arg2 ;
26771 int arg3 ;
26772 PyObject * obj0 = 0 ;
26773 PyObject * obj1 = 0 ;
26774 PyObject * obj2 = 0 ;
26775 char *kwnames[] = {
26776 (char *) "self",(char *) "w",(char *) "h", NULL
26777 };
26778
26779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26781 if (SWIG_arg_fail(1)) SWIG_fail;
26782 {
26783 arg2 = (int)(SWIG_As_int(obj1));
26784 if (SWIG_arg_fail(2)) SWIG_fail;
26785 }
26786 {
26787 arg3 = (int)(SWIG_As_int(obj2));
26788 if (SWIG_arg_fail(3)) SWIG_fail;
26789 }
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 (arg1)->SetVirtualSize(arg2,arg3);
26793
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 Py_INCREF(Py_None); resultobj = Py_None;
26798 return resultobj;
26799 fail:
26800 return NULL;
26801 }
26802
26803
26804 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26805 PyObject *resultobj;
26806 wxWindow *arg1 = (wxWindow *) 0 ;
26807 wxSize result;
26808 PyObject * obj0 = 0 ;
26809 char *kwnames[] = {
26810 (char *) "self", NULL
26811 };
26812
26813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26815 if (SWIG_arg_fail(1)) SWIG_fail;
26816 {
26817 PyThreadState* __tstate = wxPyBeginAllowThreads();
26818 result = ((wxWindow const *)arg1)->GetVirtualSize();
26819
26820 wxPyEndAllowThreads(__tstate);
26821 if (PyErr_Occurred()) SWIG_fail;
26822 }
26823 {
26824 wxSize * resultptr;
26825 resultptr = new wxSize((wxSize &)(result));
26826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26827 }
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj;
26836 wxWindow *arg1 = (wxWindow *) 0 ;
26837 int *arg2 = (int *) 0 ;
26838 int *arg3 = (int *) 0 ;
26839 int temp2 ;
26840 int res2 = 0 ;
26841 int temp3 ;
26842 int res3 = 0 ;
26843 PyObject * obj0 = 0 ;
26844 char *kwnames[] = {
26845 (char *) "self", NULL
26846 };
26847
26848 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26849 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26852 if (SWIG_arg_fail(1)) SWIG_fail;
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26856
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 Py_INCREF(Py_None); resultobj = Py_None;
26861 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26862 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26863 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26864 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26872 PyObject *resultobj;
26873 wxWindow *arg1 = (wxWindow *) 0 ;
26874 wxSize result;
26875 PyObject * obj0 = 0 ;
26876 char *kwnames[] = {
26877 (char *) "self", NULL
26878 };
26879
26880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26882 if (SWIG_arg_fail(1)) SWIG_fail;
26883 {
26884 PyThreadState* __tstate = wxPyBeginAllowThreads();
26885 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26886
26887 wxPyEndAllowThreads(__tstate);
26888 if (PyErr_Occurred()) SWIG_fail;
26889 }
26890 {
26891 wxSize * resultptr;
26892 resultptr = new wxSize((wxSize &)(result));
26893 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26894 }
26895 return resultobj;
26896 fail:
26897 return NULL;
26898 }
26899
26900
26901 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26902 PyObject *resultobj;
26903 wxWindow *arg1 = (wxWindow *) 0 ;
26904 bool arg2 = (bool) true ;
26905 bool result;
26906 PyObject * obj0 = 0 ;
26907 PyObject * obj1 = 0 ;
26908 char *kwnames[] = {
26909 (char *) "self",(char *) "show", NULL
26910 };
26911
26912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26914 if (SWIG_arg_fail(1)) SWIG_fail;
26915 if (obj1) {
26916 {
26917 arg2 = (bool)(SWIG_As_bool(obj1));
26918 if (SWIG_arg_fail(2)) SWIG_fail;
26919 }
26920 }
26921 {
26922 PyThreadState* __tstate = wxPyBeginAllowThreads();
26923 result = (bool)(arg1)->Show(arg2);
26924
26925 wxPyEndAllowThreads(__tstate);
26926 if (PyErr_Occurred()) SWIG_fail;
26927 }
26928 {
26929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26930 }
26931 return resultobj;
26932 fail:
26933 return NULL;
26934 }
26935
26936
26937 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26938 PyObject *resultobj;
26939 wxWindow *arg1 = (wxWindow *) 0 ;
26940 bool result;
26941 PyObject * obj0 = 0 ;
26942 char *kwnames[] = {
26943 (char *) "self", NULL
26944 };
26945
26946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26948 if (SWIG_arg_fail(1)) SWIG_fail;
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = (bool)(arg1)->Hide();
26952
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 {
26957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26958 }
26959 return resultobj;
26960 fail:
26961 return NULL;
26962 }
26963
26964
26965 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26966 PyObject *resultobj;
26967 wxWindow *arg1 = (wxWindow *) 0 ;
26968 bool arg2 = (bool) true ;
26969 bool result;
26970 PyObject * obj0 = 0 ;
26971 PyObject * obj1 = 0 ;
26972 char *kwnames[] = {
26973 (char *) "self",(char *) "enable", NULL
26974 };
26975
26976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26978 if (SWIG_arg_fail(1)) SWIG_fail;
26979 if (obj1) {
26980 {
26981 arg2 = (bool)(SWIG_As_bool(obj1));
26982 if (SWIG_arg_fail(2)) SWIG_fail;
26983 }
26984 }
26985 {
26986 PyThreadState* __tstate = wxPyBeginAllowThreads();
26987 result = (bool)(arg1)->Enable(arg2);
26988
26989 wxPyEndAllowThreads(__tstate);
26990 if (PyErr_Occurred()) SWIG_fail;
26991 }
26992 {
26993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26994 }
26995 return resultobj;
26996 fail:
26997 return NULL;
26998 }
26999
27000
27001 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27002 PyObject *resultobj;
27003 wxWindow *arg1 = (wxWindow *) 0 ;
27004 bool result;
27005 PyObject * obj0 = 0 ;
27006 char *kwnames[] = {
27007 (char *) "self", NULL
27008 };
27009
27010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27012 if (SWIG_arg_fail(1)) SWIG_fail;
27013 {
27014 PyThreadState* __tstate = wxPyBeginAllowThreads();
27015 result = (bool)(arg1)->Disable();
27016
27017 wxPyEndAllowThreads(__tstate);
27018 if (PyErr_Occurred()) SWIG_fail;
27019 }
27020 {
27021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27022 }
27023 return resultobj;
27024 fail:
27025 return NULL;
27026 }
27027
27028
27029 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27030 PyObject *resultobj;
27031 wxWindow *arg1 = (wxWindow *) 0 ;
27032 bool result;
27033 PyObject * obj0 = 0 ;
27034 char *kwnames[] = {
27035 (char *) "self", NULL
27036 };
27037
27038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27040 if (SWIG_arg_fail(1)) SWIG_fail;
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 result = (bool)((wxWindow const *)arg1)->IsShown();
27044
27045 wxPyEndAllowThreads(__tstate);
27046 if (PyErr_Occurred()) SWIG_fail;
27047 }
27048 {
27049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27050 }
27051 return resultobj;
27052 fail:
27053 return NULL;
27054 }
27055
27056
27057 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27058 PyObject *resultobj;
27059 wxWindow *arg1 = (wxWindow *) 0 ;
27060 bool result;
27061 PyObject * obj0 = 0 ;
27062 char *kwnames[] = {
27063 (char *) "self", NULL
27064 };
27065
27066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27068 if (SWIG_arg_fail(1)) SWIG_fail;
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27072
27073 wxPyEndAllowThreads(__tstate);
27074 if (PyErr_Occurred()) SWIG_fail;
27075 }
27076 {
27077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27078 }
27079 return resultobj;
27080 fail:
27081 return NULL;
27082 }
27083
27084
27085 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27086 PyObject *resultobj;
27087 wxWindow *arg1 = (wxWindow *) 0 ;
27088 long arg2 ;
27089 PyObject * obj0 = 0 ;
27090 PyObject * obj1 = 0 ;
27091 char *kwnames[] = {
27092 (char *) "self",(char *) "style", NULL
27093 };
27094
27095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27097 if (SWIG_arg_fail(1)) SWIG_fail;
27098 {
27099 arg2 = (long)(SWIG_As_long(obj1));
27100 if (SWIG_arg_fail(2)) SWIG_fail;
27101 }
27102 {
27103 PyThreadState* __tstate = wxPyBeginAllowThreads();
27104 (arg1)->SetWindowStyleFlag(arg2);
27105
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 Py_INCREF(Py_None); resultobj = Py_None;
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27117 PyObject *resultobj;
27118 wxWindow *arg1 = (wxWindow *) 0 ;
27119 long result;
27120 PyObject * obj0 = 0 ;
27121 char *kwnames[] = {
27122 (char *) "self", NULL
27123 };
27124
27125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27127 if (SWIG_arg_fail(1)) SWIG_fail;
27128 {
27129 PyThreadState* __tstate = wxPyBeginAllowThreads();
27130 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27131
27132 wxPyEndAllowThreads(__tstate);
27133 if (PyErr_Occurred()) SWIG_fail;
27134 }
27135 {
27136 resultobj = SWIG_From_long((long)(result));
27137 }
27138 return resultobj;
27139 fail:
27140 return NULL;
27141 }
27142
27143
27144 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27145 PyObject *resultobj;
27146 wxWindow *arg1 = (wxWindow *) 0 ;
27147 int arg2 ;
27148 bool result;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char *kwnames[] = {
27152 (char *) "self",(char *) "flag", NULL
27153 };
27154
27155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27157 if (SWIG_arg_fail(1)) SWIG_fail;
27158 {
27159 arg2 = (int)(SWIG_As_int(obj1));
27160 if (SWIG_arg_fail(2)) SWIG_fail;
27161 }
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27165
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 {
27170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27171 }
27172 return resultobj;
27173 fail:
27174 return NULL;
27175 }
27176
27177
27178 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27179 PyObject *resultobj;
27180 wxWindow *arg1 = (wxWindow *) 0 ;
27181 bool result;
27182 PyObject * obj0 = 0 ;
27183 char *kwnames[] = {
27184 (char *) "self", NULL
27185 };
27186
27187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27189 if (SWIG_arg_fail(1)) SWIG_fail;
27190 {
27191 PyThreadState* __tstate = wxPyBeginAllowThreads();
27192 result = (bool)((wxWindow const *)arg1)->IsRetained();
27193
27194 wxPyEndAllowThreads(__tstate);
27195 if (PyErr_Occurred()) SWIG_fail;
27196 }
27197 {
27198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27199 }
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27207 PyObject *resultobj;
27208 wxWindow *arg1 = (wxWindow *) 0 ;
27209 long arg2 ;
27210 PyObject * obj0 = 0 ;
27211 PyObject * obj1 = 0 ;
27212 char *kwnames[] = {
27213 (char *) "self",(char *) "exStyle", NULL
27214 };
27215
27216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27218 if (SWIG_arg_fail(1)) SWIG_fail;
27219 {
27220 arg2 = (long)(SWIG_As_long(obj1));
27221 if (SWIG_arg_fail(2)) SWIG_fail;
27222 }
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 (arg1)->SetExtraStyle(arg2);
27226
27227 wxPyEndAllowThreads(__tstate);
27228 if (PyErr_Occurred()) SWIG_fail;
27229 }
27230 Py_INCREF(Py_None); resultobj = Py_None;
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj;
27239 wxWindow *arg1 = (wxWindow *) 0 ;
27240 long result;
27241 PyObject * obj0 = 0 ;
27242 char *kwnames[] = {
27243 (char *) "self", NULL
27244 };
27245
27246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27248 if (SWIG_arg_fail(1)) SWIG_fail;
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27252
27253 wxPyEndAllowThreads(__tstate);
27254 if (PyErr_Occurred()) SWIG_fail;
27255 }
27256 {
27257 resultobj = SWIG_From_long((long)(result));
27258 }
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27266 PyObject *resultobj;
27267 wxWindow *arg1 = (wxWindow *) 0 ;
27268 bool arg2 = (bool) true ;
27269 PyObject * obj0 = 0 ;
27270 PyObject * obj1 = 0 ;
27271 char *kwnames[] = {
27272 (char *) "self",(char *) "modal", NULL
27273 };
27274
27275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27277 if (SWIG_arg_fail(1)) SWIG_fail;
27278 if (obj1) {
27279 {
27280 arg2 = (bool)(SWIG_As_bool(obj1));
27281 if (SWIG_arg_fail(2)) SWIG_fail;
27282 }
27283 }
27284 {
27285 PyThreadState* __tstate = wxPyBeginAllowThreads();
27286 (arg1)->MakeModal(arg2);
27287
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 Py_INCREF(Py_None); resultobj = Py_None;
27292 return resultobj;
27293 fail:
27294 return NULL;
27295 }
27296
27297
27298 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27299 PyObject *resultobj;
27300 wxWindow *arg1 = (wxWindow *) 0 ;
27301 bool arg2 ;
27302 PyObject * obj0 = 0 ;
27303 PyObject * obj1 = 0 ;
27304 char *kwnames[] = {
27305 (char *) "self",(char *) "enableTheme", NULL
27306 };
27307
27308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27310 if (SWIG_arg_fail(1)) SWIG_fail;
27311 {
27312 arg2 = (bool)(SWIG_As_bool(obj1));
27313 if (SWIG_arg_fail(2)) SWIG_fail;
27314 }
27315 {
27316 PyThreadState* __tstate = wxPyBeginAllowThreads();
27317 (arg1)->SetThemeEnabled(arg2);
27318
27319 wxPyEndAllowThreads(__tstate);
27320 if (PyErr_Occurred()) SWIG_fail;
27321 }
27322 Py_INCREF(Py_None); resultobj = Py_None;
27323 return resultobj;
27324 fail:
27325 return NULL;
27326 }
27327
27328
27329 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27330 PyObject *resultobj;
27331 wxWindow *arg1 = (wxWindow *) 0 ;
27332 bool result;
27333 PyObject * obj0 = 0 ;
27334 char *kwnames[] = {
27335 (char *) "self", NULL
27336 };
27337
27338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",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 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27344
27345 wxPyEndAllowThreads(__tstate);
27346 if (PyErr_Occurred()) SWIG_fail;
27347 }
27348 {
27349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27350 }
27351 return resultobj;
27352 fail:
27353 return NULL;
27354 }
27355
27356
27357 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27358 PyObject *resultobj;
27359 wxWindow *arg1 = (wxWindow *) 0 ;
27360 PyObject * obj0 = 0 ;
27361 char *kwnames[] = {
27362 (char *) "self", NULL
27363 };
27364
27365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27367 if (SWIG_arg_fail(1)) SWIG_fail;
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 (arg1)->SetFocus();
27371
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 Py_INCREF(Py_None); resultobj = Py_None;
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27383 PyObject *resultobj;
27384 wxWindow *arg1 = (wxWindow *) 0 ;
27385 PyObject * obj0 = 0 ;
27386 char *kwnames[] = {
27387 (char *) "self", NULL
27388 };
27389
27390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27392 if (SWIG_arg_fail(1)) SWIG_fail;
27393 {
27394 PyThreadState* __tstate = wxPyBeginAllowThreads();
27395 (arg1)->SetFocusFromKbd();
27396
27397 wxPyEndAllowThreads(__tstate);
27398 if (PyErr_Occurred()) SWIG_fail;
27399 }
27400 Py_INCREF(Py_None); resultobj = Py_None;
27401 return resultobj;
27402 fail:
27403 return NULL;
27404 }
27405
27406
27407 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27408 PyObject *resultobj;
27409 wxWindow *result;
27410 char *kwnames[] = {
27411 NULL
27412 };
27413
27414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27415 {
27416 if (!wxPyCheckForApp()) SWIG_fail;
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 result = (wxWindow *)wxWindow::FindFocus();
27419
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 {
27424 resultobj = wxPyMake_wxObject(result, 0);
27425 }
27426 return resultobj;
27427 fail:
27428 return NULL;
27429 }
27430
27431
27432 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27433 PyObject *resultobj;
27434 wxWindow *arg1 = (wxWindow *) 0 ;
27435 bool result;
27436 PyObject * obj0 = 0 ;
27437 char *kwnames[] = {
27438 (char *) "self", NULL
27439 };
27440
27441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27443 if (SWIG_arg_fail(1)) SWIG_fail;
27444 {
27445 PyThreadState* __tstate = wxPyBeginAllowThreads();
27446 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27447
27448 wxPyEndAllowThreads(__tstate);
27449 if (PyErr_Occurred()) SWIG_fail;
27450 }
27451 {
27452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27453 }
27454 return resultobj;
27455 fail:
27456 return NULL;
27457 }
27458
27459
27460 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27461 PyObject *resultobj;
27462 wxWindow *arg1 = (wxWindow *) 0 ;
27463 bool result;
27464 PyObject * obj0 = 0 ;
27465 char *kwnames[] = {
27466 (char *) "self", NULL
27467 };
27468
27469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27471 if (SWIG_arg_fail(1)) SWIG_fail;
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27475
27476 wxPyEndAllowThreads(__tstate);
27477 if (PyErr_Occurred()) SWIG_fail;
27478 }
27479 {
27480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27481 }
27482 return resultobj;
27483 fail:
27484 return NULL;
27485 }
27486
27487
27488 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27489 PyObject *resultobj;
27490 wxWindow *arg1 = (wxWindow *) 0 ;
27491 wxWindow *result;
27492 PyObject * obj0 = 0 ;
27493 char *kwnames[] = {
27494 (char *) "self", NULL
27495 };
27496
27497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27499 if (SWIG_arg_fail(1)) SWIG_fail;
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27503
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 {
27508 resultobj = wxPyMake_wxObject(result, 0);
27509 }
27510 return resultobj;
27511 fail:
27512 return NULL;
27513 }
27514
27515
27516 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27517 PyObject *resultobj;
27518 wxWindow *arg1 = (wxWindow *) 0 ;
27519 wxWindow *arg2 = (wxWindow *) 0 ;
27520 wxWindow *result;
27521 PyObject * obj0 = 0 ;
27522 PyObject * obj1 = 0 ;
27523 char *kwnames[] = {
27524 (char *) "self",(char *) "child", NULL
27525 };
27526
27527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27529 if (SWIG_arg_fail(1)) SWIG_fail;
27530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27531 if (SWIG_arg_fail(2)) SWIG_fail;
27532 {
27533 PyThreadState* __tstate = wxPyBeginAllowThreads();
27534 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27535
27536 wxPyEndAllowThreads(__tstate);
27537 if (PyErr_Occurred()) SWIG_fail;
27538 }
27539 {
27540 resultobj = wxPyMake_wxObject(result, 0);
27541 }
27542 return resultobj;
27543 fail:
27544 return NULL;
27545 }
27546
27547
27548 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27549 PyObject *resultobj;
27550 wxWindow *arg1 = (wxWindow *) 0 ;
27551 wxWindow *arg2 = (wxWindow *) 0 ;
27552 PyObject * obj0 = 0 ;
27553 PyObject * obj1 = 0 ;
27554 char *kwnames[] = {
27555 (char *) "self",(char *) "win", NULL
27556 };
27557
27558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27560 if (SWIG_arg_fail(1)) SWIG_fail;
27561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27562 if (SWIG_arg_fail(2)) SWIG_fail;
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 (arg1)->SetTmpDefaultItem(arg2);
27566
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 Py_INCREF(Py_None); resultobj = Py_None;
27571 return resultobj;
27572 fail:
27573 return NULL;
27574 }
27575
27576
27577 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27578 PyObject *resultobj;
27579 wxWindow *arg1 = (wxWindow *) 0 ;
27580 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27581 bool result;
27582 PyObject * obj0 = 0 ;
27583 PyObject * obj1 = 0 ;
27584 char *kwnames[] = {
27585 (char *) "self",(char *) "flags", NULL
27586 };
27587
27588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27590 if (SWIG_arg_fail(1)) SWIG_fail;
27591 if (obj1) {
27592 {
27593 arg2 = (int)(SWIG_As_int(obj1));
27594 if (SWIG_arg_fail(2)) SWIG_fail;
27595 }
27596 }
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (bool)(arg1)->Navigate(arg2);
27600
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 {
27605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27606 }
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27614 PyObject *resultobj;
27615 wxWindow *arg1 = (wxWindow *) 0 ;
27616 wxWindow *arg2 = (wxWindow *) 0 ;
27617 PyObject * obj0 = 0 ;
27618 PyObject * obj1 = 0 ;
27619 char *kwnames[] = {
27620 (char *) "self",(char *) "win", NULL
27621 };
27622
27623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27625 if (SWIG_arg_fail(1)) SWIG_fail;
27626 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27627 if (SWIG_arg_fail(2)) SWIG_fail;
27628 {
27629 PyThreadState* __tstate = wxPyBeginAllowThreads();
27630 (arg1)->MoveAfterInTabOrder(arg2);
27631
27632 wxPyEndAllowThreads(__tstate);
27633 if (PyErr_Occurred()) SWIG_fail;
27634 }
27635 Py_INCREF(Py_None); resultobj = Py_None;
27636 return resultobj;
27637 fail:
27638 return NULL;
27639 }
27640
27641
27642 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27643 PyObject *resultobj;
27644 wxWindow *arg1 = (wxWindow *) 0 ;
27645 wxWindow *arg2 = (wxWindow *) 0 ;
27646 PyObject * obj0 = 0 ;
27647 PyObject * obj1 = 0 ;
27648 char *kwnames[] = {
27649 (char *) "self",(char *) "win", NULL
27650 };
27651
27652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27654 if (SWIG_arg_fail(1)) SWIG_fail;
27655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27656 if (SWIG_arg_fail(2)) SWIG_fail;
27657 {
27658 PyThreadState* __tstate = wxPyBeginAllowThreads();
27659 (arg1)->MoveBeforeInTabOrder(arg2);
27660
27661 wxPyEndAllowThreads(__tstate);
27662 if (PyErr_Occurred()) SWIG_fail;
27663 }
27664 Py_INCREF(Py_None); resultobj = Py_None;
27665 return resultobj;
27666 fail:
27667 return NULL;
27668 }
27669
27670
27671 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27672 PyObject *resultobj;
27673 wxWindow *arg1 = (wxWindow *) 0 ;
27674 PyObject *result;
27675 PyObject * obj0 = 0 ;
27676 char *kwnames[] = {
27677 (char *) "self", NULL
27678 };
27679
27680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27682 if (SWIG_arg_fail(1)) SWIG_fail;
27683 {
27684 PyThreadState* __tstate = wxPyBeginAllowThreads();
27685 result = (PyObject *)wxWindow_GetChildren(arg1);
27686
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 resultobj = result;
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj;
27699 wxWindow *arg1 = (wxWindow *) 0 ;
27700 wxWindow *result;
27701 PyObject * obj0 = 0 ;
27702 char *kwnames[] = {
27703 (char *) "self", NULL
27704 };
27705
27706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27708 if (SWIG_arg_fail(1)) SWIG_fail;
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27712
27713 wxPyEndAllowThreads(__tstate);
27714 if (PyErr_Occurred()) SWIG_fail;
27715 }
27716 {
27717 resultobj = wxPyMake_wxObject(result, 0);
27718 }
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj;
27727 wxWindow *arg1 = (wxWindow *) 0 ;
27728 wxWindow *result;
27729 PyObject * obj0 = 0 ;
27730 char *kwnames[] = {
27731 (char *) "self", NULL
27732 };
27733
27734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",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 = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27740
27741 wxPyEndAllowThreads(__tstate);
27742 if (PyErr_Occurred()) SWIG_fail;
27743 }
27744 {
27745 resultobj = wxPyMake_wxObject(result, 0);
27746 }
27747 return resultobj;
27748 fail:
27749 return NULL;
27750 }
27751
27752
27753 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27754 PyObject *resultobj;
27755 wxWindow *arg1 = (wxWindow *) 0 ;
27756 bool result;
27757 PyObject * obj0 = 0 ;
27758 char *kwnames[] = {
27759 (char *) "self", NULL
27760 };
27761
27762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27764 if (SWIG_arg_fail(1)) SWIG_fail;
27765 {
27766 PyThreadState* __tstate = wxPyBeginAllowThreads();
27767 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27768
27769 wxPyEndAllowThreads(__tstate);
27770 if (PyErr_Occurred()) SWIG_fail;
27771 }
27772 {
27773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27774 }
27775 return resultobj;
27776 fail:
27777 return NULL;
27778 }
27779
27780
27781 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27782 PyObject *resultobj;
27783 wxWindow *arg1 = (wxWindow *) 0 ;
27784 wxWindow *arg2 = (wxWindow *) 0 ;
27785 bool result;
27786 PyObject * obj0 = 0 ;
27787 PyObject * obj1 = 0 ;
27788 char *kwnames[] = {
27789 (char *) "self",(char *) "newParent", NULL
27790 };
27791
27792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27794 if (SWIG_arg_fail(1)) SWIG_fail;
27795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27796 if (SWIG_arg_fail(2)) SWIG_fail;
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = (bool)(arg1)->Reparent(arg2);
27800
27801 wxPyEndAllowThreads(__tstate);
27802 if (PyErr_Occurred()) SWIG_fail;
27803 }
27804 {
27805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27806 }
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27814 PyObject *resultobj;
27815 wxWindow *arg1 = (wxWindow *) 0 ;
27816 wxWindow *arg2 = (wxWindow *) 0 ;
27817 PyObject * obj0 = 0 ;
27818 PyObject * obj1 = 0 ;
27819 char *kwnames[] = {
27820 (char *) "self",(char *) "child", NULL
27821 };
27822
27823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27825 if (SWIG_arg_fail(1)) SWIG_fail;
27826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27827 if (SWIG_arg_fail(2)) SWIG_fail;
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 (arg1)->AddChild(arg2);
27831
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 Py_INCREF(Py_None); resultobj = Py_None;
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27843 PyObject *resultobj;
27844 wxWindow *arg1 = (wxWindow *) 0 ;
27845 wxWindow *arg2 = (wxWindow *) 0 ;
27846 PyObject * obj0 = 0 ;
27847 PyObject * obj1 = 0 ;
27848 char *kwnames[] = {
27849 (char *) "self",(char *) "child", NULL
27850 };
27851
27852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27854 if (SWIG_arg_fail(1)) SWIG_fail;
27855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27856 if (SWIG_arg_fail(2)) SWIG_fail;
27857 {
27858 PyThreadState* __tstate = wxPyBeginAllowThreads();
27859 (arg1)->RemoveChild(arg2);
27860
27861 wxPyEndAllowThreads(__tstate);
27862 if (PyErr_Occurred()) SWIG_fail;
27863 }
27864 Py_INCREF(Py_None); resultobj = Py_None;
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27872 PyObject *resultobj;
27873 wxWindow *arg1 = (wxWindow *) 0 ;
27874 long arg2 ;
27875 wxWindow *result;
27876 PyObject * obj0 = 0 ;
27877 PyObject * obj1 = 0 ;
27878 char *kwnames[] = {
27879 (char *) "self",(char *) "winid", NULL
27880 };
27881
27882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27884 if (SWIG_arg_fail(1)) SWIG_fail;
27885 {
27886 arg2 = (long)(SWIG_As_long(obj1));
27887 if (SWIG_arg_fail(2)) SWIG_fail;
27888 }
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (wxWindow *)(arg1)->FindWindow(arg2);
27892
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 {
27897 resultobj = wxPyMake_wxObject(result, 0);
27898 }
27899 return resultobj;
27900 fail:
27901 return NULL;
27902 }
27903
27904
27905 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27906 PyObject *resultobj;
27907 wxWindow *arg1 = (wxWindow *) 0 ;
27908 wxString *arg2 = 0 ;
27909 wxWindow *result;
27910 bool temp2 = false ;
27911 PyObject * obj0 = 0 ;
27912 PyObject * obj1 = 0 ;
27913 char *kwnames[] = {
27914 (char *) "self",(char *) "name", NULL
27915 };
27916
27917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27919 if (SWIG_arg_fail(1)) SWIG_fail;
27920 {
27921 arg2 = wxString_in_helper(obj1);
27922 if (arg2 == NULL) SWIG_fail;
27923 temp2 = true;
27924 }
27925 {
27926 PyThreadState* __tstate = wxPyBeginAllowThreads();
27927 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27928
27929 wxPyEndAllowThreads(__tstate);
27930 if (PyErr_Occurred()) SWIG_fail;
27931 }
27932 {
27933 resultobj = wxPyMake_wxObject(result, 0);
27934 }
27935 {
27936 if (temp2)
27937 delete arg2;
27938 }
27939 return resultobj;
27940 fail:
27941 {
27942 if (temp2)
27943 delete arg2;
27944 }
27945 return NULL;
27946 }
27947
27948
27949 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj;
27951 wxWindow *arg1 = (wxWindow *) 0 ;
27952 wxEvtHandler *result;
27953 PyObject * obj0 = 0 ;
27954 char *kwnames[] = {
27955 (char *) "self", NULL
27956 };
27957
27958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27960 if (SWIG_arg_fail(1)) SWIG_fail;
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27964
27965 wxPyEndAllowThreads(__tstate);
27966 if (PyErr_Occurred()) SWIG_fail;
27967 }
27968 {
27969 resultobj = wxPyMake_wxObject(result, 0);
27970 }
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27978 PyObject *resultobj;
27979 wxWindow *arg1 = (wxWindow *) 0 ;
27980 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27981 PyObject * obj0 = 0 ;
27982 PyObject * obj1 = 0 ;
27983 char *kwnames[] = {
27984 (char *) "self",(char *) "handler", NULL
27985 };
27986
27987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27989 if (SWIG_arg_fail(1)) SWIG_fail;
27990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27991 if (SWIG_arg_fail(2)) SWIG_fail;
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 (arg1)->SetEventHandler(arg2);
27995
27996 wxPyEndAllowThreads(__tstate);
27997 if (PyErr_Occurred()) SWIG_fail;
27998 }
27999 Py_INCREF(Py_None); resultobj = Py_None;
28000 return resultobj;
28001 fail:
28002 return NULL;
28003 }
28004
28005
28006 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28007 PyObject *resultobj;
28008 wxWindow *arg1 = (wxWindow *) 0 ;
28009 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28010 PyObject * obj0 = 0 ;
28011 PyObject * obj1 = 0 ;
28012 char *kwnames[] = {
28013 (char *) "self",(char *) "handler", NULL
28014 };
28015
28016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28018 if (SWIG_arg_fail(1)) SWIG_fail;
28019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28020 if (SWIG_arg_fail(2)) SWIG_fail;
28021 {
28022 PyThreadState* __tstate = wxPyBeginAllowThreads();
28023 (arg1)->PushEventHandler(arg2);
28024
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 Py_INCREF(Py_None); resultobj = Py_None;
28029 return resultobj;
28030 fail:
28031 return NULL;
28032 }
28033
28034
28035 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28036 PyObject *resultobj;
28037 wxWindow *arg1 = (wxWindow *) 0 ;
28038 bool arg2 = (bool) false ;
28039 wxEvtHandler *result;
28040 PyObject * obj0 = 0 ;
28041 PyObject * obj1 = 0 ;
28042 char *kwnames[] = {
28043 (char *) "self",(char *) "deleteHandler", NULL
28044 };
28045
28046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",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 if (obj1) {
28050 {
28051 arg2 = (bool)(SWIG_As_bool(obj1));
28052 if (SWIG_arg_fail(2)) SWIG_fail;
28053 }
28054 }
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28058
28059 wxPyEndAllowThreads(__tstate);
28060 if (PyErr_Occurred()) SWIG_fail;
28061 }
28062 {
28063 resultobj = wxPyMake_wxObject(result, 0);
28064 }
28065 return resultobj;
28066 fail:
28067 return NULL;
28068 }
28069
28070
28071 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28072 PyObject *resultobj;
28073 wxWindow *arg1 = (wxWindow *) 0 ;
28074 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28075 bool result;
28076 PyObject * obj0 = 0 ;
28077 PyObject * obj1 = 0 ;
28078 char *kwnames[] = {
28079 (char *) "self",(char *) "handler", NULL
28080 };
28081
28082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28084 if (SWIG_arg_fail(1)) SWIG_fail;
28085 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28086 if (SWIG_arg_fail(2)) SWIG_fail;
28087 {
28088 PyThreadState* __tstate = wxPyBeginAllowThreads();
28089 result = (bool)(arg1)->RemoveEventHandler(arg2);
28090
28091 wxPyEndAllowThreads(__tstate);
28092 if (PyErr_Occurred()) SWIG_fail;
28093 }
28094 {
28095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28096 }
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj;
28105 wxWindow *arg1 = (wxWindow *) 0 ;
28106 wxValidator *arg2 = 0 ;
28107 PyObject * obj0 = 0 ;
28108 PyObject * obj1 = 0 ;
28109 char *kwnames[] = {
28110 (char *) "self",(char *) "validator", NULL
28111 };
28112
28113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28115 if (SWIG_arg_fail(1)) SWIG_fail;
28116 {
28117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28118 if (SWIG_arg_fail(2)) SWIG_fail;
28119 if (arg2 == NULL) {
28120 SWIG_null_ref("wxValidator");
28121 }
28122 if (SWIG_arg_fail(2)) SWIG_fail;
28123 }
28124 {
28125 PyThreadState* __tstate = wxPyBeginAllowThreads();
28126 (arg1)->SetValidator((wxValidator const &)*arg2);
28127
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 Py_INCREF(Py_None); resultobj = Py_None;
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28139 PyObject *resultobj;
28140 wxWindow *arg1 = (wxWindow *) 0 ;
28141 wxValidator *result;
28142 PyObject * obj0 = 0 ;
28143 char *kwnames[] = {
28144 (char *) "self", NULL
28145 };
28146
28147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28149 if (SWIG_arg_fail(1)) SWIG_fail;
28150 {
28151 PyThreadState* __tstate = wxPyBeginAllowThreads();
28152 result = (wxValidator *)(arg1)->GetValidator();
28153
28154 wxPyEndAllowThreads(__tstate);
28155 if (PyErr_Occurred()) SWIG_fail;
28156 }
28157 {
28158 resultobj = wxPyMake_wxObject(result, 0);
28159 }
28160 return resultobj;
28161 fail:
28162 return NULL;
28163 }
28164
28165
28166 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28167 PyObject *resultobj;
28168 wxWindow *arg1 = (wxWindow *) 0 ;
28169 bool result;
28170 PyObject * obj0 = 0 ;
28171 char *kwnames[] = {
28172 (char *) "self", NULL
28173 };
28174
28175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28177 if (SWIG_arg_fail(1)) SWIG_fail;
28178 {
28179 PyThreadState* __tstate = wxPyBeginAllowThreads();
28180 result = (bool)(arg1)->Validate();
28181
28182 wxPyEndAllowThreads(__tstate);
28183 if (PyErr_Occurred()) SWIG_fail;
28184 }
28185 {
28186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28187 }
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj;
28196 wxWindow *arg1 = (wxWindow *) 0 ;
28197 bool result;
28198 PyObject * obj0 = 0 ;
28199 char *kwnames[] = {
28200 (char *) "self", NULL
28201 };
28202
28203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28205 if (SWIG_arg_fail(1)) SWIG_fail;
28206 {
28207 PyThreadState* __tstate = wxPyBeginAllowThreads();
28208 result = (bool)(arg1)->TransferDataToWindow();
28209
28210 wxPyEndAllowThreads(__tstate);
28211 if (PyErr_Occurred()) SWIG_fail;
28212 }
28213 {
28214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28215 }
28216 return resultobj;
28217 fail:
28218 return NULL;
28219 }
28220
28221
28222 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28223 PyObject *resultobj;
28224 wxWindow *arg1 = (wxWindow *) 0 ;
28225 bool result;
28226 PyObject * obj0 = 0 ;
28227 char *kwnames[] = {
28228 (char *) "self", NULL
28229 };
28230
28231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28233 if (SWIG_arg_fail(1)) SWIG_fail;
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (bool)(arg1)->TransferDataFromWindow();
28237
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 {
28242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28243 }
28244 return resultobj;
28245 fail:
28246 return NULL;
28247 }
28248
28249
28250 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28251 PyObject *resultobj;
28252 wxWindow *arg1 = (wxWindow *) 0 ;
28253 PyObject * obj0 = 0 ;
28254 char *kwnames[] = {
28255 (char *) "self", NULL
28256 };
28257
28258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28260 if (SWIG_arg_fail(1)) SWIG_fail;
28261 {
28262 PyThreadState* __tstate = wxPyBeginAllowThreads();
28263 (arg1)->InitDialog();
28264
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 Py_INCREF(Py_None); resultobj = Py_None;
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj;
28277 wxWindow *arg1 = (wxWindow *) 0 ;
28278 wxAcceleratorTable *arg2 = 0 ;
28279 PyObject * obj0 = 0 ;
28280 PyObject * obj1 = 0 ;
28281 char *kwnames[] = {
28282 (char *) "self",(char *) "accel", NULL
28283 };
28284
28285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28287 if (SWIG_arg_fail(1)) SWIG_fail;
28288 {
28289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28290 if (SWIG_arg_fail(2)) SWIG_fail;
28291 if (arg2 == NULL) {
28292 SWIG_null_ref("wxAcceleratorTable");
28293 }
28294 if (SWIG_arg_fail(2)) SWIG_fail;
28295 }
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28299
28300 wxPyEndAllowThreads(__tstate);
28301 if (PyErr_Occurred()) SWIG_fail;
28302 }
28303 Py_INCREF(Py_None); resultobj = Py_None;
28304 return resultobj;
28305 fail:
28306 return NULL;
28307 }
28308
28309
28310 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28311 PyObject *resultobj;
28312 wxWindow *arg1 = (wxWindow *) 0 ;
28313 wxAcceleratorTable *result;
28314 PyObject * obj0 = 0 ;
28315 char *kwnames[] = {
28316 (char *) "self", NULL
28317 };
28318
28319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28321 if (SWIG_arg_fail(1)) SWIG_fail;
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28325
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28330 return resultobj;
28331 fail:
28332 return NULL;
28333 }
28334
28335
28336 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28337 PyObject *resultobj;
28338 wxWindow *arg1 = (wxWindow *) 0 ;
28339 int arg2 ;
28340 int arg3 ;
28341 int arg4 ;
28342 bool result;
28343 PyObject * obj0 = 0 ;
28344 PyObject * obj1 = 0 ;
28345 PyObject * obj2 = 0 ;
28346 PyObject * obj3 = 0 ;
28347 char *kwnames[] = {
28348 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28349 };
28350
28351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28353 if (SWIG_arg_fail(1)) SWIG_fail;
28354 {
28355 arg2 = (int)(SWIG_As_int(obj1));
28356 if (SWIG_arg_fail(2)) SWIG_fail;
28357 }
28358 {
28359 arg3 = (int)(SWIG_As_int(obj2));
28360 if (SWIG_arg_fail(3)) SWIG_fail;
28361 }
28362 {
28363 arg4 = (int)(SWIG_As_int(obj3));
28364 if (SWIG_arg_fail(4)) SWIG_fail;
28365 }
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28369
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 {
28374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28375 }
28376 return resultobj;
28377 fail:
28378 return NULL;
28379 }
28380
28381
28382 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28383 PyObject *resultobj;
28384 wxWindow *arg1 = (wxWindow *) 0 ;
28385 int arg2 ;
28386 bool result;
28387 PyObject * obj0 = 0 ;
28388 PyObject * obj1 = 0 ;
28389 char *kwnames[] = {
28390 (char *) "self",(char *) "hotkeyId", NULL
28391 };
28392
28393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28395 if (SWIG_arg_fail(1)) SWIG_fail;
28396 {
28397 arg2 = (int)(SWIG_As_int(obj1));
28398 if (SWIG_arg_fail(2)) SWIG_fail;
28399 }
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28403
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 {
28408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28409 }
28410 return resultobj;
28411 fail:
28412 return NULL;
28413 }
28414
28415
28416 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28417 PyObject *resultobj;
28418 wxWindow *arg1 = (wxWindow *) 0 ;
28419 wxPoint *arg2 = 0 ;
28420 wxPoint result;
28421 wxPoint temp2 ;
28422 PyObject * obj0 = 0 ;
28423 PyObject * obj1 = 0 ;
28424 char *kwnames[] = {
28425 (char *) "self",(char *) "pt", NULL
28426 };
28427
28428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28430 if (SWIG_arg_fail(1)) SWIG_fail;
28431 {
28432 arg2 = &temp2;
28433 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28434 }
28435 {
28436 PyThreadState* __tstate = wxPyBeginAllowThreads();
28437 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28438
28439 wxPyEndAllowThreads(__tstate);
28440 if (PyErr_Occurred()) SWIG_fail;
28441 }
28442 {
28443 wxPoint * resultptr;
28444 resultptr = new wxPoint((wxPoint &)(result));
28445 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28446 }
28447 return resultobj;
28448 fail:
28449 return NULL;
28450 }
28451
28452
28453 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28454 PyObject *resultobj;
28455 wxWindow *arg1 = (wxWindow *) 0 ;
28456 wxSize *arg2 = 0 ;
28457 wxSize result;
28458 wxSize temp2 ;
28459 PyObject * obj0 = 0 ;
28460 PyObject * obj1 = 0 ;
28461 char *kwnames[] = {
28462 (char *) "self",(char *) "sz", NULL
28463 };
28464
28465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28467 if (SWIG_arg_fail(1)) SWIG_fail;
28468 {
28469 arg2 = &temp2;
28470 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28471 }
28472 {
28473 PyThreadState* __tstate = wxPyBeginAllowThreads();
28474 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28475
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 {
28480 wxSize * resultptr;
28481 resultptr = new wxSize((wxSize &)(result));
28482 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28483 }
28484 return resultobj;
28485 fail:
28486 return NULL;
28487 }
28488
28489
28490 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28491 PyObject *resultobj;
28492 wxWindow *arg1 = (wxWindow *) 0 ;
28493 wxPoint *arg2 = 0 ;
28494 wxPoint result;
28495 wxPoint temp2 ;
28496 PyObject * obj0 = 0 ;
28497 PyObject * obj1 = 0 ;
28498 char *kwnames[] = {
28499 (char *) "self",(char *) "pt", NULL
28500 };
28501
28502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28504 if (SWIG_arg_fail(1)) SWIG_fail;
28505 {
28506 arg2 = &temp2;
28507 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28508 }
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28512
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 {
28517 wxPoint * resultptr;
28518 resultptr = new wxPoint((wxPoint &)(result));
28519 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28520 }
28521 return resultobj;
28522 fail:
28523 return NULL;
28524 }
28525
28526
28527 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28528 PyObject *resultobj;
28529 wxWindow *arg1 = (wxWindow *) 0 ;
28530 wxSize *arg2 = 0 ;
28531 wxSize result;
28532 wxSize temp2 ;
28533 PyObject * obj0 = 0 ;
28534 PyObject * obj1 = 0 ;
28535 char *kwnames[] = {
28536 (char *) "self",(char *) "sz", NULL
28537 };
28538
28539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28541 if (SWIG_arg_fail(1)) SWIG_fail;
28542 {
28543 arg2 = &temp2;
28544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28545 }
28546 {
28547 PyThreadState* __tstate = wxPyBeginAllowThreads();
28548 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28549
28550 wxPyEndAllowThreads(__tstate);
28551 if (PyErr_Occurred()) SWIG_fail;
28552 }
28553 {
28554 wxSize * resultptr;
28555 resultptr = new wxSize((wxSize &)(result));
28556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28557 }
28558 return resultobj;
28559 fail:
28560 return NULL;
28561 }
28562
28563
28564 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28565 PyObject *resultobj;
28566 wxWindow *arg1 = (wxWindow *) 0 ;
28567 wxPoint *arg2 = 0 ;
28568 wxPoint result;
28569 wxPoint temp2 ;
28570 PyObject * obj0 = 0 ;
28571 PyObject * obj1 = 0 ;
28572 char *kwnames[] = {
28573 (char *) "self",(char *) "pt", NULL
28574 };
28575
28576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28578 if (SWIG_arg_fail(1)) SWIG_fail;
28579 {
28580 arg2 = &temp2;
28581 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28582 }
28583 {
28584 PyThreadState* __tstate = wxPyBeginAllowThreads();
28585 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28586
28587 wxPyEndAllowThreads(__tstate);
28588 if (PyErr_Occurred()) SWIG_fail;
28589 }
28590 {
28591 wxPoint * resultptr;
28592 resultptr = new wxPoint((wxPoint &)(result));
28593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28594 }
28595 return resultobj;
28596 fail:
28597 return NULL;
28598 }
28599
28600
28601 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28602 PyObject *resultobj;
28603 wxWindow *arg1 = (wxWindow *) 0 ;
28604 wxSize *arg2 = 0 ;
28605 wxSize result;
28606 wxSize temp2 ;
28607 PyObject * obj0 = 0 ;
28608 PyObject * obj1 = 0 ;
28609 char *kwnames[] = {
28610 (char *) "self",(char *) "sz", NULL
28611 };
28612
28613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28615 if (SWIG_arg_fail(1)) SWIG_fail;
28616 {
28617 arg2 = &temp2;
28618 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28619 }
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28623
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 {
28628 wxSize * resultptr;
28629 resultptr = new wxSize((wxSize &)(result));
28630 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28631 }
28632 return resultobj;
28633 fail:
28634 return NULL;
28635 }
28636
28637
28638 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28639 PyObject *resultobj;
28640 wxWindow *arg1 = (wxWindow *) 0 ;
28641 int arg2 ;
28642 int arg3 ;
28643 PyObject * obj0 = 0 ;
28644 PyObject * obj1 = 0 ;
28645 PyObject * obj2 = 0 ;
28646 char *kwnames[] = {
28647 (char *) "self",(char *) "x",(char *) "y", NULL
28648 };
28649
28650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28652 if (SWIG_arg_fail(1)) SWIG_fail;
28653 {
28654 arg2 = (int)(SWIG_As_int(obj1));
28655 if (SWIG_arg_fail(2)) SWIG_fail;
28656 }
28657 {
28658 arg3 = (int)(SWIG_As_int(obj2));
28659 if (SWIG_arg_fail(3)) SWIG_fail;
28660 }
28661 {
28662 PyThreadState* __tstate = wxPyBeginAllowThreads();
28663 (arg1)->WarpPointer(arg2,arg3);
28664
28665 wxPyEndAllowThreads(__tstate);
28666 if (PyErr_Occurred()) SWIG_fail;
28667 }
28668 Py_INCREF(Py_None); resultobj = Py_None;
28669 return resultobj;
28670 fail:
28671 return NULL;
28672 }
28673
28674
28675 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28676 PyObject *resultobj;
28677 wxWindow *arg1 = (wxWindow *) 0 ;
28678 PyObject * obj0 = 0 ;
28679 char *kwnames[] = {
28680 (char *) "self", NULL
28681 };
28682
28683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28685 if (SWIG_arg_fail(1)) SWIG_fail;
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 (arg1)->CaptureMouse();
28689
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 Py_INCREF(Py_None); resultobj = Py_None;
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28701 PyObject *resultobj;
28702 wxWindow *arg1 = (wxWindow *) 0 ;
28703 PyObject * obj0 = 0 ;
28704 char *kwnames[] = {
28705 (char *) "self", NULL
28706 };
28707
28708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28710 if (SWIG_arg_fail(1)) SWIG_fail;
28711 {
28712 PyThreadState* __tstate = wxPyBeginAllowThreads();
28713 (arg1)->ReleaseMouse();
28714
28715 wxPyEndAllowThreads(__tstate);
28716 if (PyErr_Occurred()) SWIG_fail;
28717 }
28718 Py_INCREF(Py_None); resultobj = Py_None;
28719 return resultobj;
28720 fail:
28721 return NULL;
28722 }
28723
28724
28725 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28726 PyObject *resultobj;
28727 wxWindow *result;
28728 char *kwnames[] = {
28729 NULL
28730 };
28731
28732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28733 {
28734 if (!wxPyCheckForApp()) SWIG_fail;
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 result = (wxWindow *)wxWindow::GetCapture();
28737
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 {
28742 resultobj = wxPyMake_wxObject(result, 0);
28743 }
28744 return resultobj;
28745 fail:
28746 return NULL;
28747 }
28748
28749
28750 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28751 PyObject *resultobj;
28752 wxWindow *arg1 = (wxWindow *) 0 ;
28753 bool result;
28754 PyObject * obj0 = 0 ;
28755 char *kwnames[] = {
28756 (char *) "self", NULL
28757 };
28758
28759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28761 if (SWIG_arg_fail(1)) SWIG_fail;
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 result = (bool)((wxWindow const *)arg1)->HasCapture();
28765
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 {
28770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28771 }
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28779 PyObject *resultobj;
28780 wxWindow *arg1 = (wxWindow *) 0 ;
28781 bool arg2 = (bool) true ;
28782 wxRect *arg3 = (wxRect *) NULL ;
28783 PyObject * obj0 = 0 ;
28784 PyObject * obj1 = 0 ;
28785 PyObject * obj2 = 0 ;
28786 char *kwnames[] = {
28787 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28788 };
28789
28790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28792 if (SWIG_arg_fail(1)) SWIG_fail;
28793 if (obj1) {
28794 {
28795 arg2 = (bool)(SWIG_As_bool(obj1));
28796 if (SWIG_arg_fail(2)) SWIG_fail;
28797 }
28798 }
28799 if (obj2) {
28800 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28801 if (SWIG_arg_fail(3)) SWIG_fail;
28802 }
28803 {
28804 PyThreadState* __tstate = wxPyBeginAllowThreads();
28805 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28806
28807 wxPyEndAllowThreads(__tstate);
28808 if (PyErr_Occurred()) SWIG_fail;
28809 }
28810 Py_INCREF(Py_None); resultobj = Py_None;
28811 return resultobj;
28812 fail:
28813 return NULL;
28814 }
28815
28816
28817 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28818 PyObject *resultobj;
28819 wxWindow *arg1 = (wxWindow *) 0 ;
28820 wxRect *arg2 = 0 ;
28821 bool arg3 = (bool) true ;
28822 wxRect temp2 ;
28823 PyObject * obj0 = 0 ;
28824 PyObject * obj1 = 0 ;
28825 PyObject * obj2 = 0 ;
28826 char *kwnames[] = {
28827 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28828 };
28829
28830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28832 if (SWIG_arg_fail(1)) SWIG_fail;
28833 {
28834 arg2 = &temp2;
28835 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28836 }
28837 if (obj2) {
28838 {
28839 arg3 = (bool)(SWIG_As_bool(obj2));
28840 if (SWIG_arg_fail(3)) SWIG_fail;
28841 }
28842 }
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28846
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 Py_INCREF(Py_None); resultobj = Py_None;
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj;
28859 wxWindow *arg1 = (wxWindow *) 0 ;
28860 PyObject * obj0 = 0 ;
28861 char *kwnames[] = {
28862 (char *) "self", NULL
28863 };
28864
28865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28867 if (SWIG_arg_fail(1)) SWIG_fail;
28868 {
28869 PyThreadState* __tstate = wxPyBeginAllowThreads();
28870 (arg1)->Update();
28871
28872 wxPyEndAllowThreads(__tstate);
28873 if (PyErr_Occurred()) SWIG_fail;
28874 }
28875 Py_INCREF(Py_None); resultobj = Py_None;
28876 return resultobj;
28877 fail:
28878 return NULL;
28879 }
28880
28881
28882 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj;
28884 wxWindow *arg1 = (wxWindow *) 0 ;
28885 PyObject * obj0 = 0 ;
28886 char *kwnames[] = {
28887 (char *) "self", NULL
28888 };
28889
28890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28892 if (SWIG_arg_fail(1)) SWIG_fail;
28893 {
28894 PyThreadState* __tstate = wxPyBeginAllowThreads();
28895 (arg1)->ClearBackground();
28896
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 Py_INCREF(Py_None); resultobj = Py_None;
28901 return resultobj;
28902 fail:
28903 return NULL;
28904 }
28905
28906
28907 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28908 PyObject *resultobj;
28909 wxWindow *arg1 = (wxWindow *) 0 ;
28910 PyObject * obj0 = 0 ;
28911 char *kwnames[] = {
28912 (char *) "self", NULL
28913 };
28914
28915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28917 if (SWIG_arg_fail(1)) SWIG_fail;
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 (arg1)->Freeze();
28921
28922 wxPyEndAllowThreads(__tstate);
28923 if (PyErr_Occurred()) SWIG_fail;
28924 }
28925 Py_INCREF(Py_None); resultobj = Py_None;
28926 return resultobj;
28927 fail:
28928 return NULL;
28929 }
28930
28931
28932 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28933 PyObject *resultobj;
28934 wxWindow *arg1 = (wxWindow *) 0 ;
28935 PyObject * obj0 = 0 ;
28936 char *kwnames[] = {
28937 (char *) "self", NULL
28938 };
28939
28940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28942 if (SWIG_arg_fail(1)) SWIG_fail;
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 (arg1)->Thaw();
28946
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 Py_INCREF(Py_None); resultobj = Py_None;
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28958 PyObject *resultobj;
28959 wxWindow *arg1 = (wxWindow *) 0 ;
28960 wxDC *arg2 = 0 ;
28961 PyObject * obj0 = 0 ;
28962 PyObject * obj1 = 0 ;
28963 char *kwnames[] = {
28964 (char *) "self",(char *) "dc", NULL
28965 };
28966
28967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28969 if (SWIG_arg_fail(1)) SWIG_fail;
28970 {
28971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28972 if (SWIG_arg_fail(2)) SWIG_fail;
28973 if (arg2 == NULL) {
28974 SWIG_null_ref("wxDC");
28975 }
28976 if (SWIG_arg_fail(2)) SWIG_fail;
28977 }
28978 {
28979 PyThreadState* __tstate = wxPyBeginAllowThreads();
28980 (arg1)->PrepareDC(*arg2);
28981
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 Py_INCREF(Py_None); resultobj = Py_None;
28986 return resultobj;
28987 fail:
28988 return NULL;
28989 }
28990
28991
28992 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28993 PyObject *resultobj;
28994 wxWindow *arg1 = (wxWindow *) 0 ;
28995 wxRegion *result;
28996 PyObject * obj0 = 0 ;
28997 char *kwnames[] = {
28998 (char *) "self", NULL
28999 };
29000
29001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29003 if (SWIG_arg_fail(1)) SWIG_fail;
29004 {
29005 PyThreadState* __tstate = wxPyBeginAllowThreads();
29006 {
29007 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29008 result = (wxRegion *) &_result_ref;
29009 }
29010
29011 wxPyEndAllowThreads(__tstate);
29012 if (PyErr_Occurred()) SWIG_fail;
29013 }
29014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29022 PyObject *resultobj;
29023 wxWindow *arg1 = (wxWindow *) 0 ;
29024 wxRect result;
29025 PyObject * obj0 = 0 ;
29026 char *kwnames[] = {
29027 (char *) "self", NULL
29028 };
29029
29030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29032 if (SWIG_arg_fail(1)) SWIG_fail;
29033 {
29034 PyThreadState* __tstate = wxPyBeginAllowThreads();
29035 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29036
29037 wxPyEndAllowThreads(__tstate);
29038 if (PyErr_Occurred()) SWIG_fail;
29039 }
29040 {
29041 wxRect * resultptr;
29042 resultptr = new wxRect((wxRect &)(result));
29043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29044 }
29045 return resultobj;
29046 fail:
29047 return NULL;
29048 }
29049
29050
29051 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29052 PyObject *resultobj;
29053 wxWindow *arg1 = (wxWindow *) 0 ;
29054 int arg2 ;
29055 int arg3 ;
29056 int arg4 = (int) 1 ;
29057 int arg5 = (int) 1 ;
29058 bool result;
29059 PyObject * obj0 = 0 ;
29060 PyObject * obj1 = 0 ;
29061 PyObject * obj2 = 0 ;
29062 PyObject * obj3 = 0 ;
29063 PyObject * obj4 = 0 ;
29064 char *kwnames[] = {
29065 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29066 };
29067
29068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29070 if (SWIG_arg_fail(1)) SWIG_fail;
29071 {
29072 arg2 = (int)(SWIG_As_int(obj1));
29073 if (SWIG_arg_fail(2)) SWIG_fail;
29074 }
29075 {
29076 arg3 = (int)(SWIG_As_int(obj2));
29077 if (SWIG_arg_fail(3)) SWIG_fail;
29078 }
29079 if (obj3) {
29080 {
29081 arg4 = (int)(SWIG_As_int(obj3));
29082 if (SWIG_arg_fail(4)) SWIG_fail;
29083 }
29084 }
29085 if (obj4) {
29086 {
29087 arg5 = (int)(SWIG_As_int(obj4));
29088 if (SWIG_arg_fail(5)) SWIG_fail;
29089 }
29090 }
29091 {
29092 PyThreadState* __tstate = wxPyBeginAllowThreads();
29093 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29094
29095 wxPyEndAllowThreads(__tstate);
29096 if (PyErr_Occurred()) SWIG_fail;
29097 }
29098 {
29099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29100 }
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29108 PyObject *resultobj;
29109 wxWindow *arg1 = (wxWindow *) 0 ;
29110 wxPoint *arg2 = 0 ;
29111 bool result;
29112 wxPoint temp2 ;
29113 PyObject * obj0 = 0 ;
29114 PyObject * obj1 = 0 ;
29115 char *kwnames[] = {
29116 (char *) "self",(char *) "pt", NULL
29117 };
29118
29119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29121 if (SWIG_arg_fail(1)) SWIG_fail;
29122 {
29123 arg2 = &temp2;
29124 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29125 }
29126 {
29127 PyThreadState* __tstate = wxPyBeginAllowThreads();
29128 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29129
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 {
29134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29135 }
29136 return resultobj;
29137 fail:
29138 return NULL;
29139 }
29140
29141
29142 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29143 PyObject *resultobj;
29144 wxWindow *arg1 = (wxWindow *) 0 ;
29145 wxRect *arg2 = 0 ;
29146 bool result;
29147 wxRect temp2 ;
29148 PyObject * obj0 = 0 ;
29149 PyObject * obj1 = 0 ;
29150 char *kwnames[] = {
29151 (char *) "self",(char *) "rect", NULL
29152 };
29153
29154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29156 if (SWIG_arg_fail(1)) SWIG_fail;
29157 {
29158 arg2 = &temp2;
29159 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29160 }
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29164
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 {
29169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29170 }
29171 return resultobj;
29172 fail:
29173 return NULL;
29174 }
29175
29176
29177 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29178 PyObject *resultobj;
29179 wxWindow *arg1 = (wxWindow *) 0 ;
29180 wxVisualAttributes result;
29181 PyObject * obj0 = 0 ;
29182 char *kwnames[] = {
29183 (char *) "self", NULL
29184 };
29185
29186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29188 if (SWIG_arg_fail(1)) SWIG_fail;
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29192
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 {
29197 wxVisualAttributes * resultptr;
29198 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29200 }
29201 return resultobj;
29202 fail:
29203 return NULL;
29204 }
29205
29206
29207 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29208 PyObject *resultobj;
29209 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29210 wxVisualAttributes result;
29211 PyObject * obj0 = 0 ;
29212 char *kwnames[] = {
29213 (char *) "variant", NULL
29214 };
29215
29216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29217 if (obj0) {
29218 {
29219 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29220 if (SWIG_arg_fail(1)) SWIG_fail;
29221 }
29222 }
29223 {
29224 if (!wxPyCheckForApp()) SWIG_fail;
29225 PyThreadState* __tstate = wxPyBeginAllowThreads();
29226 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29227
29228 wxPyEndAllowThreads(__tstate);
29229 if (PyErr_Occurred()) SWIG_fail;
29230 }
29231 {
29232 wxVisualAttributes * resultptr;
29233 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29234 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29235 }
29236 return resultobj;
29237 fail:
29238 return NULL;
29239 }
29240
29241
29242 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29243 PyObject *resultobj;
29244 wxWindow *arg1 = (wxWindow *) 0 ;
29245 wxColour *arg2 = 0 ;
29246 bool result;
29247 wxColour temp2 ;
29248 PyObject * obj0 = 0 ;
29249 PyObject * obj1 = 0 ;
29250 char *kwnames[] = {
29251 (char *) "self",(char *) "colour", NULL
29252 };
29253
29254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29256 if (SWIG_arg_fail(1)) SWIG_fail;
29257 {
29258 arg2 = &temp2;
29259 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29260 }
29261 {
29262 PyThreadState* __tstate = wxPyBeginAllowThreads();
29263 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29264
29265 wxPyEndAllowThreads(__tstate);
29266 if (PyErr_Occurred()) SWIG_fail;
29267 }
29268 {
29269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29270 }
29271 return resultobj;
29272 fail:
29273 return NULL;
29274 }
29275
29276
29277 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29278 PyObject *resultobj;
29279 wxWindow *arg1 = (wxWindow *) 0 ;
29280 wxColour *arg2 = 0 ;
29281 wxColour temp2 ;
29282 PyObject * obj0 = 0 ;
29283 PyObject * obj1 = 0 ;
29284 char *kwnames[] = {
29285 (char *) "self",(char *) "colour", NULL
29286 };
29287
29288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29290 if (SWIG_arg_fail(1)) SWIG_fail;
29291 {
29292 arg2 = &temp2;
29293 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29294 }
29295 {
29296 PyThreadState* __tstate = wxPyBeginAllowThreads();
29297 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29298
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 Py_INCREF(Py_None); resultobj = Py_None;
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29310 PyObject *resultobj;
29311 wxWindow *arg1 = (wxWindow *) 0 ;
29312 wxColour *arg2 = 0 ;
29313 bool result;
29314 wxColour temp2 ;
29315 PyObject * obj0 = 0 ;
29316 PyObject * obj1 = 0 ;
29317 char *kwnames[] = {
29318 (char *) "self",(char *) "colour", NULL
29319 };
29320
29321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29323 if (SWIG_arg_fail(1)) SWIG_fail;
29324 {
29325 arg2 = &temp2;
29326 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29327 }
29328 {
29329 PyThreadState* __tstate = wxPyBeginAllowThreads();
29330 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29331
29332 wxPyEndAllowThreads(__tstate);
29333 if (PyErr_Occurred()) SWIG_fail;
29334 }
29335 {
29336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29337 }
29338 return resultobj;
29339 fail:
29340 return NULL;
29341 }
29342
29343
29344 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29345 PyObject *resultobj;
29346 wxWindow *arg1 = (wxWindow *) 0 ;
29347 wxColour *arg2 = 0 ;
29348 wxColour temp2 ;
29349 PyObject * obj0 = 0 ;
29350 PyObject * obj1 = 0 ;
29351 char *kwnames[] = {
29352 (char *) "self",(char *) "colour", NULL
29353 };
29354
29355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29357 if (SWIG_arg_fail(1)) SWIG_fail;
29358 {
29359 arg2 = &temp2;
29360 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29361 }
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 Py_INCREF(Py_None); resultobj = Py_None;
29370 return resultobj;
29371 fail:
29372 return NULL;
29373 }
29374
29375
29376 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29377 PyObject *resultobj;
29378 wxWindow *arg1 = (wxWindow *) 0 ;
29379 wxColour result;
29380 PyObject * obj0 = 0 ;
29381 char *kwnames[] = {
29382 (char *) "self", NULL
29383 };
29384
29385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29387 if (SWIG_arg_fail(1)) SWIG_fail;
29388 {
29389 PyThreadState* __tstate = wxPyBeginAllowThreads();
29390 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29391
29392 wxPyEndAllowThreads(__tstate);
29393 if (PyErr_Occurred()) SWIG_fail;
29394 }
29395 {
29396 wxColour * resultptr;
29397 resultptr = new wxColour((wxColour &)(result));
29398 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29399 }
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29407 PyObject *resultobj;
29408 wxWindow *arg1 = (wxWindow *) 0 ;
29409 wxColour result;
29410 PyObject * obj0 = 0 ;
29411 char *kwnames[] = {
29412 (char *) "self", NULL
29413 };
29414
29415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29417 if (SWIG_arg_fail(1)) SWIG_fail;
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 result = ((wxWindow const *)arg1)->GetForegroundColour();
29421
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 {
29426 wxColour * resultptr;
29427 resultptr = new wxColour((wxColour &)(result));
29428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29429 }
29430 return resultobj;
29431 fail:
29432 return NULL;
29433 }
29434
29435
29436 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29437 PyObject *resultobj;
29438 wxWindow *arg1 = (wxWindow *) 0 ;
29439 bool result;
29440 PyObject * obj0 = 0 ;
29441 char *kwnames[] = {
29442 (char *) "self", NULL
29443 };
29444
29445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29447 if (SWIG_arg_fail(1)) SWIG_fail;
29448 {
29449 PyThreadState* __tstate = wxPyBeginAllowThreads();
29450 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29451
29452 wxPyEndAllowThreads(__tstate);
29453 if (PyErr_Occurred()) SWIG_fail;
29454 }
29455 {
29456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29457 }
29458 return resultobj;
29459 fail:
29460 return NULL;
29461 }
29462
29463
29464 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29465 PyObject *resultobj;
29466 wxWindow *arg1 = (wxWindow *) 0 ;
29467 bool result;
29468 PyObject * obj0 = 0 ;
29469 char *kwnames[] = {
29470 (char *) "self", NULL
29471 };
29472
29473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29475 if (SWIG_arg_fail(1)) SWIG_fail;
29476 {
29477 PyThreadState* __tstate = wxPyBeginAllowThreads();
29478 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29479
29480 wxPyEndAllowThreads(__tstate);
29481 if (PyErr_Occurred()) SWIG_fail;
29482 }
29483 {
29484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29485 }
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29493 PyObject *resultobj;
29494 wxWindow *arg1 = (wxWindow *) 0 ;
29495 wxBackgroundStyle arg2 ;
29496 bool result;
29497 PyObject * obj0 = 0 ;
29498 PyObject * obj1 = 0 ;
29499 char *kwnames[] = {
29500 (char *) "self",(char *) "style", NULL
29501 };
29502
29503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29505 if (SWIG_arg_fail(1)) SWIG_fail;
29506 {
29507 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29508 if (SWIG_arg_fail(2)) SWIG_fail;
29509 }
29510 {
29511 PyThreadState* __tstate = wxPyBeginAllowThreads();
29512 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29513
29514 wxPyEndAllowThreads(__tstate);
29515 if (PyErr_Occurred()) SWIG_fail;
29516 }
29517 {
29518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29519 }
29520 return resultobj;
29521 fail:
29522 return NULL;
29523 }
29524
29525
29526 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29527 PyObject *resultobj;
29528 wxWindow *arg1 = (wxWindow *) 0 ;
29529 wxBackgroundStyle result;
29530 PyObject * obj0 = 0 ;
29531 char *kwnames[] = {
29532 (char *) "self", NULL
29533 };
29534
29535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29537 if (SWIG_arg_fail(1)) SWIG_fail;
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29541
29542 wxPyEndAllowThreads(__tstate);
29543 if (PyErr_Occurred()) SWIG_fail;
29544 }
29545 resultobj = SWIG_From_int((result));
29546 return resultobj;
29547 fail:
29548 return NULL;
29549 }
29550
29551
29552 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29553 PyObject *resultobj;
29554 wxWindow *arg1 = (wxWindow *) 0 ;
29555 bool result;
29556 PyObject * obj0 = 0 ;
29557 char *kwnames[] = {
29558 (char *) "self", NULL
29559 };
29560
29561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29563 if (SWIG_arg_fail(1)) SWIG_fail;
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 result = (bool)(arg1)->HasTransparentBackground();
29567
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 {
29572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29573 }
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj;
29582 wxWindow *arg1 = (wxWindow *) 0 ;
29583 wxCursor *arg2 = 0 ;
29584 bool result;
29585 PyObject * obj0 = 0 ;
29586 PyObject * obj1 = 0 ;
29587 char *kwnames[] = {
29588 (char *) "self",(char *) "cursor", NULL
29589 };
29590
29591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29593 if (SWIG_arg_fail(1)) SWIG_fail;
29594 {
29595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29596 if (SWIG_arg_fail(2)) SWIG_fail;
29597 if (arg2 == NULL) {
29598 SWIG_null_ref("wxCursor");
29599 }
29600 if (SWIG_arg_fail(2)) SWIG_fail;
29601 }
29602 {
29603 PyThreadState* __tstate = wxPyBeginAllowThreads();
29604 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29605
29606 wxPyEndAllowThreads(__tstate);
29607 if (PyErr_Occurred()) SWIG_fail;
29608 }
29609 {
29610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29611 }
29612 return resultobj;
29613 fail:
29614 return NULL;
29615 }
29616
29617
29618 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29619 PyObject *resultobj;
29620 wxWindow *arg1 = (wxWindow *) 0 ;
29621 wxCursor result;
29622 PyObject * obj0 = 0 ;
29623 char *kwnames[] = {
29624 (char *) "self", NULL
29625 };
29626
29627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29629 if (SWIG_arg_fail(1)) SWIG_fail;
29630 {
29631 PyThreadState* __tstate = wxPyBeginAllowThreads();
29632 result = (arg1)->GetCursor();
29633
29634 wxPyEndAllowThreads(__tstate);
29635 if (PyErr_Occurred()) SWIG_fail;
29636 }
29637 {
29638 wxCursor * resultptr;
29639 resultptr = new wxCursor((wxCursor &)(result));
29640 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29641 }
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29649 PyObject *resultobj;
29650 wxWindow *arg1 = (wxWindow *) 0 ;
29651 wxFont *arg2 = 0 ;
29652 bool result;
29653 PyObject * obj0 = 0 ;
29654 PyObject * obj1 = 0 ;
29655 char *kwnames[] = {
29656 (char *) "self",(char *) "font", NULL
29657 };
29658
29659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29661 if (SWIG_arg_fail(1)) SWIG_fail;
29662 {
29663 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29664 if (SWIG_arg_fail(2)) SWIG_fail;
29665 if (arg2 == NULL) {
29666 SWIG_null_ref("wxFont");
29667 }
29668 if (SWIG_arg_fail(2)) SWIG_fail;
29669 }
29670 {
29671 PyThreadState* __tstate = wxPyBeginAllowThreads();
29672 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29673
29674 wxPyEndAllowThreads(__tstate);
29675 if (PyErr_Occurred()) SWIG_fail;
29676 }
29677 {
29678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29679 }
29680 return resultobj;
29681 fail:
29682 return NULL;
29683 }
29684
29685
29686 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29687 PyObject *resultobj;
29688 wxWindow *arg1 = (wxWindow *) 0 ;
29689 wxFont *arg2 = 0 ;
29690 PyObject * obj0 = 0 ;
29691 PyObject * obj1 = 0 ;
29692 char *kwnames[] = {
29693 (char *) "self",(char *) "font", NULL
29694 };
29695
29696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29698 if (SWIG_arg_fail(1)) SWIG_fail;
29699 {
29700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29701 if (SWIG_arg_fail(2)) SWIG_fail;
29702 if (arg2 == NULL) {
29703 SWIG_null_ref("wxFont");
29704 }
29705 if (SWIG_arg_fail(2)) SWIG_fail;
29706 }
29707 {
29708 PyThreadState* __tstate = wxPyBeginAllowThreads();
29709 (arg1)->SetOwnFont((wxFont const &)*arg2);
29710
29711 wxPyEndAllowThreads(__tstate);
29712 if (PyErr_Occurred()) SWIG_fail;
29713 }
29714 Py_INCREF(Py_None); resultobj = Py_None;
29715 return resultobj;
29716 fail:
29717 return NULL;
29718 }
29719
29720
29721 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29722 PyObject *resultobj;
29723 wxWindow *arg1 = (wxWindow *) 0 ;
29724 wxFont result;
29725 PyObject * obj0 = 0 ;
29726 char *kwnames[] = {
29727 (char *) "self", NULL
29728 };
29729
29730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29732 if (SWIG_arg_fail(1)) SWIG_fail;
29733 {
29734 PyThreadState* __tstate = wxPyBeginAllowThreads();
29735 result = (arg1)->GetFont();
29736
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 {
29741 wxFont * resultptr;
29742 resultptr = new wxFont((wxFont &)(result));
29743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29744 }
29745 return resultobj;
29746 fail:
29747 return NULL;
29748 }
29749
29750
29751 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29752 PyObject *resultobj;
29753 wxWindow *arg1 = (wxWindow *) 0 ;
29754 wxCaret *arg2 = (wxCaret *) 0 ;
29755 PyObject * obj0 = 0 ;
29756 PyObject * obj1 = 0 ;
29757 char *kwnames[] = {
29758 (char *) "self",(char *) "caret", NULL
29759 };
29760
29761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29763 if (SWIG_arg_fail(1)) SWIG_fail;
29764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29765 if (SWIG_arg_fail(2)) SWIG_fail;
29766 {
29767 PyThreadState* __tstate = wxPyBeginAllowThreads();
29768 (arg1)->SetCaret(arg2);
29769
29770 wxPyEndAllowThreads(__tstate);
29771 if (PyErr_Occurred()) SWIG_fail;
29772 }
29773 Py_INCREF(Py_None); resultobj = Py_None;
29774 return resultobj;
29775 fail:
29776 return NULL;
29777 }
29778
29779
29780 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29781 PyObject *resultobj;
29782 wxWindow *arg1 = (wxWindow *) 0 ;
29783 wxCaret *result;
29784 PyObject * obj0 = 0 ;
29785 char *kwnames[] = {
29786 (char *) "self", NULL
29787 };
29788
29789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29791 if (SWIG_arg_fail(1)) SWIG_fail;
29792 {
29793 PyThreadState* __tstate = wxPyBeginAllowThreads();
29794 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29795
29796 wxPyEndAllowThreads(__tstate);
29797 if (PyErr_Occurred()) SWIG_fail;
29798 }
29799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29800 return resultobj;
29801 fail:
29802 return NULL;
29803 }
29804
29805
29806 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29807 PyObject *resultobj;
29808 wxWindow *arg1 = (wxWindow *) 0 ;
29809 int result;
29810 PyObject * obj0 = 0 ;
29811 char *kwnames[] = {
29812 (char *) "self", NULL
29813 };
29814
29815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29817 if (SWIG_arg_fail(1)) SWIG_fail;
29818 {
29819 PyThreadState* __tstate = wxPyBeginAllowThreads();
29820 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29821
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 {
29826 resultobj = SWIG_From_int((int)(result));
29827 }
29828 return resultobj;
29829 fail:
29830 return NULL;
29831 }
29832
29833
29834 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29835 PyObject *resultobj;
29836 wxWindow *arg1 = (wxWindow *) 0 ;
29837 int result;
29838 PyObject * obj0 = 0 ;
29839 char *kwnames[] = {
29840 (char *) "self", NULL
29841 };
29842
29843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29848 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29849
29850 wxPyEndAllowThreads(__tstate);
29851 if (PyErr_Occurred()) SWIG_fail;
29852 }
29853 {
29854 resultobj = SWIG_From_int((int)(result));
29855 }
29856 return resultobj;
29857 fail:
29858 return NULL;
29859 }
29860
29861
29862 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29863 PyObject *resultobj;
29864 wxWindow *arg1 = (wxWindow *) 0 ;
29865 wxString *arg2 = 0 ;
29866 int *arg3 = (int *) 0 ;
29867 int *arg4 = (int *) 0 ;
29868 bool temp2 = false ;
29869 int temp3 ;
29870 int res3 = 0 ;
29871 int temp4 ;
29872 int res4 = 0 ;
29873 PyObject * obj0 = 0 ;
29874 PyObject * obj1 = 0 ;
29875 char *kwnames[] = {
29876 (char *) "self",(char *) "string", NULL
29877 };
29878
29879 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29880 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29883 if (SWIG_arg_fail(1)) SWIG_fail;
29884 {
29885 arg2 = wxString_in_helper(obj1);
29886 if (arg2 == NULL) SWIG_fail;
29887 temp2 = true;
29888 }
29889 {
29890 PyThreadState* __tstate = wxPyBeginAllowThreads();
29891 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29892
29893 wxPyEndAllowThreads(__tstate);
29894 if (PyErr_Occurred()) SWIG_fail;
29895 }
29896 Py_INCREF(Py_None); resultobj = Py_None;
29897 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29898 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29899 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29900 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29901 {
29902 if (temp2)
29903 delete arg2;
29904 }
29905 return resultobj;
29906 fail:
29907 {
29908 if (temp2)
29909 delete arg2;
29910 }
29911 return NULL;
29912 }
29913
29914
29915 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29916 PyObject *resultobj;
29917 wxWindow *arg1 = (wxWindow *) 0 ;
29918 wxString *arg2 = 0 ;
29919 int *arg3 = (int *) 0 ;
29920 int *arg4 = (int *) 0 ;
29921 int *arg5 = (int *) 0 ;
29922 int *arg6 = (int *) 0 ;
29923 wxFont *arg7 = (wxFont *) NULL ;
29924 bool temp2 = false ;
29925 int temp3 ;
29926 int res3 = 0 ;
29927 int temp4 ;
29928 int res4 = 0 ;
29929 int temp5 ;
29930 int res5 = 0 ;
29931 int temp6 ;
29932 int res6 = 0 ;
29933 PyObject * obj0 = 0 ;
29934 PyObject * obj1 = 0 ;
29935 PyObject * obj2 = 0 ;
29936 char *kwnames[] = {
29937 (char *) "self",(char *) "string",(char *) "font", NULL
29938 };
29939
29940 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29941 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29942 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29943 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29946 if (SWIG_arg_fail(1)) SWIG_fail;
29947 {
29948 arg2 = wxString_in_helper(obj1);
29949 if (arg2 == NULL) SWIG_fail;
29950 temp2 = true;
29951 }
29952 if (obj2) {
29953 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29954 if (SWIG_arg_fail(7)) SWIG_fail;
29955 }
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29959
29960 wxPyEndAllowThreads(__tstate);
29961 if (PyErr_Occurred()) SWIG_fail;
29962 }
29963 Py_INCREF(Py_None); resultobj = Py_None;
29964 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29965 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29966 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29967 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29968 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29969 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29970 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29971 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29972 {
29973 if (temp2)
29974 delete arg2;
29975 }
29976 return resultobj;
29977 fail:
29978 {
29979 if (temp2)
29980 delete arg2;
29981 }
29982 return NULL;
29983 }
29984
29985
29986 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29987 PyObject *resultobj;
29988 wxWindow *arg1 = (wxWindow *) 0 ;
29989 int *arg2 = (int *) 0 ;
29990 int *arg3 = (int *) 0 ;
29991 int temp2 ;
29992 int res2 = 0 ;
29993 int temp3 ;
29994 int res3 = 0 ;
29995 PyObject * obj0 = 0 ;
29996 PyObject * obj1 = 0 ;
29997 PyObject * obj2 = 0 ;
29998 char *kwnames[] = {
29999 (char *) "self",(char *) "x",(char *) "y", NULL
30000 };
30001
30002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30004 if (SWIG_arg_fail(1)) SWIG_fail;
30005 {
30006 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30007 temp2 = SWIG_As_int(obj1);
30008 if (SWIG_arg_fail(2)) SWIG_fail;
30009 arg2 = &temp2;
30010 res2 = SWIG_NEWOBJ;
30011 }
30012 }
30013 {
30014 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30015 temp3 = SWIG_As_int(obj2);
30016 if (SWIG_arg_fail(3)) SWIG_fail;
30017 arg3 = &temp3;
30018 res3 = SWIG_NEWOBJ;
30019 }
30020 }
30021 {
30022 PyThreadState* __tstate = wxPyBeginAllowThreads();
30023 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30024
30025 wxPyEndAllowThreads(__tstate);
30026 if (PyErr_Occurred()) SWIG_fail;
30027 }
30028 Py_INCREF(Py_None); resultobj = Py_None;
30029 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30030 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30031 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30032 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30033 return resultobj;
30034 fail:
30035 return NULL;
30036 }
30037
30038
30039 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30040 PyObject *resultobj;
30041 wxWindow *arg1 = (wxWindow *) 0 ;
30042 int *arg2 = (int *) 0 ;
30043 int *arg3 = (int *) 0 ;
30044 int temp2 ;
30045 int res2 = 0 ;
30046 int temp3 ;
30047 int res3 = 0 ;
30048 PyObject * obj0 = 0 ;
30049 PyObject * obj1 = 0 ;
30050 PyObject * obj2 = 0 ;
30051 char *kwnames[] = {
30052 (char *) "self",(char *) "x",(char *) "y", NULL
30053 };
30054
30055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30057 if (SWIG_arg_fail(1)) SWIG_fail;
30058 {
30059 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30060 temp2 = SWIG_As_int(obj1);
30061 if (SWIG_arg_fail(2)) SWIG_fail;
30062 arg2 = &temp2;
30063 res2 = SWIG_NEWOBJ;
30064 }
30065 }
30066 {
30067 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30068 temp3 = SWIG_As_int(obj2);
30069 if (SWIG_arg_fail(3)) SWIG_fail;
30070 arg3 = &temp3;
30071 res3 = SWIG_NEWOBJ;
30072 }
30073 }
30074 {
30075 PyThreadState* __tstate = wxPyBeginAllowThreads();
30076 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30077
30078 wxPyEndAllowThreads(__tstate);
30079 if (PyErr_Occurred()) SWIG_fail;
30080 }
30081 Py_INCREF(Py_None); resultobj = Py_None;
30082 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30083 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30084 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30085 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30086 return resultobj;
30087 fail:
30088 return NULL;
30089 }
30090
30091
30092 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30093 PyObject *resultobj;
30094 wxWindow *arg1 = (wxWindow *) 0 ;
30095 wxPoint *arg2 = 0 ;
30096 wxPoint result;
30097 wxPoint temp2 ;
30098 PyObject * obj0 = 0 ;
30099 PyObject * obj1 = 0 ;
30100 char *kwnames[] = {
30101 (char *) "self",(char *) "pt", NULL
30102 };
30103
30104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30106 if (SWIG_arg_fail(1)) SWIG_fail;
30107 {
30108 arg2 = &temp2;
30109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30110 }
30111 {
30112 PyThreadState* __tstate = wxPyBeginAllowThreads();
30113 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30114
30115 wxPyEndAllowThreads(__tstate);
30116 if (PyErr_Occurred()) SWIG_fail;
30117 }
30118 {
30119 wxPoint * resultptr;
30120 resultptr = new wxPoint((wxPoint &)(result));
30121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30122 }
30123 return resultobj;
30124 fail:
30125 return NULL;
30126 }
30127
30128
30129 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30130 PyObject *resultobj;
30131 wxWindow *arg1 = (wxWindow *) 0 ;
30132 wxPoint *arg2 = 0 ;
30133 wxPoint result;
30134 wxPoint temp2 ;
30135 PyObject * obj0 = 0 ;
30136 PyObject * obj1 = 0 ;
30137 char *kwnames[] = {
30138 (char *) "self",(char *) "pt", NULL
30139 };
30140
30141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30143 if (SWIG_arg_fail(1)) SWIG_fail;
30144 {
30145 arg2 = &temp2;
30146 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30147 }
30148 {
30149 PyThreadState* __tstate = wxPyBeginAllowThreads();
30150 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30151
30152 wxPyEndAllowThreads(__tstate);
30153 if (PyErr_Occurred()) SWIG_fail;
30154 }
30155 {
30156 wxPoint * resultptr;
30157 resultptr = new wxPoint((wxPoint &)(result));
30158 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30159 }
30160 return resultobj;
30161 fail:
30162 return NULL;
30163 }
30164
30165
30166 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30167 PyObject *resultobj;
30168 wxWindow *arg1 = (wxWindow *) 0 ;
30169 int arg2 ;
30170 int arg3 ;
30171 wxHitTest result;
30172 PyObject * obj0 = 0 ;
30173 PyObject * obj1 = 0 ;
30174 PyObject * obj2 = 0 ;
30175 char *kwnames[] = {
30176 (char *) "self",(char *) "x",(char *) "y", NULL
30177 };
30178
30179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30181 if (SWIG_arg_fail(1)) SWIG_fail;
30182 {
30183 arg2 = (int)(SWIG_As_int(obj1));
30184 if (SWIG_arg_fail(2)) SWIG_fail;
30185 }
30186 {
30187 arg3 = (int)(SWIG_As_int(obj2));
30188 if (SWIG_arg_fail(3)) SWIG_fail;
30189 }
30190 {
30191 PyThreadState* __tstate = wxPyBeginAllowThreads();
30192 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30193
30194 wxPyEndAllowThreads(__tstate);
30195 if (PyErr_Occurred()) SWIG_fail;
30196 }
30197 resultobj = SWIG_From_int((result));
30198 return resultobj;
30199 fail:
30200 return NULL;
30201 }
30202
30203
30204 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30205 PyObject *resultobj;
30206 wxWindow *arg1 = (wxWindow *) 0 ;
30207 wxPoint *arg2 = 0 ;
30208 wxHitTest result;
30209 wxPoint temp2 ;
30210 PyObject * obj0 = 0 ;
30211 PyObject * obj1 = 0 ;
30212 char *kwnames[] = {
30213 (char *) "self",(char *) "pt", NULL
30214 };
30215
30216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30218 if (SWIG_arg_fail(1)) SWIG_fail;
30219 {
30220 arg2 = &temp2;
30221 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30222 }
30223 {
30224 PyThreadState* __tstate = wxPyBeginAllowThreads();
30225 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30226
30227 wxPyEndAllowThreads(__tstate);
30228 if (PyErr_Occurred()) SWIG_fail;
30229 }
30230 resultobj = SWIG_From_int((result));
30231 return resultobj;
30232 fail:
30233 return NULL;
30234 }
30235
30236
30237 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30238 PyObject *resultobj;
30239 wxWindow *arg1 = (wxWindow *) 0 ;
30240 long arg2 ;
30241 wxBorder result;
30242 PyObject * obj0 = 0 ;
30243 PyObject * obj1 = 0 ;
30244
30245 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30247 if (SWIG_arg_fail(1)) SWIG_fail;
30248 {
30249 arg2 = (long)(SWIG_As_long(obj1));
30250 if (SWIG_arg_fail(2)) SWIG_fail;
30251 }
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30255
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 resultobj = SWIG_From_int((result));
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30267 PyObject *resultobj;
30268 wxWindow *arg1 = (wxWindow *) 0 ;
30269 wxBorder result;
30270 PyObject * obj0 = 0 ;
30271
30272 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30274 if (SWIG_arg_fail(1)) SWIG_fail;
30275 {
30276 PyThreadState* __tstate = wxPyBeginAllowThreads();
30277 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30278
30279 wxPyEndAllowThreads(__tstate);
30280 if (PyErr_Occurred()) SWIG_fail;
30281 }
30282 resultobj = SWIG_From_int((result));
30283 return resultobj;
30284 fail:
30285 return NULL;
30286 }
30287
30288
30289 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30290 int argc;
30291 PyObject *argv[3];
30292 int ii;
30293
30294 argc = PyObject_Length(args);
30295 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30296 argv[ii] = PyTuple_GetItem(args,ii);
30297 }
30298 if (argc == 1) {
30299 int _v;
30300 {
30301 void *ptr;
30302 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30303 _v = 0;
30304 PyErr_Clear();
30305 } else {
30306 _v = 1;
30307 }
30308 }
30309 if (_v) {
30310 return _wrap_Window_GetBorder__SWIG_1(self,args);
30311 }
30312 }
30313 if (argc == 2) {
30314 int _v;
30315 {
30316 void *ptr;
30317 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30318 _v = 0;
30319 PyErr_Clear();
30320 } else {
30321 _v = 1;
30322 }
30323 }
30324 if (_v) {
30325 _v = SWIG_Check_long(argv[1]);
30326 if (_v) {
30327 return _wrap_Window_GetBorder__SWIG_0(self,args);
30328 }
30329 }
30330 }
30331
30332 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30333 return NULL;
30334 }
30335
30336
30337 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30338 PyObject *resultobj;
30339 wxWindow *arg1 = (wxWindow *) 0 ;
30340 long arg2 = (long) wxUPDATE_UI_NONE ;
30341 PyObject * obj0 = 0 ;
30342 PyObject * obj1 = 0 ;
30343 char *kwnames[] = {
30344 (char *) "self",(char *) "flags", NULL
30345 };
30346
30347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30349 if (SWIG_arg_fail(1)) SWIG_fail;
30350 if (obj1) {
30351 {
30352 arg2 = (long)(SWIG_As_long(obj1));
30353 if (SWIG_arg_fail(2)) SWIG_fail;
30354 }
30355 }
30356 {
30357 PyThreadState* __tstate = wxPyBeginAllowThreads();
30358 (arg1)->UpdateWindowUI(arg2);
30359
30360 wxPyEndAllowThreads(__tstate);
30361 if (PyErr_Occurred()) SWIG_fail;
30362 }
30363 Py_INCREF(Py_None); resultobj = Py_None;
30364 return resultobj;
30365 fail:
30366 return NULL;
30367 }
30368
30369
30370 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30371 PyObject *resultobj;
30372 wxWindow *arg1 = (wxWindow *) 0 ;
30373 wxMenu *arg2 = (wxMenu *) 0 ;
30374 int arg3 = (int) -1 ;
30375 int arg4 = (int) -1 ;
30376 bool result;
30377 PyObject * obj0 = 0 ;
30378 PyObject * obj1 = 0 ;
30379 PyObject * obj2 = 0 ;
30380 PyObject * obj3 = 0 ;
30381 char *kwnames[] = {
30382 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30383 };
30384
30385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30387 if (SWIG_arg_fail(1)) SWIG_fail;
30388 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30389 if (SWIG_arg_fail(2)) SWIG_fail;
30390 if (obj2) {
30391 {
30392 arg3 = (int)(SWIG_As_int(obj2));
30393 if (SWIG_arg_fail(3)) SWIG_fail;
30394 }
30395 }
30396 if (obj3) {
30397 {
30398 arg4 = (int)(SWIG_As_int(obj3));
30399 if (SWIG_arg_fail(4)) SWIG_fail;
30400 }
30401 }
30402 {
30403 PyThreadState* __tstate = wxPyBeginAllowThreads();
30404 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30405
30406 wxPyEndAllowThreads(__tstate);
30407 if (PyErr_Occurred()) SWIG_fail;
30408 }
30409 {
30410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30411 }
30412 return resultobj;
30413 fail:
30414 return NULL;
30415 }
30416
30417
30418 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30419 PyObject *resultobj;
30420 wxWindow *arg1 = (wxWindow *) 0 ;
30421 wxMenu *arg2 = (wxMenu *) 0 ;
30422 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30423 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30424 bool result;
30425 wxPoint temp3 ;
30426 PyObject * obj0 = 0 ;
30427 PyObject * obj1 = 0 ;
30428 PyObject * obj2 = 0 ;
30429 char *kwnames[] = {
30430 (char *) "self",(char *) "menu",(char *) "pos", NULL
30431 };
30432
30433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30435 if (SWIG_arg_fail(1)) SWIG_fail;
30436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30437 if (SWIG_arg_fail(2)) SWIG_fail;
30438 if (obj2) {
30439 {
30440 arg3 = &temp3;
30441 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30442 }
30443 }
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30447
30448 wxPyEndAllowThreads(__tstate);
30449 if (PyErr_Occurred()) SWIG_fail;
30450 }
30451 {
30452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30453 }
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30461 PyObject *resultobj;
30462 wxWindow *arg1 = (wxWindow *) 0 ;
30463 long result;
30464 PyObject * obj0 = 0 ;
30465 char *kwnames[] = {
30466 (char *) "self", NULL
30467 };
30468
30469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30471 if (SWIG_arg_fail(1)) SWIG_fail;
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 result = (long)wxWindow_GetHandle(arg1);
30475
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 {
30480 resultobj = SWIG_From_long((long)(result));
30481 }
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj;
30490 wxWindow *arg1 = (wxWindow *) 0 ;
30491 long arg2 ;
30492 PyObject * obj0 = 0 ;
30493 PyObject * obj1 = 0 ;
30494 char *kwnames[] = {
30495 (char *) "self",(char *) "handle", NULL
30496 };
30497
30498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30500 if (SWIG_arg_fail(1)) SWIG_fail;
30501 {
30502 arg2 = (long)(SWIG_As_long(obj1));
30503 if (SWIG_arg_fail(2)) SWIG_fail;
30504 }
30505 {
30506 PyThreadState* __tstate = wxPyBeginAllowThreads();
30507 wxWindow_AssociateHandle(arg1,arg2);
30508
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 Py_INCREF(Py_None); resultobj = Py_None;
30513 return resultobj;
30514 fail:
30515 return NULL;
30516 }
30517
30518
30519 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30520 PyObject *resultobj;
30521 wxWindow *arg1 = (wxWindow *) 0 ;
30522 PyObject * obj0 = 0 ;
30523 char *kwnames[] = {
30524 (char *) "self", NULL
30525 };
30526
30527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30529 if (SWIG_arg_fail(1)) SWIG_fail;
30530 {
30531 PyThreadState* __tstate = wxPyBeginAllowThreads();
30532 (arg1)->DissociateHandle();
30533
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 Py_INCREF(Py_None); resultobj = Py_None;
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj;
30546 wxWindow *arg1 = (wxWindow *) 0 ;
30547 wxPaintEvent *arg2 = 0 ;
30548 PyObject * obj0 = 0 ;
30549 PyObject * obj1 = 0 ;
30550 char *kwnames[] = {
30551 (char *) "self",(char *) "event", NULL
30552 };
30553
30554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30556 if (SWIG_arg_fail(1)) SWIG_fail;
30557 {
30558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30559 if (SWIG_arg_fail(2)) SWIG_fail;
30560 if (arg2 == NULL) {
30561 SWIG_null_ref("wxPaintEvent");
30562 }
30563 if (SWIG_arg_fail(2)) SWIG_fail;
30564 }
30565 {
30566 PyThreadState* __tstate = wxPyBeginAllowThreads();
30567 (arg1)->OnPaint(*arg2);
30568
30569 wxPyEndAllowThreads(__tstate);
30570 if (PyErr_Occurred()) SWIG_fail;
30571 }
30572 Py_INCREF(Py_None); resultobj = Py_None;
30573 return resultobj;
30574 fail:
30575 return NULL;
30576 }
30577
30578
30579 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30580 PyObject *resultobj;
30581 wxWindow *arg1 = (wxWindow *) 0 ;
30582 int arg2 ;
30583 bool result;
30584 PyObject * obj0 = 0 ;
30585 PyObject * obj1 = 0 ;
30586 char *kwnames[] = {
30587 (char *) "self",(char *) "orient", NULL
30588 };
30589
30590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30592 if (SWIG_arg_fail(1)) SWIG_fail;
30593 {
30594 arg2 = (int)(SWIG_As_int(obj1));
30595 if (SWIG_arg_fail(2)) SWIG_fail;
30596 }
30597 {
30598 PyThreadState* __tstate = wxPyBeginAllowThreads();
30599 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30600
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 {
30605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30606 }
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30614 PyObject *resultobj;
30615 wxWindow *arg1 = (wxWindow *) 0 ;
30616 int arg2 ;
30617 int arg3 ;
30618 int arg4 ;
30619 int arg5 ;
30620 bool arg6 = (bool) true ;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 PyObject * obj2 = 0 ;
30624 PyObject * obj3 = 0 ;
30625 PyObject * obj4 = 0 ;
30626 PyObject * obj5 = 0 ;
30627 char *kwnames[] = {
30628 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30629 };
30630
30631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30633 if (SWIG_arg_fail(1)) SWIG_fail;
30634 {
30635 arg2 = (int)(SWIG_As_int(obj1));
30636 if (SWIG_arg_fail(2)) SWIG_fail;
30637 }
30638 {
30639 arg3 = (int)(SWIG_As_int(obj2));
30640 if (SWIG_arg_fail(3)) SWIG_fail;
30641 }
30642 {
30643 arg4 = (int)(SWIG_As_int(obj3));
30644 if (SWIG_arg_fail(4)) SWIG_fail;
30645 }
30646 {
30647 arg5 = (int)(SWIG_As_int(obj4));
30648 if (SWIG_arg_fail(5)) SWIG_fail;
30649 }
30650 if (obj5) {
30651 {
30652 arg6 = (bool)(SWIG_As_bool(obj5));
30653 if (SWIG_arg_fail(6)) SWIG_fail;
30654 }
30655 }
30656 {
30657 PyThreadState* __tstate = wxPyBeginAllowThreads();
30658 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30659
30660 wxPyEndAllowThreads(__tstate);
30661 if (PyErr_Occurred()) SWIG_fail;
30662 }
30663 Py_INCREF(Py_None); resultobj = Py_None;
30664 return resultobj;
30665 fail:
30666 return NULL;
30667 }
30668
30669
30670 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30671 PyObject *resultobj;
30672 wxWindow *arg1 = (wxWindow *) 0 ;
30673 int arg2 ;
30674 int arg3 ;
30675 bool arg4 = (bool) true ;
30676 PyObject * obj0 = 0 ;
30677 PyObject * obj1 = 0 ;
30678 PyObject * obj2 = 0 ;
30679 PyObject * obj3 = 0 ;
30680 char *kwnames[] = {
30681 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30682 };
30683
30684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30686 if (SWIG_arg_fail(1)) SWIG_fail;
30687 {
30688 arg2 = (int)(SWIG_As_int(obj1));
30689 if (SWIG_arg_fail(2)) SWIG_fail;
30690 }
30691 {
30692 arg3 = (int)(SWIG_As_int(obj2));
30693 if (SWIG_arg_fail(3)) SWIG_fail;
30694 }
30695 if (obj3) {
30696 {
30697 arg4 = (bool)(SWIG_As_bool(obj3));
30698 if (SWIG_arg_fail(4)) SWIG_fail;
30699 }
30700 }
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 (arg1)->SetScrollPos(arg2,arg3,arg4);
30704
30705 wxPyEndAllowThreads(__tstate);
30706 if (PyErr_Occurred()) SWIG_fail;
30707 }
30708 Py_INCREF(Py_None); resultobj = Py_None;
30709 return resultobj;
30710 fail:
30711 return NULL;
30712 }
30713
30714
30715 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30716 PyObject *resultobj;
30717 wxWindow *arg1 = (wxWindow *) 0 ;
30718 int arg2 ;
30719 int result;
30720 PyObject * obj0 = 0 ;
30721 PyObject * obj1 = 0 ;
30722 char *kwnames[] = {
30723 (char *) "self",(char *) "orientation", NULL
30724 };
30725
30726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30728 if (SWIG_arg_fail(1)) SWIG_fail;
30729 {
30730 arg2 = (int)(SWIG_As_int(obj1));
30731 if (SWIG_arg_fail(2)) SWIG_fail;
30732 }
30733 {
30734 PyThreadState* __tstate = wxPyBeginAllowThreads();
30735 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30736
30737 wxPyEndAllowThreads(__tstate);
30738 if (PyErr_Occurred()) SWIG_fail;
30739 }
30740 {
30741 resultobj = SWIG_From_int((int)(result));
30742 }
30743 return resultobj;
30744 fail:
30745 return NULL;
30746 }
30747
30748
30749 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30750 PyObject *resultobj;
30751 wxWindow *arg1 = (wxWindow *) 0 ;
30752 int arg2 ;
30753 int result;
30754 PyObject * obj0 = 0 ;
30755 PyObject * obj1 = 0 ;
30756 char *kwnames[] = {
30757 (char *) "self",(char *) "orientation", NULL
30758 };
30759
30760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
30765 if (SWIG_arg_fail(2)) SWIG_fail;
30766 }
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30770
30771 wxPyEndAllowThreads(__tstate);
30772 if (PyErr_Occurred()) SWIG_fail;
30773 }
30774 {
30775 resultobj = SWIG_From_int((int)(result));
30776 }
30777 return resultobj;
30778 fail:
30779 return NULL;
30780 }
30781
30782
30783 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30784 PyObject *resultobj;
30785 wxWindow *arg1 = (wxWindow *) 0 ;
30786 int arg2 ;
30787 int result;
30788 PyObject * obj0 = 0 ;
30789 PyObject * obj1 = 0 ;
30790 char *kwnames[] = {
30791 (char *) "self",(char *) "orientation", NULL
30792 };
30793
30794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30796 if (SWIG_arg_fail(1)) SWIG_fail;
30797 {
30798 arg2 = (int)(SWIG_As_int(obj1));
30799 if (SWIG_arg_fail(2)) SWIG_fail;
30800 }
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30804
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 {
30809 resultobj = SWIG_From_int((int)(result));
30810 }
30811 return resultobj;
30812 fail:
30813 return NULL;
30814 }
30815
30816
30817 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30818 PyObject *resultobj;
30819 wxWindow *arg1 = (wxWindow *) 0 ;
30820 int arg2 ;
30821 int arg3 ;
30822 wxRect *arg4 = (wxRect *) NULL ;
30823 PyObject * obj0 = 0 ;
30824 PyObject * obj1 = 0 ;
30825 PyObject * obj2 = 0 ;
30826 PyObject * obj3 = 0 ;
30827 char *kwnames[] = {
30828 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30829 };
30830
30831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30833 if (SWIG_arg_fail(1)) SWIG_fail;
30834 {
30835 arg2 = (int)(SWIG_As_int(obj1));
30836 if (SWIG_arg_fail(2)) SWIG_fail;
30837 }
30838 {
30839 arg3 = (int)(SWIG_As_int(obj2));
30840 if (SWIG_arg_fail(3)) SWIG_fail;
30841 }
30842 if (obj3) {
30843 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30844 if (SWIG_arg_fail(4)) SWIG_fail;
30845 }
30846 {
30847 PyThreadState* __tstate = wxPyBeginAllowThreads();
30848 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30849
30850 wxPyEndAllowThreads(__tstate);
30851 if (PyErr_Occurred()) SWIG_fail;
30852 }
30853 Py_INCREF(Py_None); resultobj = Py_None;
30854 return resultobj;
30855 fail:
30856 return NULL;
30857 }
30858
30859
30860 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30861 PyObject *resultobj;
30862 wxWindow *arg1 = (wxWindow *) 0 ;
30863 int arg2 ;
30864 bool result;
30865 PyObject * obj0 = 0 ;
30866 PyObject * obj1 = 0 ;
30867 char *kwnames[] = {
30868 (char *) "self",(char *) "lines", NULL
30869 };
30870
30871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30873 if (SWIG_arg_fail(1)) SWIG_fail;
30874 {
30875 arg2 = (int)(SWIG_As_int(obj1));
30876 if (SWIG_arg_fail(2)) SWIG_fail;
30877 }
30878 {
30879 PyThreadState* __tstate = wxPyBeginAllowThreads();
30880 result = (bool)(arg1)->ScrollLines(arg2);
30881
30882 wxPyEndAllowThreads(__tstate);
30883 if (PyErr_Occurred()) SWIG_fail;
30884 }
30885 {
30886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30887 }
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30895 PyObject *resultobj;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 int arg2 ;
30898 bool result;
30899 PyObject * obj0 = 0 ;
30900 PyObject * obj1 = 0 ;
30901 char *kwnames[] = {
30902 (char *) "self",(char *) "pages", NULL
30903 };
30904
30905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30907 if (SWIG_arg_fail(1)) SWIG_fail;
30908 {
30909 arg2 = (int)(SWIG_As_int(obj1));
30910 if (SWIG_arg_fail(2)) SWIG_fail;
30911 }
30912 {
30913 PyThreadState* __tstate = wxPyBeginAllowThreads();
30914 result = (bool)(arg1)->ScrollPages(arg2);
30915
30916 wxPyEndAllowThreads(__tstate);
30917 if (PyErr_Occurred()) SWIG_fail;
30918 }
30919 {
30920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30921 }
30922 return resultobj;
30923 fail:
30924 return NULL;
30925 }
30926
30927
30928 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30929 PyObject *resultobj;
30930 wxWindow *arg1 = (wxWindow *) 0 ;
30931 bool result;
30932 PyObject * obj0 = 0 ;
30933 char *kwnames[] = {
30934 (char *) "self", NULL
30935 };
30936
30937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30939 if (SWIG_arg_fail(1)) SWIG_fail;
30940 {
30941 PyThreadState* __tstate = wxPyBeginAllowThreads();
30942 result = (bool)(arg1)->LineUp();
30943
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 {
30948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30949 }
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 bool result;
30960 PyObject * obj0 = 0 ;
30961 char *kwnames[] = {
30962 (char *) "self", NULL
30963 };
30964
30965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30967 if (SWIG_arg_fail(1)) SWIG_fail;
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 result = (bool)(arg1)->LineDown();
30971
30972 wxPyEndAllowThreads(__tstate);
30973 if (PyErr_Occurred()) SWIG_fail;
30974 }
30975 {
30976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30977 }
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30985 PyObject *resultobj;
30986 wxWindow *arg1 = (wxWindow *) 0 ;
30987 bool result;
30988 PyObject * obj0 = 0 ;
30989 char *kwnames[] = {
30990 (char *) "self", NULL
30991 };
30992
30993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30995 if (SWIG_arg_fail(1)) SWIG_fail;
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 result = (bool)(arg1)->PageUp();
30999
31000 wxPyEndAllowThreads(__tstate);
31001 if (PyErr_Occurred()) SWIG_fail;
31002 }
31003 {
31004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31005 }
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31013 PyObject *resultobj;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 bool result;
31016 PyObject * obj0 = 0 ;
31017 char *kwnames[] = {
31018 (char *) "self", NULL
31019 };
31020
31021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31023 if (SWIG_arg_fail(1)) SWIG_fail;
31024 {
31025 PyThreadState* __tstate = wxPyBeginAllowThreads();
31026 result = (bool)(arg1)->PageDown();
31027
31028 wxPyEndAllowThreads(__tstate);
31029 if (PyErr_Occurred()) SWIG_fail;
31030 }
31031 {
31032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31033 }
31034 return resultobj;
31035 fail:
31036 return NULL;
31037 }
31038
31039
31040 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31041 PyObject *resultobj;
31042 wxWindow *arg1 = (wxWindow *) 0 ;
31043 wxString *arg2 = 0 ;
31044 bool temp2 = false ;
31045 PyObject * obj0 = 0 ;
31046 PyObject * obj1 = 0 ;
31047 char *kwnames[] = {
31048 (char *) "self",(char *) "text", NULL
31049 };
31050
31051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31053 if (SWIG_arg_fail(1)) SWIG_fail;
31054 {
31055 arg2 = wxString_in_helper(obj1);
31056 if (arg2 == NULL) SWIG_fail;
31057 temp2 = true;
31058 }
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 (arg1)->SetHelpText((wxString const &)*arg2);
31062
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 Py_INCREF(Py_None); resultobj = Py_None;
31067 {
31068 if (temp2)
31069 delete arg2;
31070 }
31071 return resultobj;
31072 fail:
31073 {
31074 if (temp2)
31075 delete arg2;
31076 }
31077 return NULL;
31078 }
31079
31080
31081 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31082 PyObject *resultobj;
31083 wxWindow *arg1 = (wxWindow *) 0 ;
31084 wxString *arg2 = 0 ;
31085 bool temp2 = false ;
31086 PyObject * obj0 = 0 ;
31087 PyObject * obj1 = 0 ;
31088 char *kwnames[] = {
31089 (char *) "self",(char *) "text", NULL
31090 };
31091
31092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31094 if (SWIG_arg_fail(1)) SWIG_fail;
31095 {
31096 arg2 = wxString_in_helper(obj1);
31097 if (arg2 == NULL) SWIG_fail;
31098 temp2 = true;
31099 }
31100 {
31101 PyThreadState* __tstate = wxPyBeginAllowThreads();
31102 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31103
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 Py_INCREF(Py_None); resultobj = Py_None;
31108 {
31109 if (temp2)
31110 delete arg2;
31111 }
31112 return resultobj;
31113 fail:
31114 {
31115 if (temp2)
31116 delete arg2;
31117 }
31118 return NULL;
31119 }
31120
31121
31122 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31123 PyObject *resultobj;
31124 wxWindow *arg1 = (wxWindow *) 0 ;
31125 wxString result;
31126 PyObject * obj0 = 0 ;
31127 char *kwnames[] = {
31128 (char *) "self", NULL
31129 };
31130
31131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31133 if (SWIG_arg_fail(1)) SWIG_fail;
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 result = ((wxWindow const *)arg1)->GetHelpText();
31137
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 {
31142 #if wxUSE_UNICODE
31143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31144 #else
31145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31146 #endif
31147 }
31148 return resultobj;
31149 fail:
31150 return NULL;
31151 }
31152
31153
31154 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31155 PyObject *resultobj;
31156 wxWindow *arg1 = (wxWindow *) 0 ;
31157 wxString *arg2 = 0 ;
31158 bool temp2 = false ;
31159 PyObject * obj0 = 0 ;
31160 PyObject * obj1 = 0 ;
31161 char *kwnames[] = {
31162 (char *) "self",(char *) "tip", NULL
31163 };
31164
31165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31167 if (SWIG_arg_fail(1)) SWIG_fail;
31168 {
31169 arg2 = wxString_in_helper(obj1);
31170 if (arg2 == NULL) SWIG_fail;
31171 temp2 = true;
31172 }
31173 {
31174 PyThreadState* __tstate = wxPyBeginAllowThreads();
31175 (arg1)->SetToolTip((wxString const &)*arg2);
31176
31177 wxPyEndAllowThreads(__tstate);
31178 if (PyErr_Occurred()) SWIG_fail;
31179 }
31180 Py_INCREF(Py_None); resultobj = Py_None;
31181 {
31182 if (temp2)
31183 delete arg2;
31184 }
31185 return resultobj;
31186 fail:
31187 {
31188 if (temp2)
31189 delete arg2;
31190 }
31191 return NULL;
31192 }
31193
31194
31195 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31196 PyObject *resultobj;
31197 wxWindow *arg1 = (wxWindow *) 0 ;
31198 wxToolTip *arg2 = (wxToolTip *) 0 ;
31199 PyObject * obj0 = 0 ;
31200 PyObject * obj1 = 0 ;
31201 char *kwnames[] = {
31202 (char *) "self",(char *) "tip", NULL
31203 };
31204
31205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31207 if (SWIG_arg_fail(1)) SWIG_fail;
31208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31209 if (SWIG_arg_fail(2)) SWIG_fail;
31210 {
31211 PyThreadState* __tstate = wxPyBeginAllowThreads();
31212 (arg1)->SetToolTip(arg2);
31213
31214 wxPyEndAllowThreads(__tstate);
31215 if (PyErr_Occurred()) SWIG_fail;
31216 }
31217 Py_INCREF(Py_None); resultobj = Py_None;
31218 return resultobj;
31219 fail:
31220 return NULL;
31221 }
31222
31223
31224 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31225 PyObject *resultobj;
31226 wxWindow *arg1 = (wxWindow *) 0 ;
31227 wxToolTip *result;
31228 PyObject * obj0 = 0 ;
31229 char *kwnames[] = {
31230 (char *) "self", NULL
31231 };
31232
31233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31235 if (SWIG_arg_fail(1)) SWIG_fail;
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31239
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 {
31244 resultobj = wxPyMake_wxObject(result, 0);
31245 }
31246 return resultobj;
31247 fail:
31248 return NULL;
31249 }
31250
31251
31252 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31253 PyObject *resultobj;
31254 wxWindow *arg1 = (wxWindow *) 0 ;
31255 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31256 PyObject * obj0 = 0 ;
31257 PyObject * obj1 = 0 ;
31258 char *kwnames[] = {
31259 (char *) "self",(char *) "dropTarget", NULL
31260 };
31261
31262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31264 if (SWIG_arg_fail(1)) SWIG_fail;
31265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31266 if (SWIG_arg_fail(2)) SWIG_fail;
31267 {
31268 PyThreadState* __tstate = wxPyBeginAllowThreads();
31269 (arg1)->SetDropTarget(arg2);
31270
31271 wxPyEndAllowThreads(__tstate);
31272 if (PyErr_Occurred()) SWIG_fail;
31273 }
31274 Py_INCREF(Py_None); resultobj = Py_None;
31275 return resultobj;
31276 fail:
31277 return NULL;
31278 }
31279
31280
31281 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31282 PyObject *resultobj;
31283 wxWindow *arg1 = (wxWindow *) 0 ;
31284 wxPyDropTarget *result;
31285 PyObject * obj0 = 0 ;
31286 char *kwnames[] = {
31287 (char *) "self", NULL
31288 };
31289
31290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31292 if (SWIG_arg_fail(1)) SWIG_fail;
31293 {
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31296
31297 wxPyEndAllowThreads(__tstate);
31298 if (PyErr_Occurred()) SWIG_fail;
31299 }
31300 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31301 return resultobj;
31302 fail:
31303 return NULL;
31304 }
31305
31306
31307 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31308 PyObject *resultobj;
31309 wxWindow *arg1 = (wxWindow *) 0 ;
31310 bool arg2 ;
31311 PyObject * obj0 = 0 ;
31312 PyObject * obj1 = 0 ;
31313 char *kwnames[] = {
31314 (char *) "self",(char *) "accept", NULL
31315 };
31316
31317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31319 if (SWIG_arg_fail(1)) SWIG_fail;
31320 {
31321 arg2 = (bool)(SWIG_As_bool(obj1));
31322 if (SWIG_arg_fail(2)) SWIG_fail;
31323 }
31324 {
31325 PyThreadState* __tstate = wxPyBeginAllowThreads();
31326 (arg1)->DragAcceptFiles(arg2);
31327
31328 wxPyEndAllowThreads(__tstate);
31329 if (PyErr_Occurred()) SWIG_fail;
31330 }
31331 Py_INCREF(Py_None); resultobj = Py_None;
31332 return resultobj;
31333 fail:
31334 return NULL;
31335 }
31336
31337
31338 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31339 PyObject *resultobj;
31340 wxWindow *arg1 = (wxWindow *) 0 ;
31341 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31342 PyObject * obj0 = 0 ;
31343 PyObject * obj1 = 0 ;
31344 char *kwnames[] = {
31345 (char *) "self",(char *) "constraints", NULL
31346 };
31347
31348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31350 if (SWIG_arg_fail(1)) SWIG_fail;
31351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31352 if (SWIG_arg_fail(2)) SWIG_fail;
31353 {
31354 PyThreadState* __tstate = wxPyBeginAllowThreads();
31355 (arg1)->SetConstraints(arg2);
31356
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 Py_INCREF(Py_None); resultobj = Py_None;
31361 return resultobj;
31362 fail:
31363 return NULL;
31364 }
31365
31366
31367 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31368 PyObject *resultobj;
31369 wxWindow *arg1 = (wxWindow *) 0 ;
31370 wxLayoutConstraints *result;
31371 PyObject * obj0 = 0 ;
31372 char *kwnames[] = {
31373 (char *) "self", NULL
31374 };
31375
31376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31378 if (SWIG_arg_fail(1)) SWIG_fail;
31379 {
31380 PyThreadState* __tstate = wxPyBeginAllowThreads();
31381 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31382
31383 wxPyEndAllowThreads(__tstate);
31384 if (PyErr_Occurred()) SWIG_fail;
31385 }
31386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31387 return resultobj;
31388 fail:
31389 return NULL;
31390 }
31391
31392
31393 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31394 PyObject *resultobj;
31395 wxWindow *arg1 = (wxWindow *) 0 ;
31396 bool arg2 ;
31397 PyObject * obj0 = 0 ;
31398 PyObject * obj1 = 0 ;
31399 char *kwnames[] = {
31400 (char *) "self",(char *) "autoLayout", NULL
31401 };
31402
31403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31405 if (SWIG_arg_fail(1)) SWIG_fail;
31406 {
31407 arg2 = (bool)(SWIG_As_bool(obj1));
31408 if (SWIG_arg_fail(2)) SWIG_fail;
31409 }
31410 {
31411 PyThreadState* __tstate = wxPyBeginAllowThreads();
31412 (arg1)->SetAutoLayout(arg2);
31413
31414 wxPyEndAllowThreads(__tstate);
31415 if (PyErr_Occurred()) SWIG_fail;
31416 }
31417 Py_INCREF(Py_None); resultobj = Py_None;
31418 return resultobj;
31419 fail:
31420 return NULL;
31421 }
31422
31423
31424 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31425 PyObject *resultobj;
31426 wxWindow *arg1 = (wxWindow *) 0 ;
31427 bool result;
31428 PyObject * obj0 = 0 ;
31429 char *kwnames[] = {
31430 (char *) "self", NULL
31431 };
31432
31433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31435 if (SWIG_arg_fail(1)) SWIG_fail;
31436 {
31437 PyThreadState* __tstate = wxPyBeginAllowThreads();
31438 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31439
31440 wxPyEndAllowThreads(__tstate);
31441 if (PyErr_Occurred()) SWIG_fail;
31442 }
31443 {
31444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31445 }
31446 return resultobj;
31447 fail:
31448 return NULL;
31449 }
31450
31451
31452 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31453 PyObject *resultobj;
31454 wxWindow *arg1 = (wxWindow *) 0 ;
31455 bool result;
31456 PyObject * obj0 = 0 ;
31457 char *kwnames[] = {
31458 (char *) "self", NULL
31459 };
31460
31461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31463 if (SWIG_arg_fail(1)) SWIG_fail;
31464 {
31465 PyThreadState* __tstate = wxPyBeginAllowThreads();
31466 result = (bool)(arg1)->Layout();
31467
31468 wxPyEndAllowThreads(__tstate);
31469 if (PyErr_Occurred()) SWIG_fail;
31470 }
31471 {
31472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31473 }
31474 return resultobj;
31475 fail:
31476 return NULL;
31477 }
31478
31479
31480 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31481 PyObject *resultobj;
31482 wxWindow *arg1 = (wxWindow *) 0 ;
31483 wxSizer *arg2 = (wxSizer *) 0 ;
31484 bool arg3 = (bool) true ;
31485 PyObject * obj0 = 0 ;
31486 PyObject * obj1 = 0 ;
31487 PyObject * obj2 = 0 ;
31488 char *kwnames[] = {
31489 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31490 };
31491
31492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31494 if (SWIG_arg_fail(1)) SWIG_fail;
31495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31496 if (SWIG_arg_fail(2)) SWIG_fail;
31497 if (obj2) {
31498 {
31499 arg3 = (bool)(SWIG_As_bool(obj2));
31500 if (SWIG_arg_fail(3)) SWIG_fail;
31501 }
31502 }
31503 {
31504 PyThreadState* __tstate = wxPyBeginAllowThreads();
31505 (arg1)->SetSizer(arg2,arg3);
31506
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 Py_INCREF(Py_None); resultobj = Py_None;
31511 return resultobj;
31512 fail:
31513 return NULL;
31514 }
31515
31516
31517 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31518 PyObject *resultobj;
31519 wxWindow *arg1 = (wxWindow *) 0 ;
31520 wxSizer *arg2 = (wxSizer *) 0 ;
31521 bool arg3 = (bool) true ;
31522 PyObject * obj0 = 0 ;
31523 PyObject * obj1 = 0 ;
31524 PyObject * obj2 = 0 ;
31525 char *kwnames[] = {
31526 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31527 };
31528
31529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31531 if (SWIG_arg_fail(1)) SWIG_fail;
31532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31533 if (SWIG_arg_fail(2)) SWIG_fail;
31534 if (obj2) {
31535 {
31536 arg3 = (bool)(SWIG_As_bool(obj2));
31537 if (SWIG_arg_fail(3)) SWIG_fail;
31538 }
31539 }
31540 {
31541 PyThreadState* __tstate = wxPyBeginAllowThreads();
31542 (arg1)->SetSizerAndFit(arg2,arg3);
31543
31544 wxPyEndAllowThreads(__tstate);
31545 if (PyErr_Occurred()) SWIG_fail;
31546 }
31547 Py_INCREF(Py_None); resultobj = Py_None;
31548 return resultobj;
31549 fail:
31550 return NULL;
31551 }
31552
31553
31554 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31555 PyObject *resultobj;
31556 wxWindow *arg1 = (wxWindow *) 0 ;
31557 wxSizer *result;
31558 PyObject * obj0 = 0 ;
31559 char *kwnames[] = {
31560 (char *) "self", NULL
31561 };
31562
31563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31565 if (SWIG_arg_fail(1)) SWIG_fail;
31566 {
31567 PyThreadState* __tstate = wxPyBeginAllowThreads();
31568 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31569
31570 wxPyEndAllowThreads(__tstate);
31571 if (PyErr_Occurred()) SWIG_fail;
31572 }
31573 {
31574 resultobj = wxPyMake_wxSizer(result, 0);
31575 }
31576 return resultobj;
31577 fail:
31578 return NULL;
31579 }
31580
31581
31582 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31583 PyObject *resultobj;
31584 wxWindow *arg1 = (wxWindow *) 0 ;
31585 wxSizer *arg2 = (wxSizer *) 0 ;
31586 PyObject * obj0 = 0 ;
31587 PyObject * obj1 = 0 ;
31588 char *kwnames[] = {
31589 (char *) "self",(char *) "sizer", NULL
31590 };
31591
31592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31594 if (SWIG_arg_fail(1)) SWIG_fail;
31595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31596 if (SWIG_arg_fail(2)) SWIG_fail;
31597 {
31598 PyThreadState* __tstate = wxPyBeginAllowThreads();
31599 (arg1)->SetContainingSizer(arg2);
31600
31601 wxPyEndAllowThreads(__tstate);
31602 if (PyErr_Occurred()) SWIG_fail;
31603 }
31604 Py_INCREF(Py_None); resultobj = Py_None;
31605 return resultobj;
31606 fail:
31607 return NULL;
31608 }
31609
31610
31611 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31612 PyObject *resultobj;
31613 wxWindow *arg1 = (wxWindow *) 0 ;
31614 wxSizer *result;
31615 PyObject * obj0 = 0 ;
31616 char *kwnames[] = {
31617 (char *) "self", NULL
31618 };
31619
31620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31622 if (SWIG_arg_fail(1)) SWIG_fail;
31623 {
31624 PyThreadState* __tstate = wxPyBeginAllowThreads();
31625 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31626
31627 wxPyEndAllowThreads(__tstate);
31628 if (PyErr_Occurred()) SWIG_fail;
31629 }
31630 {
31631 resultobj = wxPyMake_wxSizer(result, 0);
31632 }
31633 return resultobj;
31634 fail:
31635 return NULL;
31636 }
31637
31638
31639 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31640 PyObject *resultobj;
31641 wxWindow *arg1 = (wxWindow *) 0 ;
31642 PyObject * obj0 = 0 ;
31643 char *kwnames[] = {
31644 (char *) "self", NULL
31645 };
31646
31647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31649 if (SWIG_arg_fail(1)) SWIG_fail;
31650 {
31651 PyThreadState* __tstate = wxPyBeginAllowThreads();
31652 (arg1)->InheritAttributes();
31653
31654 wxPyEndAllowThreads(__tstate);
31655 if (PyErr_Occurred()) SWIG_fail;
31656 }
31657 Py_INCREF(Py_None); resultobj = Py_None;
31658 return resultobj;
31659 fail:
31660 return NULL;
31661 }
31662
31663
31664 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31665 PyObject *resultobj;
31666 wxWindow *arg1 = (wxWindow *) 0 ;
31667 bool result;
31668 PyObject * obj0 = 0 ;
31669 char *kwnames[] = {
31670 (char *) "self", NULL
31671 };
31672
31673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31675 if (SWIG_arg_fail(1)) SWIG_fail;
31676 {
31677 PyThreadState* __tstate = wxPyBeginAllowThreads();
31678 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31679
31680 wxPyEndAllowThreads(__tstate);
31681 if (PyErr_Occurred()) SWIG_fail;
31682 }
31683 {
31684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31685 }
31686 return resultobj;
31687 fail:
31688 return NULL;
31689 }
31690
31691
31692 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31693 PyObject *obj;
31694 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31695 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31696 Py_INCREF(obj);
31697 return Py_BuildValue((char *)"");
31698 }
31699 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31700 PyObject *resultobj;
31701 long arg1 ;
31702 wxWindow *arg2 = (wxWindow *) NULL ;
31703 wxWindow *result;
31704 PyObject * obj0 = 0 ;
31705 PyObject * obj1 = 0 ;
31706 char *kwnames[] = {
31707 (char *) "id",(char *) "parent", NULL
31708 };
31709
31710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31711 {
31712 arg1 = (long)(SWIG_As_long(obj0));
31713 if (SWIG_arg_fail(1)) SWIG_fail;
31714 }
31715 if (obj1) {
31716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31717 if (SWIG_arg_fail(2)) SWIG_fail;
31718 }
31719 {
31720 if (!wxPyCheckForApp()) SWIG_fail;
31721 PyThreadState* __tstate = wxPyBeginAllowThreads();
31722 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31723
31724 wxPyEndAllowThreads(__tstate);
31725 if (PyErr_Occurred()) SWIG_fail;
31726 }
31727 {
31728 resultobj = wxPyMake_wxObject(result, 0);
31729 }
31730 return resultobj;
31731 fail:
31732 return NULL;
31733 }
31734
31735
31736 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31737 PyObject *resultobj;
31738 wxString *arg1 = 0 ;
31739 wxWindow *arg2 = (wxWindow *) NULL ;
31740 wxWindow *result;
31741 bool temp1 = false ;
31742 PyObject * obj0 = 0 ;
31743 PyObject * obj1 = 0 ;
31744 char *kwnames[] = {
31745 (char *) "name",(char *) "parent", NULL
31746 };
31747
31748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31749 {
31750 arg1 = wxString_in_helper(obj0);
31751 if (arg1 == NULL) SWIG_fail;
31752 temp1 = true;
31753 }
31754 if (obj1) {
31755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31756 if (SWIG_arg_fail(2)) SWIG_fail;
31757 }
31758 {
31759 if (!wxPyCheckForApp()) SWIG_fail;
31760 PyThreadState* __tstate = wxPyBeginAllowThreads();
31761 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31762
31763 wxPyEndAllowThreads(__tstate);
31764 if (PyErr_Occurred()) SWIG_fail;
31765 }
31766 {
31767 resultobj = wxPyMake_wxObject(result, 0);
31768 }
31769 {
31770 if (temp1)
31771 delete arg1;
31772 }
31773 return resultobj;
31774 fail:
31775 {
31776 if (temp1)
31777 delete arg1;
31778 }
31779 return NULL;
31780 }
31781
31782
31783 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31784 PyObject *resultobj;
31785 wxString *arg1 = 0 ;
31786 wxWindow *arg2 = (wxWindow *) NULL ;
31787 wxWindow *result;
31788 bool temp1 = false ;
31789 PyObject * obj0 = 0 ;
31790 PyObject * obj1 = 0 ;
31791 char *kwnames[] = {
31792 (char *) "label",(char *) "parent", NULL
31793 };
31794
31795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31796 {
31797 arg1 = wxString_in_helper(obj0);
31798 if (arg1 == NULL) SWIG_fail;
31799 temp1 = true;
31800 }
31801 if (obj1) {
31802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31803 if (SWIG_arg_fail(2)) SWIG_fail;
31804 }
31805 {
31806 if (!wxPyCheckForApp()) SWIG_fail;
31807 PyThreadState* __tstate = wxPyBeginAllowThreads();
31808 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31809
31810 wxPyEndAllowThreads(__tstate);
31811 if (PyErr_Occurred()) SWIG_fail;
31812 }
31813 {
31814 resultobj = wxPyMake_wxObject(result, 0);
31815 }
31816 {
31817 if (temp1)
31818 delete arg1;
31819 }
31820 return resultobj;
31821 fail:
31822 {
31823 if (temp1)
31824 delete arg1;
31825 }
31826 return NULL;
31827 }
31828
31829
31830 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31831 PyObject *resultobj;
31832 wxWindow *arg1 = (wxWindow *) 0 ;
31833 unsigned long arg2 ;
31834 wxWindow *result;
31835 PyObject * obj0 = 0 ;
31836 PyObject * obj1 = 0 ;
31837 char *kwnames[] = {
31838 (char *) "parent",(char *) "_hWnd", NULL
31839 };
31840
31841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31843 if (SWIG_arg_fail(1)) SWIG_fail;
31844 {
31845 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31846 if (SWIG_arg_fail(2)) SWIG_fail;
31847 }
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31851
31852 wxPyEndAllowThreads(__tstate);
31853 if (PyErr_Occurred()) SWIG_fail;
31854 }
31855 {
31856 resultobj = wxPyMake_wxObject(result, 0);
31857 }
31858 return resultobj;
31859 fail:
31860 return NULL;
31861 }
31862
31863
31864 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31865 PyObject *resultobj;
31866 wxValidator *result;
31867 char *kwnames[] = {
31868 NULL
31869 };
31870
31871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31872 {
31873 PyThreadState* __tstate = wxPyBeginAllowThreads();
31874 result = (wxValidator *)new wxValidator();
31875
31876 wxPyEndAllowThreads(__tstate);
31877 if (PyErr_Occurred()) SWIG_fail;
31878 }
31879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31880 return resultobj;
31881 fail:
31882 return NULL;
31883 }
31884
31885
31886 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31887 PyObject *resultobj;
31888 wxValidator *arg1 = (wxValidator *) 0 ;
31889 wxValidator *result;
31890 PyObject * obj0 = 0 ;
31891 char *kwnames[] = {
31892 (char *) "self", NULL
31893 };
31894
31895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31897 if (SWIG_arg_fail(1)) SWIG_fail;
31898 {
31899 PyThreadState* __tstate = wxPyBeginAllowThreads();
31900 result = (wxValidator *)(arg1)->Clone();
31901
31902 wxPyEndAllowThreads(__tstate);
31903 if (PyErr_Occurred()) SWIG_fail;
31904 }
31905 {
31906 resultobj = wxPyMake_wxObject(result, 0);
31907 }
31908 return resultobj;
31909 fail:
31910 return NULL;
31911 }
31912
31913
31914 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31915 PyObject *resultobj;
31916 wxValidator *arg1 = (wxValidator *) 0 ;
31917 wxWindow *arg2 = (wxWindow *) 0 ;
31918 bool result;
31919 PyObject * obj0 = 0 ;
31920 PyObject * obj1 = 0 ;
31921 char *kwnames[] = {
31922 (char *) "self",(char *) "parent", NULL
31923 };
31924
31925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31927 if (SWIG_arg_fail(1)) SWIG_fail;
31928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31929 if (SWIG_arg_fail(2)) SWIG_fail;
31930 {
31931 PyThreadState* __tstate = wxPyBeginAllowThreads();
31932 result = (bool)(arg1)->Validate(arg2);
31933
31934 wxPyEndAllowThreads(__tstate);
31935 if (PyErr_Occurred()) SWIG_fail;
31936 }
31937 {
31938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31939 }
31940 return resultobj;
31941 fail:
31942 return NULL;
31943 }
31944
31945
31946 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31947 PyObject *resultobj;
31948 wxValidator *arg1 = (wxValidator *) 0 ;
31949 bool result;
31950 PyObject * obj0 = 0 ;
31951 char *kwnames[] = {
31952 (char *) "self", NULL
31953 };
31954
31955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31957 if (SWIG_arg_fail(1)) SWIG_fail;
31958 {
31959 PyThreadState* __tstate = wxPyBeginAllowThreads();
31960 result = (bool)(arg1)->TransferToWindow();
31961
31962 wxPyEndAllowThreads(__tstate);
31963 if (PyErr_Occurred()) SWIG_fail;
31964 }
31965 {
31966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31967 }
31968 return resultobj;
31969 fail:
31970 return NULL;
31971 }
31972
31973
31974 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31975 PyObject *resultobj;
31976 wxValidator *arg1 = (wxValidator *) 0 ;
31977 bool result;
31978 PyObject * obj0 = 0 ;
31979 char *kwnames[] = {
31980 (char *) "self", NULL
31981 };
31982
31983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31985 if (SWIG_arg_fail(1)) SWIG_fail;
31986 {
31987 PyThreadState* __tstate = wxPyBeginAllowThreads();
31988 result = (bool)(arg1)->TransferFromWindow();
31989
31990 wxPyEndAllowThreads(__tstate);
31991 if (PyErr_Occurred()) SWIG_fail;
31992 }
31993 {
31994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31995 }
31996 return resultobj;
31997 fail:
31998 return NULL;
31999 }
32000
32001
32002 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32003 PyObject *resultobj;
32004 wxValidator *arg1 = (wxValidator *) 0 ;
32005 wxWindow *result;
32006 PyObject * obj0 = 0 ;
32007 char *kwnames[] = {
32008 (char *) "self", NULL
32009 };
32010
32011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32013 if (SWIG_arg_fail(1)) SWIG_fail;
32014 {
32015 PyThreadState* __tstate = wxPyBeginAllowThreads();
32016 result = (wxWindow *)(arg1)->GetWindow();
32017
32018 wxPyEndAllowThreads(__tstate);
32019 if (PyErr_Occurred()) SWIG_fail;
32020 }
32021 {
32022 resultobj = wxPyMake_wxObject(result, 0);
32023 }
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32031 PyObject *resultobj;
32032 wxValidator *arg1 = (wxValidator *) 0 ;
32033 wxWindow *arg2 = (wxWindow *) 0 ;
32034 PyObject * obj0 = 0 ;
32035 PyObject * obj1 = 0 ;
32036 char *kwnames[] = {
32037 (char *) "self",(char *) "window", NULL
32038 };
32039
32040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32042 if (SWIG_arg_fail(1)) SWIG_fail;
32043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32044 if (SWIG_arg_fail(2)) SWIG_fail;
32045 {
32046 PyThreadState* __tstate = wxPyBeginAllowThreads();
32047 (arg1)->SetWindow(arg2);
32048
32049 wxPyEndAllowThreads(__tstate);
32050 if (PyErr_Occurred()) SWIG_fail;
32051 }
32052 Py_INCREF(Py_None); resultobj = Py_None;
32053 return resultobj;
32054 fail:
32055 return NULL;
32056 }
32057
32058
32059 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32060 PyObject *resultobj;
32061 bool result;
32062 char *kwnames[] = {
32063 NULL
32064 };
32065
32066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 result = (bool)wxValidator::IsSilent();
32070
32071 wxPyEndAllowThreads(__tstate);
32072 if (PyErr_Occurred()) SWIG_fail;
32073 }
32074 {
32075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32076 }
32077 return resultobj;
32078 fail:
32079 return NULL;
32080 }
32081
32082
32083 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32084 PyObject *resultobj;
32085 int arg1 = (int) true ;
32086 PyObject * obj0 = 0 ;
32087 char *kwnames[] = {
32088 (char *) "doIt", NULL
32089 };
32090
32091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32092 if (obj0) {
32093 {
32094 arg1 = (int)(SWIG_As_int(obj0));
32095 if (SWIG_arg_fail(1)) SWIG_fail;
32096 }
32097 }
32098 {
32099 PyThreadState* __tstate = wxPyBeginAllowThreads();
32100 wxValidator::SetBellOnError(arg1);
32101
32102 wxPyEndAllowThreads(__tstate);
32103 if (PyErr_Occurred()) SWIG_fail;
32104 }
32105 Py_INCREF(Py_None); resultobj = Py_None;
32106 return resultobj;
32107 fail:
32108 return NULL;
32109 }
32110
32111
32112 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32113 PyObject *obj;
32114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32115 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32116 Py_INCREF(obj);
32117 return Py_BuildValue((char *)"");
32118 }
32119 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32120 PyObject *resultobj;
32121 wxPyValidator *result;
32122 char *kwnames[] = {
32123 NULL
32124 };
32125
32126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 result = (wxPyValidator *)new wxPyValidator();
32130
32131 wxPyEndAllowThreads(__tstate);
32132 if (PyErr_Occurred()) SWIG_fail;
32133 }
32134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32135 return resultobj;
32136 fail:
32137 return NULL;
32138 }
32139
32140
32141 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32142 PyObject *resultobj;
32143 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32144 PyObject *arg2 = (PyObject *) 0 ;
32145 PyObject *arg3 = (PyObject *) 0 ;
32146 int arg4 = (int) true ;
32147 PyObject * obj0 = 0 ;
32148 PyObject * obj1 = 0 ;
32149 PyObject * obj2 = 0 ;
32150 PyObject * obj3 = 0 ;
32151 char *kwnames[] = {
32152 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32153 };
32154
32155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32157 if (SWIG_arg_fail(1)) SWIG_fail;
32158 arg2 = obj1;
32159 arg3 = obj2;
32160 if (obj3) {
32161 {
32162 arg4 = (int)(SWIG_As_int(obj3));
32163 if (SWIG_arg_fail(4)) SWIG_fail;
32164 }
32165 }
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32169
32170 wxPyEndAllowThreads(__tstate);
32171 if (PyErr_Occurred()) SWIG_fail;
32172 }
32173 Py_INCREF(Py_None); resultobj = Py_None;
32174 return resultobj;
32175 fail:
32176 return NULL;
32177 }
32178
32179
32180 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32181 PyObject *obj;
32182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32183 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32184 Py_INCREF(obj);
32185 return Py_BuildValue((char *)"");
32186 }
32187 static int _wrap_DefaultValidator_set(PyObject *) {
32188 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32189 return 1;
32190 }
32191
32192
32193 static PyObject *_wrap_DefaultValidator_get(void) {
32194 PyObject *pyobj;
32195
32196 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32197 return pyobj;
32198 }
32199
32200
32201 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32202 PyObject *resultobj;
32203 wxString const &arg1_defvalue = wxPyEmptyString ;
32204 wxString *arg1 = (wxString *) &arg1_defvalue ;
32205 long arg2 = (long) 0 ;
32206 wxMenu *result;
32207 bool temp1 = false ;
32208 PyObject * obj0 = 0 ;
32209 PyObject * obj1 = 0 ;
32210 char *kwnames[] = {
32211 (char *) "title",(char *) "style", NULL
32212 };
32213
32214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32215 if (obj0) {
32216 {
32217 arg1 = wxString_in_helper(obj0);
32218 if (arg1 == NULL) SWIG_fail;
32219 temp1 = true;
32220 }
32221 }
32222 if (obj1) {
32223 {
32224 arg2 = (long)(SWIG_As_long(obj1));
32225 if (SWIG_arg_fail(2)) SWIG_fail;
32226 }
32227 }
32228 {
32229 if (!wxPyCheckForApp()) SWIG_fail;
32230 PyThreadState* __tstate = wxPyBeginAllowThreads();
32231 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32232
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32237 {
32238 if (temp1)
32239 delete arg1;
32240 }
32241 return resultobj;
32242 fail:
32243 {
32244 if (temp1)
32245 delete arg1;
32246 }
32247 return NULL;
32248 }
32249
32250
32251 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32252 PyObject *resultobj;
32253 wxMenu *arg1 = (wxMenu *) 0 ;
32254 int arg2 ;
32255 wxString *arg3 = 0 ;
32256 wxString const &arg4_defvalue = wxPyEmptyString ;
32257 wxString *arg4 = (wxString *) &arg4_defvalue ;
32258 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32259 wxMenuItem *result;
32260 bool temp3 = false ;
32261 bool temp4 = false ;
32262 PyObject * obj0 = 0 ;
32263 PyObject * obj1 = 0 ;
32264 PyObject * obj2 = 0 ;
32265 PyObject * obj3 = 0 ;
32266 PyObject * obj4 = 0 ;
32267 char *kwnames[] = {
32268 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32269 };
32270
32271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32273 if (SWIG_arg_fail(1)) SWIG_fail;
32274 {
32275 arg2 = (int)(SWIG_As_int(obj1));
32276 if (SWIG_arg_fail(2)) SWIG_fail;
32277 }
32278 {
32279 arg3 = wxString_in_helper(obj2);
32280 if (arg3 == NULL) SWIG_fail;
32281 temp3 = true;
32282 }
32283 if (obj3) {
32284 {
32285 arg4 = wxString_in_helper(obj3);
32286 if (arg4 == NULL) SWIG_fail;
32287 temp4 = true;
32288 }
32289 }
32290 if (obj4) {
32291 {
32292 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32293 if (SWIG_arg_fail(5)) SWIG_fail;
32294 }
32295 }
32296 {
32297 PyThreadState* __tstate = wxPyBeginAllowThreads();
32298 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32299
32300 wxPyEndAllowThreads(__tstate);
32301 if (PyErr_Occurred()) SWIG_fail;
32302 }
32303 {
32304 resultobj = wxPyMake_wxObject(result, 0);
32305 }
32306 {
32307 if (temp3)
32308 delete arg3;
32309 }
32310 {
32311 if (temp4)
32312 delete arg4;
32313 }
32314 return resultobj;
32315 fail:
32316 {
32317 if (temp3)
32318 delete arg3;
32319 }
32320 {
32321 if (temp4)
32322 delete arg4;
32323 }
32324 return NULL;
32325 }
32326
32327
32328 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32329 PyObject *resultobj;
32330 wxMenu *arg1 = (wxMenu *) 0 ;
32331 wxMenuItem *result;
32332 PyObject * obj0 = 0 ;
32333 char *kwnames[] = {
32334 (char *) "self", NULL
32335 };
32336
32337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32339 if (SWIG_arg_fail(1)) SWIG_fail;
32340 {
32341 PyThreadState* __tstate = wxPyBeginAllowThreads();
32342 result = (wxMenuItem *)(arg1)->AppendSeparator();
32343
32344 wxPyEndAllowThreads(__tstate);
32345 if (PyErr_Occurred()) SWIG_fail;
32346 }
32347 {
32348 resultobj = wxPyMake_wxObject(result, 0);
32349 }
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj;
32358 wxMenu *arg1 = (wxMenu *) 0 ;
32359 int arg2 ;
32360 wxString *arg3 = 0 ;
32361 wxString const &arg4_defvalue = wxPyEmptyString ;
32362 wxString *arg4 = (wxString *) &arg4_defvalue ;
32363 wxMenuItem *result;
32364 bool temp3 = false ;
32365 bool temp4 = false ;
32366 PyObject * obj0 = 0 ;
32367 PyObject * obj1 = 0 ;
32368 PyObject * obj2 = 0 ;
32369 PyObject * obj3 = 0 ;
32370 char *kwnames[] = {
32371 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32372 };
32373
32374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32376 if (SWIG_arg_fail(1)) SWIG_fail;
32377 {
32378 arg2 = (int)(SWIG_As_int(obj1));
32379 if (SWIG_arg_fail(2)) SWIG_fail;
32380 }
32381 {
32382 arg3 = wxString_in_helper(obj2);
32383 if (arg3 == NULL) SWIG_fail;
32384 temp3 = true;
32385 }
32386 if (obj3) {
32387 {
32388 arg4 = wxString_in_helper(obj3);
32389 if (arg4 == NULL) SWIG_fail;
32390 temp4 = true;
32391 }
32392 }
32393 {
32394 PyThreadState* __tstate = wxPyBeginAllowThreads();
32395 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32396
32397 wxPyEndAllowThreads(__tstate);
32398 if (PyErr_Occurred()) SWIG_fail;
32399 }
32400 {
32401 resultobj = wxPyMake_wxObject(result, 0);
32402 }
32403 {
32404 if (temp3)
32405 delete arg3;
32406 }
32407 {
32408 if (temp4)
32409 delete arg4;
32410 }
32411 return resultobj;
32412 fail:
32413 {
32414 if (temp3)
32415 delete arg3;
32416 }
32417 {
32418 if (temp4)
32419 delete arg4;
32420 }
32421 return NULL;
32422 }
32423
32424
32425 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32426 PyObject *resultobj;
32427 wxMenu *arg1 = (wxMenu *) 0 ;
32428 int arg2 ;
32429 wxString *arg3 = 0 ;
32430 wxString const &arg4_defvalue = wxPyEmptyString ;
32431 wxString *arg4 = (wxString *) &arg4_defvalue ;
32432 wxMenuItem *result;
32433 bool temp3 = false ;
32434 bool temp4 = false ;
32435 PyObject * obj0 = 0 ;
32436 PyObject * obj1 = 0 ;
32437 PyObject * obj2 = 0 ;
32438 PyObject * obj3 = 0 ;
32439 char *kwnames[] = {
32440 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32441 };
32442
32443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32445 if (SWIG_arg_fail(1)) SWIG_fail;
32446 {
32447 arg2 = (int)(SWIG_As_int(obj1));
32448 if (SWIG_arg_fail(2)) SWIG_fail;
32449 }
32450 {
32451 arg3 = wxString_in_helper(obj2);
32452 if (arg3 == NULL) SWIG_fail;
32453 temp3 = true;
32454 }
32455 if (obj3) {
32456 {
32457 arg4 = wxString_in_helper(obj3);
32458 if (arg4 == NULL) SWIG_fail;
32459 temp4 = true;
32460 }
32461 }
32462 {
32463 PyThreadState* __tstate = wxPyBeginAllowThreads();
32464 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32465
32466 wxPyEndAllowThreads(__tstate);
32467 if (PyErr_Occurred()) SWIG_fail;
32468 }
32469 {
32470 resultobj = wxPyMake_wxObject(result, 0);
32471 }
32472 {
32473 if (temp3)
32474 delete arg3;
32475 }
32476 {
32477 if (temp4)
32478 delete arg4;
32479 }
32480 return resultobj;
32481 fail:
32482 {
32483 if (temp3)
32484 delete arg3;
32485 }
32486 {
32487 if (temp4)
32488 delete arg4;
32489 }
32490 return NULL;
32491 }
32492
32493
32494 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32495 PyObject *resultobj;
32496 wxMenu *arg1 = (wxMenu *) 0 ;
32497 int arg2 ;
32498 wxString *arg3 = 0 ;
32499 wxMenu *arg4 = (wxMenu *) 0 ;
32500 wxString const &arg5_defvalue = wxPyEmptyString ;
32501 wxString *arg5 = (wxString *) &arg5_defvalue ;
32502 wxMenuItem *result;
32503 bool temp3 = false ;
32504 bool temp5 = false ;
32505 PyObject * obj0 = 0 ;
32506 PyObject * obj1 = 0 ;
32507 PyObject * obj2 = 0 ;
32508 PyObject * obj3 = 0 ;
32509 PyObject * obj4 = 0 ;
32510 char *kwnames[] = {
32511 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32512 };
32513
32514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32516 if (SWIG_arg_fail(1)) SWIG_fail;
32517 {
32518 arg2 = (int)(SWIG_As_int(obj1));
32519 if (SWIG_arg_fail(2)) SWIG_fail;
32520 }
32521 {
32522 arg3 = wxString_in_helper(obj2);
32523 if (arg3 == NULL) SWIG_fail;
32524 temp3 = true;
32525 }
32526 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32527 if (SWIG_arg_fail(4)) SWIG_fail;
32528 if (obj4) {
32529 {
32530 arg5 = wxString_in_helper(obj4);
32531 if (arg5 == NULL) SWIG_fail;
32532 temp5 = true;
32533 }
32534 }
32535 {
32536 PyThreadState* __tstate = wxPyBeginAllowThreads();
32537 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32538
32539 wxPyEndAllowThreads(__tstate);
32540 if (PyErr_Occurred()) SWIG_fail;
32541 }
32542 {
32543 resultobj = wxPyMake_wxObject(result, 0);
32544 }
32545 {
32546 if (temp3)
32547 delete arg3;
32548 }
32549 {
32550 if (temp5)
32551 delete arg5;
32552 }
32553 return resultobj;
32554 fail:
32555 {
32556 if (temp3)
32557 delete arg3;
32558 }
32559 {
32560 if (temp5)
32561 delete arg5;
32562 }
32563 return NULL;
32564 }
32565
32566
32567 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32568 PyObject *resultobj;
32569 wxMenu *arg1 = (wxMenu *) 0 ;
32570 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32571 wxMenuItem *result;
32572 PyObject * obj0 = 0 ;
32573 PyObject * obj1 = 0 ;
32574 char *kwnames[] = {
32575 (char *) "self",(char *) "item", NULL
32576 };
32577
32578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32580 if (SWIG_arg_fail(1)) SWIG_fail;
32581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32582 if (SWIG_arg_fail(2)) SWIG_fail;
32583 {
32584 PyThreadState* __tstate = wxPyBeginAllowThreads();
32585 result = (wxMenuItem *)(arg1)->Append(arg2);
32586
32587 wxPyEndAllowThreads(__tstate);
32588 if (PyErr_Occurred()) SWIG_fail;
32589 }
32590 {
32591 resultobj = wxPyMake_wxObject(result, 0);
32592 }
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32600 PyObject *resultobj;
32601 wxMenu *arg1 = (wxMenu *) 0 ;
32602 PyObject * obj0 = 0 ;
32603 char *kwnames[] = {
32604 (char *) "self", NULL
32605 };
32606
32607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32609 if (SWIG_arg_fail(1)) SWIG_fail;
32610 {
32611 PyThreadState* __tstate = wxPyBeginAllowThreads();
32612 (arg1)->Break();
32613
32614 wxPyEndAllowThreads(__tstate);
32615 if (PyErr_Occurred()) SWIG_fail;
32616 }
32617 Py_INCREF(Py_None); resultobj = Py_None;
32618 return resultobj;
32619 fail:
32620 return NULL;
32621 }
32622
32623
32624 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32625 PyObject *resultobj;
32626 wxMenu *arg1 = (wxMenu *) 0 ;
32627 size_t arg2 ;
32628 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32629 wxMenuItem *result;
32630 PyObject * obj0 = 0 ;
32631 PyObject * obj1 = 0 ;
32632 PyObject * obj2 = 0 ;
32633 char *kwnames[] = {
32634 (char *) "self",(char *) "pos",(char *) "item", NULL
32635 };
32636
32637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32639 if (SWIG_arg_fail(1)) SWIG_fail;
32640 {
32641 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32642 if (SWIG_arg_fail(2)) SWIG_fail;
32643 }
32644 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32645 if (SWIG_arg_fail(3)) SWIG_fail;
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32649
32650 wxPyEndAllowThreads(__tstate);
32651 if (PyErr_Occurred()) SWIG_fail;
32652 }
32653 {
32654 resultobj = wxPyMake_wxObject(result, 0);
32655 }
32656 return resultobj;
32657 fail:
32658 return NULL;
32659 }
32660
32661
32662 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32663 PyObject *resultobj;
32664 wxMenu *arg1 = (wxMenu *) 0 ;
32665 size_t arg2 ;
32666 int arg3 ;
32667 wxString *arg4 = 0 ;
32668 wxString const &arg5_defvalue = wxPyEmptyString ;
32669 wxString *arg5 = (wxString *) &arg5_defvalue ;
32670 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32671 wxMenuItem *result;
32672 bool temp4 = false ;
32673 bool temp5 = false ;
32674 PyObject * obj0 = 0 ;
32675 PyObject * obj1 = 0 ;
32676 PyObject * obj2 = 0 ;
32677 PyObject * obj3 = 0 ;
32678 PyObject * obj4 = 0 ;
32679 PyObject * obj5 = 0 ;
32680 char *kwnames[] = {
32681 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32682 };
32683
32684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32686 if (SWIG_arg_fail(1)) SWIG_fail;
32687 {
32688 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32689 if (SWIG_arg_fail(2)) SWIG_fail;
32690 }
32691 {
32692 arg3 = (int)(SWIG_As_int(obj2));
32693 if (SWIG_arg_fail(3)) SWIG_fail;
32694 }
32695 {
32696 arg4 = wxString_in_helper(obj3);
32697 if (arg4 == NULL) SWIG_fail;
32698 temp4 = true;
32699 }
32700 if (obj4) {
32701 {
32702 arg5 = wxString_in_helper(obj4);
32703 if (arg5 == NULL) SWIG_fail;
32704 temp5 = true;
32705 }
32706 }
32707 if (obj5) {
32708 {
32709 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32710 if (SWIG_arg_fail(6)) SWIG_fail;
32711 }
32712 }
32713 {
32714 PyThreadState* __tstate = wxPyBeginAllowThreads();
32715 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32716
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 {
32721 resultobj = wxPyMake_wxObject(result, 0);
32722 }
32723 {
32724 if (temp4)
32725 delete arg4;
32726 }
32727 {
32728 if (temp5)
32729 delete arg5;
32730 }
32731 return resultobj;
32732 fail:
32733 {
32734 if (temp4)
32735 delete arg4;
32736 }
32737 {
32738 if (temp5)
32739 delete arg5;
32740 }
32741 return NULL;
32742 }
32743
32744
32745 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32746 PyObject *resultobj;
32747 wxMenu *arg1 = (wxMenu *) 0 ;
32748 size_t arg2 ;
32749 wxMenuItem *result;
32750 PyObject * obj0 = 0 ;
32751 PyObject * obj1 = 0 ;
32752 char *kwnames[] = {
32753 (char *) "self",(char *) "pos", NULL
32754 };
32755
32756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32758 if (SWIG_arg_fail(1)) SWIG_fail;
32759 {
32760 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32761 if (SWIG_arg_fail(2)) SWIG_fail;
32762 }
32763 {
32764 PyThreadState* __tstate = wxPyBeginAllowThreads();
32765 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32766
32767 wxPyEndAllowThreads(__tstate);
32768 if (PyErr_Occurred()) SWIG_fail;
32769 }
32770 {
32771 resultobj = wxPyMake_wxObject(result, 0);
32772 }
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32780 PyObject *resultobj;
32781 wxMenu *arg1 = (wxMenu *) 0 ;
32782 size_t arg2 ;
32783 int arg3 ;
32784 wxString *arg4 = 0 ;
32785 wxString const &arg5_defvalue = wxPyEmptyString ;
32786 wxString *arg5 = (wxString *) &arg5_defvalue ;
32787 wxMenuItem *result;
32788 bool temp4 = false ;
32789 bool temp5 = false ;
32790 PyObject * obj0 = 0 ;
32791 PyObject * obj1 = 0 ;
32792 PyObject * obj2 = 0 ;
32793 PyObject * obj3 = 0 ;
32794 PyObject * obj4 = 0 ;
32795 char *kwnames[] = {
32796 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32797 };
32798
32799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32801 if (SWIG_arg_fail(1)) SWIG_fail;
32802 {
32803 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32804 if (SWIG_arg_fail(2)) SWIG_fail;
32805 }
32806 {
32807 arg3 = (int)(SWIG_As_int(obj2));
32808 if (SWIG_arg_fail(3)) SWIG_fail;
32809 }
32810 {
32811 arg4 = wxString_in_helper(obj3);
32812 if (arg4 == NULL) SWIG_fail;
32813 temp4 = true;
32814 }
32815 if (obj4) {
32816 {
32817 arg5 = wxString_in_helper(obj4);
32818 if (arg5 == NULL) SWIG_fail;
32819 temp5 = true;
32820 }
32821 }
32822 {
32823 PyThreadState* __tstate = wxPyBeginAllowThreads();
32824 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32825
32826 wxPyEndAllowThreads(__tstate);
32827 if (PyErr_Occurred()) SWIG_fail;
32828 }
32829 {
32830 resultobj = wxPyMake_wxObject(result, 0);
32831 }
32832 {
32833 if (temp4)
32834 delete arg4;
32835 }
32836 {
32837 if (temp5)
32838 delete arg5;
32839 }
32840 return resultobj;
32841 fail:
32842 {
32843 if (temp4)
32844 delete arg4;
32845 }
32846 {
32847 if (temp5)
32848 delete arg5;
32849 }
32850 return NULL;
32851 }
32852
32853
32854 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32855 PyObject *resultobj;
32856 wxMenu *arg1 = (wxMenu *) 0 ;
32857 size_t arg2 ;
32858 int arg3 ;
32859 wxString *arg4 = 0 ;
32860 wxString const &arg5_defvalue = wxPyEmptyString ;
32861 wxString *arg5 = (wxString *) &arg5_defvalue ;
32862 wxMenuItem *result;
32863 bool temp4 = false ;
32864 bool temp5 = false ;
32865 PyObject * obj0 = 0 ;
32866 PyObject * obj1 = 0 ;
32867 PyObject * obj2 = 0 ;
32868 PyObject * obj3 = 0 ;
32869 PyObject * obj4 = 0 ;
32870 char *kwnames[] = {
32871 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32872 };
32873
32874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32876 if (SWIG_arg_fail(1)) SWIG_fail;
32877 {
32878 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32879 if (SWIG_arg_fail(2)) SWIG_fail;
32880 }
32881 {
32882 arg3 = (int)(SWIG_As_int(obj2));
32883 if (SWIG_arg_fail(3)) SWIG_fail;
32884 }
32885 {
32886 arg4 = wxString_in_helper(obj3);
32887 if (arg4 == NULL) SWIG_fail;
32888 temp4 = true;
32889 }
32890 if (obj4) {
32891 {
32892 arg5 = wxString_in_helper(obj4);
32893 if (arg5 == NULL) SWIG_fail;
32894 temp5 = true;
32895 }
32896 }
32897 {
32898 PyThreadState* __tstate = wxPyBeginAllowThreads();
32899 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32900
32901 wxPyEndAllowThreads(__tstate);
32902 if (PyErr_Occurred()) SWIG_fail;
32903 }
32904 {
32905 resultobj = wxPyMake_wxObject(result, 0);
32906 }
32907 {
32908 if (temp4)
32909 delete arg4;
32910 }
32911 {
32912 if (temp5)
32913 delete arg5;
32914 }
32915 return resultobj;
32916 fail:
32917 {
32918 if (temp4)
32919 delete arg4;
32920 }
32921 {
32922 if (temp5)
32923 delete arg5;
32924 }
32925 return NULL;
32926 }
32927
32928
32929 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32930 PyObject *resultobj;
32931 wxMenu *arg1 = (wxMenu *) 0 ;
32932 size_t arg2 ;
32933 int arg3 ;
32934 wxString *arg4 = 0 ;
32935 wxMenu *arg5 = (wxMenu *) 0 ;
32936 wxString const &arg6_defvalue = wxPyEmptyString ;
32937 wxString *arg6 = (wxString *) &arg6_defvalue ;
32938 wxMenuItem *result;
32939 bool temp4 = false ;
32940 bool temp6 = false ;
32941 PyObject * obj0 = 0 ;
32942 PyObject * obj1 = 0 ;
32943 PyObject * obj2 = 0 ;
32944 PyObject * obj3 = 0 ;
32945 PyObject * obj4 = 0 ;
32946 PyObject * obj5 = 0 ;
32947 char *kwnames[] = {
32948 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32949 };
32950
32951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32953 if (SWIG_arg_fail(1)) SWIG_fail;
32954 {
32955 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32956 if (SWIG_arg_fail(2)) SWIG_fail;
32957 }
32958 {
32959 arg3 = (int)(SWIG_As_int(obj2));
32960 if (SWIG_arg_fail(3)) SWIG_fail;
32961 }
32962 {
32963 arg4 = wxString_in_helper(obj3);
32964 if (arg4 == NULL) SWIG_fail;
32965 temp4 = true;
32966 }
32967 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32968 if (SWIG_arg_fail(5)) SWIG_fail;
32969 if (obj5) {
32970 {
32971 arg6 = wxString_in_helper(obj5);
32972 if (arg6 == NULL) SWIG_fail;
32973 temp6 = true;
32974 }
32975 }
32976 {
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32979
32980 wxPyEndAllowThreads(__tstate);
32981 if (PyErr_Occurred()) SWIG_fail;
32982 }
32983 {
32984 resultobj = wxPyMake_wxObject(result, 0);
32985 }
32986 {
32987 if (temp4)
32988 delete arg4;
32989 }
32990 {
32991 if (temp6)
32992 delete arg6;
32993 }
32994 return resultobj;
32995 fail:
32996 {
32997 if (temp4)
32998 delete arg4;
32999 }
33000 {
33001 if (temp6)
33002 delete arg6;
33003 }
33004 return NULL;
33005 }
33006
33007
33008 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33009 PyObject *resultobj;
33010 wxMenu *arg1 = (wxMenu *) 0 ;
33011 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33012 wxMenuItem *result;
33013 PyObject * obj0 = 0 ;
33014 PyObject * obj1 = 0 ;
33015 char *kwnames[] = {
33016 (char *) "self",(char *) "item", NULL
33017 };
33018
33019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33021 if (SWIG_arg_fail(1)) SWIG_fail;
33022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33023 if (SWIG_arg_fail(2)) SWIG_fail;
33024 {
33025 PyThreadState* __tstate = wxPyBeginAllowThreads();
33026 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33027
33028 wxPyEndAllowThreads(__tstate);
33029 if (PyErr_Occurred()) SWIG_fail;
33030 }
33031 {
33032 resultobj = wxPyMake_wxObject(result, 0);
33033 }
33034 return resultobj;
33035 fail:
33036 return NULL;
33037 }
33038
33039
33040 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33041 PyObject *resultobj;
33042 wxMenu *arg1 = (wxMenu *) 0 ;
33043 int arg2 ;
33044 wxString *arg3 = 0 ;
33045 wxString const &arg4_defvalue = wxPyEmptyString ;
33046 wxString *arg4 = (wxString *) &arg4_defvalue ;
33047 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33048 wxMenuItem *result;
33049 bool temp3 = false ;
33050 bool temp4 = false ;
33051 PyObject * obj0 = 0 ;
33052 PyObject * obj1 = 0 ;
33053 PyObject * obj2 = 0 ;
33054 PyObject * obj3 = 0 ;
33055 PyObject * obj4 = 0 ;
33056 char *kwnames[] = {
33057 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33058 };
33059
33060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33062 if (SWIG_arg_fail(1)) SWIG_fail;
33063 {
33064 arg2 = (int)(SWIG_As_int(obj1));
33065 if (SWIG_arg_fail(2)) SWIG_fail;
33066 }
33067 {
33068 arg3 = wxString_in_helper(obj2);
33069 if (arg3 == NULL) SWIG_fail;
33070 temp3 = true;
33071 }
33072 if (obj3) {
33073 {
33074 arg4 = wxString_in_helper(obj3);
33075 if (arg4 == NULL) SWIG_fail;
33076 temp4 = true;
33077 }
33078 }
33079 if (obj4) {
33080 {
33081 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33082 if (SWIG_arg_fail(5)) SWIG_fail;
33083 }
33084 }
33085 {
33086 PyThreadState* __tstate = wxPyBeginAllowThreads();
33087 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33088
33089 wxPyEndAllowThreads(__tstate);
33090 if (PyErr_Occurred()) SWIG_fail;
33091 }
33092 {
33093 resultobj = wxPyMake_wxObject(result, 0);
33094 }
33095 {
33096 if (temp3)
33097 delete arg3;
33098 }
33099 {
33100 if (temp4)
33101 delete arg4;
33102 }
33103 return resultobj;
33104 fail:
33105 {
33106 if (temp3)
33107 delete arg3;
33108 }
33109 {
33110 if (temp4)
33111 delete arg4;
33112 }
33113 return NULL;
33114 }
33115
33116
33117 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33118 PyObject *resultobj;
33119 wxMenu *arg1 = (wxMenu *) 0 ;
33120 wxMenuItem *result;
33121 PyObject * obj0 = 0 ;
33122 char *kwnames[] = {
33123 (char *) "self", NULL
33124 };
33125
33126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33128 if (SWIG_arg_fail(1)) SWIG_fail;
33129 {
33130 PyThreadState* __tstate = wxPyBeginAllowThreads();
33131 result = (wxMenuItem *)(arg1)->PrependSeparator();
33132
33133 wxPyEndAllowThreads(__tstate);
33134 if (PyErr_Occurred()) SWIG_fail;
33135 }
33136 {
33137 resultobj = wxPyMake_wxObject(result, 0);
33138 }
33139 return resultobj;
33140 fail:
33141 return NULL;
33142 }
33143
33144
33145 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33146 PyObject *resultobj;
33147 wxMenu *arg1 = (wxMenu *) 0 ;
33148 int arg2 ;
33149 wxString *arg3 = 0 ;
33150 wxString const &arg4_defvalue = wxPyEmptyString ;
33151 wxString *arg4 = (wxString *) &arg4_defvalue ;
33152 wxMenuItem *result;
33153 bool temp3 = false ;
33154 bool temp4 = false ;
33155 PyObject * obj0 = 0 ;
33156 PyObject * obj1 = 0 ;
33157 PyObject * obj2 = 0 ;
33158 PyObject * obj3 = 0 ;
33159 char *kwnames[] = {
33160 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33161 };
33162
33163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33165 if (SWIG_arg_fail(1)) SWIG_fail;
33166 {
33167 arg2 = (int)(SWIG_As_int(obj1));
33168 if (SWIG_arg_fail(2)) SWIG_fail;
33169 }
33170 {
33171 arg3 = wxString_in_helper(obj2);
33172 if (arg3 == NULL) SWIG_fail;
33173 temp3 = true;
33174 }
33175 if (obj3) {
33176 {
33177 arg4 = wxString_in_helper(obj3);
33178 if (arg4 == NULL) SWIG_fail;
33179 temp4 = true;
33180 }
33181 }
33182 {
33183 PyThreadState* __tstate = wxPyBeginAllowThreads();
33184 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33185
33186 wxPyEndAllowThreads(__tstate);
33187 if (PyErr_Occurred()) SWIG_fail;
33188 }
33189 {
33190 resultobj = wxPyMake_wxObject(result, 0);
33191 }
33192 {
33193 if (temp3)
33194 delete arg3;
33195 }
33196 {
33197 if (temp4)
33198 delete arg4;
33199 }
33200 return resultobj;
33201 fail:
33202 {
33203 if (temp3)
33204 delete arg3;
33205 }
33206 {
33207 if (temp4)
33208 delete arg4;
33209 }
33210 return NULL;
33211 }
33212
33213
33214 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33215 PyObject *resultobj;
33216 wxMenu *arg1 = (wxMenu *) 0 ;
33217 int arg2 ;
33218 wxString *arg3 = 0 ;
33219 wxString const &arg4_defvalue = wxPyEmptyString ;
33220 wxString *arg4 = (wxString *) &arg4_defvalue ;
33221 wxMenuItem *result;
33222 bool temp3 = false ;
33223 bool temp4 = false ;
33224 PyObject * obj0 = 0 ;
33225 PyObject * obj1 = 0 ;
33226 PyObject * obj2 = 0 ;
33227 PyObject * obj3 = 0 ;
33228 char *kwnames[] = {
33229 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33230 };
33231
33232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33234 if (SWIG_arg_fail(1)) SWIG_fail;
33235 {
33236 arg2 = (int)(SWIG_As_int(obj1));
33237 if (SWIG_arg_fail(2)) SWIG_fail;
33238 }
33239 {
33240 arg3 = wxString_in_helper(obj2);
33241 if (arg3 == NULL) SWIG_fail;
33242 temp3 = true;
33243 }
33244 if (obj3) {
33245 {
33246 arg4 = wxString_in_helper(obj3);
33247 if (arg4 == NULL) SWIG_fail;
33248 temp4 = true;
33249 }
33250 }
33251 {
33252 PyThreadState* __tstate = wxPyBeginAllowThreads();
33253 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33254
33255 wxPyEndAllowThreads(__tstate);
33256 if (PyErr_Occurred()) SWIG_fail;
33257 }
33258 {
33259 resultobj = wxPyMake_wxObject(result, 0);
33260 }
33261 {
33262 if (temp3)
33263 delete arg3;
33264 }
33265 {
33266 if (temp4)
33267 delete arg4;
33268 }
33269 return resultobj;
33270 fail:
33271 {
33272 if (temp3)
33273 delete arg3;
33274 }
33275 {
33276 if (temp4)
33277 delete arg4;
33278 }
33279 return NULL;
33280 }
33281
33282
33283 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33284 PyObject *resultobj;
33285 wxMenu *arg1 = (wxMenu *) 0 ;
33286 int arg2 ;
33287 wxString *arg3 = 0 ;
33288 wxMenu *arg4 = (wxMenu *) 0 ;
33289 wxString const &arg5_defvalue = wxPyEmptyString ;
33290 wxString *arg5 = (wxString *) &arg5_defvalue ;
33291 wxMenuItem *result;
33292 bool temp3 = false ;
33293 bool temp5 = false ;
33294 PyObject * obj0 = 0 ;
33295 PyObject * obj1 = 0 ;
33296 PyObject * obj2 = 0 ;
33297 PyObject * obj3 = 0 ;
33298 PyObject * obj4 = 0 ;
33299 char *kwnames[] = {
33300 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33301 };
33302
33303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33305 if (SWIG_arg_fail(1)) SWIG_fail;
33306 {
33307 arg2 = (int)(SWIG_As_int(obj1));
33308 if (SWIG_arg_fail(2)) SWIG_fail;
33309 }
33310 {
33311 arg3 = wxString_in_helper(obj2);
33312 if (arg3 == NULL) SWIG_fail;
33313 temp3 = true;
33314 }
33315 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33316 if (SWIG_arg_fail(4)) SWIG_fail;
33317 if (obj4) {
33318 {
33319 arg5 = wxString_in_helper(obj4);
33320 if (arg5 == NULL) SWIG_fail;
33321 temp5 = true;
33322 }
33323 }
33324 {
33325 PyThreadState* __tstate = wxPyBeginAllowThreads();
33326 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33327
33328 wxPyEndAllowThreads(__tstate);
33329 if (PyErr_Occurred()) SWIG_fail;
33330 }
33331 {
33332 resultobj = wxPyMake_wxObject(result, 0);
33333 }
33334 {
33335 if (temp3)
33336 delete arg3;
33337 }
33338 {
33339 if (temp5)
33340 delete arg5;
33341 }
33342 return resultobj;
33343 fail:
33344 {
33345 if (temp3)
33346 delete arg3;
33347 }
33348 {
33349 if (temp5)
33350 delete arg5;
33351 }
33352 return NULL;
33353 }
33354
33355
33356 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33357 PyObject *resultobj;
33358 wxMenu *arg1 = (wxMenu *) 0 ;
33359 int arg2 ;
33360 wxMenuItem *result;
33361 PyObject * obj0 = 0 ;
33362 PyObject * obj1 = 0 ;
33363 char *kwnames[] = {
33364 (char *) "self",(char *) "id", NULL
33365 };
33366
33367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33369 if (SWIG_arg_fail(1)) SWIG_fail;
33370 {
33371 arg2 = (int)(SWIG_As_int(obj1));
33372 if (SWIG_arg_fail(2)) SWIG_fail;
33373 }
33374 {
33375 PyThreadState* __tstate = wxPyBeginAllowThreads();
33376 result = (wxMenuItem *)(arg1)->Remove(arg2);
33377
33378 wxPyEndAllowThreads(__tstate);
33379 if (PyErr_Occurred()) SWIG_fail;
33380 }
33381 {
33382 resultobj = wxPyMake_wxObject(result, 0);
33383 }
33384 return resultobj;
33385 fail:
33386 return NULL;
33387 }
33388
33389
33390 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33391 PyObject *resultobj;
33392 wxMenu *arg1 = (wxMenu *) 0 ;
33393 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33394 wxMenuItem *result;
33395 PyObject * obj0 = 0 ;
33396 PyObject * obj1 = 0 ;
33397 char *kwnames[] = {
33398 (char *) "self",(char *) "item", NULL
33399 };
33400
33401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33403 if (SWIG_arg_fail(1)) SWIG_fail;
33404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33405 if (SWIG_arg_fail(2)) SWIG_fail;
33406 {
33407 PyThreadState* __tstate = wxPyBeginAllowThreads();
33408 result = (wxMenuItem *)(arg1)->Remove(arg2);
33409
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 {
33414 resultobj = wxPyMake_wxObject(result, 0);
33415 }
33416 return resultobj;
33417 fail:
33418 return NULL;
33419 }
33420
33421
33422 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33423 PyObject *resultobj;
33424 wxMenu *arg1 = (wxMenu *) 0 ;
33425 int arg2 ;
33426 bool result;
33427 PyObject * obj0 = 0 ;
33428 PyObject * obj1 = 0 ;
33429 char *kwnames[] = {
33430 (char *) "self",(char *) "id", NULL
33431 };
33432
33433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33435 if (SWIG_arg_fail(1)) SWIG_fail;
33436 {
33437 arg2 = (int)(SWIG_As_int(obj1));
33438 if (SWIG_arg_fail(2)) SWIG_fail;
33439 }
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 result = (bool)(arg1)->Delete(arg2);
33443
33444 wxPyEndAllowThreads(__tstate);
33445 if (PyErr_Occurred()) SWIG_fail;
33446 }
33447 {
33448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33449 }
33450 return resultobj;
33451 fail:
33452 return NULL;
33453 }
33454
33455
33456 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33457 PyObject *resultobj;
33458 wxMenu *arg1 = (wxMenu *) 0 ;
33459 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33460 bool result;
33461 PyObject * obj0 = 0 ;
33462 PyObject * obj1 = 0 ;
33463 char *kwnames[] = {
33464 (char *) "self",(char *) "item", NULL
33465 };
33466
33467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33469 if (SWIG_arg_fail(1)) SWIG_fail;
33470 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33471 if (SWIG_arg_fail(2)) SWIG_fail;
33472 {
33473 PyThreadState* __tstate = wxPyBeginAllowThreads();
33474 result = (bool)(arg1)->Delete(arg2);
33475
33476 wxPyEndAllowThreads(__tstate);
33477 if (PyErr_Occurred()) SWIG_fail;
33478 }
33479 {
33480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33481 }
33482 return resultobj;
33483 fail:
33484 return NULL;
33485 }
33486
33487
33488 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33489 PyObject *resultobj;
33490 wxMenu *arg1 = (wxMenu *) 0 ;
33491 PyObject * obj0 = 0 ;
33492 char *kwnames[] = {
33493 (char *) "self", NULL
33494 };
33495
33496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33498 if (SWIG_arg_fail(1)) SWIG_fail;
33499 {
33500 PyThreadState* __tstate = wxPyBeginAllowThreads();
33501 wxMenu_Destroy(arg1);
33502
33503 wxPyEndAllowThreads(__tstate);
33504 if (PyErr_Occurred()) SWIG_fail;
33505 }
33506 Py_INCREF(Py_None); resultobj = Py_None;
33507 return resultobj;
33508 fail:
33509 return NULL;
33510 }
33511
33512
33513 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33514 PyObject *resultobj;
33515 wxMenu *arg1 = (wxMenu *) 0 ;
33516 int arg2 ;
33517 bool result;
33518 PyObject * obj0 = 0 ;
33519 PyObject * obj1 = 0 ;
33520 char *kwnames[] = {
33521 (char *) "self",(char *) "id", NULL
33522 };
33523
33524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33526 if (SWIG_arg_fail(1)) SWIG_fail;
33527 {
33528 arg2 = (int)(SWIG_As_int(obj1));
33529 if (SWIG_arg_fail(2)) SWIG_fail;
33530 }
33531 {
33532 PyThreadState* __tstate = wxPyBeginAllowThreads();
33533 result = (bool)(arg1)->Destroy(arg2);
33534
33535 wxPyEndAllowThreads(__tstate);
33536 if (PyErr_Occurred()) SWIG_fail;
33537 }
33538 {
33539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33540 }
33541 return resultobj;
33542 fail:
33543 return NULL;
33544 }
33545
33546
33547 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33548 PyObject *resultobj;
33549 wxMenu *arg1 = (wxMenu *) 0 ;
33550 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33551 bool result;
33552 PyObject * obj0 = 0 ;
33553 PyObject * obj1 = 0 ;
33554 char *kwnames[] = {
33555 (char *) "self",(char *) "item", NULL
33556 };
33557
33558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33560 if (SWIG_arg_fail(1)) SWIG_fail;
33561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33562 if (SWIG_arg_fail(2)) SWIG_fail;
33563 {
33564 PyThreadState* __tstate = wxPyBeginAllowThreads();
33565 result = (bool)(arg1)->Destroy(arg2);
33566
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 {
33571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33572 }
33573 return resultobj;
33574 fail:
33575 return NULL;
33576 }
33577
33578
33579 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33580 PyObject *resultobj;
33581 wxMenu *arg1 = (wxMenu *) 0 ;
33582 size_t result;
33583 PyObject * obj0 = 0 ;
33584 char *kwnames[] = {
33585 (char *) "self", NULL
33586 };
33587
33588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33590 if (SWIG_arg_fail(1)) SWIG_fail;
33591 {
33592 PyThreadState* __tstate = wxPyBeginAllowThreads();
33593 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33594
33595 wxPyEndAllowThreads(__tstate);
33596 if (PyErr_Occurred()) SWIG_fail;
33597 }
33598 {
33599 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33600 }
33601 return resultobj;
33602 fail:
33603 return NULL;
33604 }
33605
33606
33607 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33608 PyObject *resultobj;
33609 wxMenu *arg1 = (wxMenu *) 0 ;
33610 PyObject *result;
33611 PyObject * obj0 = 0 ;
33612 char *kwnames[] = {
33613 (char *) "self", NULL
33614 };
33615
33616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33618 if (SWIG_arg_fail(1)) SWIG_fail;
33619 {
33620 PyThreadState* __tstate = wxPyBeginAllowThreads();
33621 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33622
33623 wxPyEndAllowThreads(__tstate);
33624 if (PyErr_Occurred()) SWIG_fail;
33625 }
33626 resultobj = result;
33627 return resultobj;
33628 fail:
33629 return NULL;
33630 }
33631
33632
33633 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33634 PyObject *resultobj;
33635 wxMenu *arg1 = (wxMenu *) 0 ;
33636 wxString *arg2 = 0 ;
33637 int result;
33638 bool temp2 = false ;
33639 PyObject * obj0 = 0 ;
33640 PyObject * obj1 = 0 ;
33641 char *kwnames[] = {
33642 (char *) "self",(char *) "item", NULL
33643 };
33644
33645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33647 if (SWIG_arg_fail(1)) SWIG_fail;
33648 {
33649 arg2 = wxString_in_helper(obj1);
33650 if (arg2 == NULL) SWIG_fail;
33651 temp2 = true;
33652 }
33653 {
33654 PyThreadState* __tstate = wxPyBeginAllowThreads();
33655 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33656
33657 wxPyEndAllowThreads(__tstate);
33658 if (PyErr_Occurred()) SWIG_fail;
33659 }
33660 {
33661 resultobj = SWIG_From_int((int)(result));
33662 }
33663 {
33664 if (temp2)
33665 delete arg2;
33666 }
33667 return resultobj;
33668 fail:
33669 {
33670 if (temp2)
33671 delete arg2;
33672 }
33673 return NULL;
33674 }
33675
33676
33677 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33678 PyObject *resultobj;
33679 wxMenu *arg1 = (wxMenu *) 0 ;
33680 int arg2 ;
33681 wxMenuItem *result;
33682 PyObject * obj0 = 0 ;
33683 PyObject * obj1 = 0 ;
33684 char *kwnames[] = {
33685 (char *) "self",(char *) "id", NULL
33686 };
33687
33688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33690 if (SWIG_arg_fail(1)) SWIG_fail;
33691 {
33692 arg2 = (int)(SWIG_As_int(obj1));
33693 if (SWIG_arg_fail(2)) SWIG_fail;
33694 }
33695 {
33696 PyThreadState* __tstate = wxPyBeginAllowThreads();
33697 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33698
33699 wxPyEndAllowThreads(__tstate);
33700 if (PyErr_Occurred()) SWIG_fail;
33701 }
33702 {
33703 resultobj = wxPyMake_wxObject(result, 0);
33704 }
33705 return resultobj;
33706 fail:
33707 return NULL;
33708 }
33709
33710
33711 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33712 PyObject *resultobj;
33713 wxMenu *arg1 = (wxMenu *) 0 ;
33714 size_t arg2 ;
33715 wxMenuItem *result;
33716 PyObject * obj0 = 0 ;
33717 PyObject * obj1 = 0 ;
33718 char *kwnames[] = {
33719 (char *) "self",(char *) "position", NULL
33720 };
33721
33722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33724 if (SWIG_arg_fail(1)) SWIG_fail;
33725 {
33726 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33727 if (SWIG_arg_fail(2)) SWIG_fail;
33728 }
33729 {
33730 PyThreadState* __tstate = wxPyBeginAllowThreads();
33731 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33732
33733 wxPyEndAllowThreads(__tstate);
33734 if (PyErr_Occurred()) SWIG_fail;
33735 }
33736 {
33737 resultobj = wxPyMake_wxObject(result, 0);
33738 }
33739 return resultobj;
33740 fail:
33741 return NULL;
33742 }
33743
33744
33745 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33746 PyObject *resultobj;
33747 wxMenu *arg1 = (wxMenu *) 0 ;
33748 int arg2 ;
33749 bool arg3 ;
33750 PyObject * obj0 = 0 ;
33751 PyObject * obj1 = 0 ;
33752 PyObject * obj2 = 0 ;
33753 char *kwnames[] = {
33754 (char *) "self",(char *) "id",(char *) "enable", NULL
33755 };
33756
33757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33759 if (SWIG_arg_fail(1)) SWIG_fail;
33760 {
33761 arg2 = (int)(SWIG_As_int(obj1));
33762 if (SWIG_arg_fail(2)) SWIG_fail;
33763 }
33764 {
33765 arg3 = (bool)(SWIG_As_bool(obj2));
33766 if (SWIG_arg_fail(3)) SWIG_fail;
33767 }
33768 {
33769 PyThreadState* __tstate = wxPyBeginAllowThreads();
33770 (arg1)->Enable(arg2,arg3);
33771
33772 wxPyEndAllowThreads(__tstate);
33773 if (PyErr_Occurred()) SWIG_fail;
33774 }
33775 Py_INCREF(Py_None); resultobj = Py_None;
33776 return resultobj;
33777 fail:
33778 return NULL;
33779 }
33780
33781
33782 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33783 PyObject *resultobj;
33784 wxMenu *arg1 = (wxMenu *) 0 ;
33785 int arg2 ;
33786 bool result;
33787 PyObject * obj0 = 0 ;
33788 PyObject * obj1 = 0 ;
33789 char *kwnames[] = {
33790 (char *) "self",(char *) "id", NULL
33791 };
33792
33793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33795 if (SWIG_arg_fail(1)) SWIG_fail;
33796 {
33797 arg2 = (int)(SWIG_As_int(obj1));
33798 if (SWIG_arg_fail(2)) SWIG_fail;
33799 }
33800 {
33801 PyThreadState* __tstate = wxPyBeginAllowThreads();
33802 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33803
33804 wxPyEndAllowThreads(__tstate);
33805 if (PyErr_Occurred()) SWIG_fail;
33806 }
33807 {
33808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33809 }
33810 return resultobj;
33811 fail:
33812 return NULL;
33813 }
33814
33815
33816 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj;
33818 wxMenu *arg1 = (wxMenu *) 0 ;
33819 int arg2 ;
33820 bool arg3 ;
33821 PyObject * obj0 = 0 ;
33822 PyObject * obj1 = 0 ;
33823 PyObject * obj2 = 0 ;
33824 char *kwnames[] = {
33825 (char *) "self",(char *) "id",(char *) "check", NULL
33826 };
33827
33828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33830 if (SWIG_arg_fail(1)) SWIG_fail;
33831 {
33832 arg2 = (int)(SWIG_As_int(obj1));
33833 if (SWIG_arg_fail(2)) SWIG_fail;
33834 }
33835 {
33836 arg3 = (bool)(SWIG_As_bool(obj2));
33837 if (SWIG_arg_fail(3)) SWIG_fail;
33838 }
33839 {
33840 PyThreadState* __tstate = wxPyBeginAllowThreads();
33841 (arg1)->Check(arg2,arg3);
33842
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 Py_INCREF(Py_None); resultobj = Py_None;
33847 return resultobj;
33848 fail:
33849 return NULL;
33850 }
33851
33852
33853 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33854 PyObject *resultobj;
33855 wxMenu *arg1 = (wxMenu *) 0 ;
33856 int arg2 ;
33857 bool result;
33858 PyObject * obj0 = 0 ;
33859 PyObject * obj1 = 0 ;
33860 char *kwnames[] = {
33861 (char *) "self",(char *) "id", NULL
33862 };
33863
33864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33866 if (SWIG_arg_fail(1)) SWIG_fail;
33867 {
33868 arg2 = (int)(SWIG_As_int(obj1));
33869 if (SWIG_arg_fail(2)) SWIG_fail;
33870 }
33871 {
33872 PyThreadState* __tstate = wxPyBeginAllowThreads();
33873 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33874
33875 wxPyEndAllowThreads(__tstate);
33876 if (PyErr_Occurred()) SWIG_fail;
33877 }
33878 {
33879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33880 }
33881 return resultobj;
33882 fail:
33883 return NULL;
33884 }
33885
33886
33887 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33888 PyObject *resultobj;
33889 wxMenu *arg1 = (wxMenu *) 0 ;
33890 int arg2 ;
33891 wxString *arg3 = 0 ;
33892 bool temp3 = false ;
33893 PyObject * obj0 = 0 ;
33894 PyObject * obj1 = 0 ;
33895 PyObject * obj2 = 0 ;
33896 char *kwnames[] = {
33897 (char *) "self",(char *) "id",(char *) "label", NULL
33898 };
33899
33900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33902 if (SWIG_arg_fail(1)) SWIG_fail;
33903 {
33904 arg2 = (int)(SWIG_As_int(obj1));
33905 if (SWIG_arg_fail(2)) SWIG_fail;
33906 }
33907 {
33908 arg3 = wxString_in_helper(obj2);
33909 if (arg3 == NULL) SWIG_fail;
33910 temp3 = true;
33911 }
33912 {
33913 PyThreadState* __tstate = wxPyBeginAllowThreads();
33914 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33915
33916 wxPyEndAllowThreads(__tstate);
33917 if (PyErr_Occurred()) SWIG_fail;
33918 }
33919 Py_INCREF(Py_None); resultobj = Py_None;
33920 {
33921 if (temp3)
33922 delete arg3;
33923 }
33924 return resultobj;
33925 fail:
33926 {
33927 if (temp3)
33928 delete arg3;
33929 }
33930 return NULL;
33931 }
33932
33933
33934 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33935 PyObject *resultobj;
33936 wxMenu *arg1 = (wxMenu *) 0 ;
33937 int arg2 ;
33938 wxString result;
33939 PyObject * obj0 = 0 ;
33940 PyObject * obj1 = 0 ;
33941 char *kwnames[] = {
33942 (char *) "self",(char *) "id", NULL
33943 };
33944
33945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33947 if (SWIG_arg_fail(1)) SWIG_fail;
33948 {
33949 arg2 = (int)(SWIG_As_int(obj1));
33950 if (SWIG_arg_fail(2)) SWIG_fail;
33951 }
33952 {
33953 PyThreadState* __tstate = wxPyBeginAllowThreads();
33954 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33955
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 {
33960 #if wxUSE_UNICODE
33961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33962 #else
33963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33964 #endif
33965 }
33966 return resultobj;
33967 fail:
33968 return NULL;
33969 }
33970
33971
33972 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33973 PyObject *resultobj;
33974 wxMenu *arg1 = (wxMenu *) 0 ;
33975 int arg2 ;
33976 wxString *arg3 = 0 ;
33977 bool temp3 = false ;
33978 PyObject * obj0 = 0 ;
33979 PyObject * obj1 = 0 ;
33980 PyObject * obj2 = 0 ;
33981 char *kwnames[] = {
33982 (char *) "self",(char *) "id",(char *) "helpString", NULL
33983 };
33984
33985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33987 if (SWIG_arg_fail(1)) SWIG_fail;
33988 {
33989 arg2 = (int)(SWIG_As_int(obj1));
33990 if (SWIG_arg_fail(2)) SWIG_fail;
33991 }
33992 {
33993 arg3 = wxString_in_helper(obj2);
33994 if (arg3 == NULL) SWIG_fail;
33995 temp3 = true;
33996 }
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34000
34001 wxPyEndAllowThreads(__tstate);
34002 if (PyErr_Occurred()) SWIG_fail;
34003 }
34004 Py_INCREF(Py_None); resultobj = Py_None;
34005 {
34006 if (temp3)
34007 delete arg3;
34008 }
34009 return resultobj;
34010 fail:
34011 {
34012 if (temp3)
34013 delete arg3;
34014 }
34015 return NULL;
34016 }
34017
34018
34019 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34020 PyObject *resultobj;
34021 wxMenu *arg1 = (wxMenu *) 0 ;
34022 int arg2 ;
34023 wxString result;
34024 PyObject * obj0 = 0 ;
34025 PyObject * obj1 = 0 ;
34026 char *kwnames[] = {
34027 (char *) "self",(char *) "id", NULL
34028 };
34029
34030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34032 if (SWIG_arg_fail(1)) SWIG_fail;
34033 {
34034 arg2 = (int)(SWIG_As_int(obj1));
34035 if (SWIG_arg_fail(2)) SWIG_fail;
34036 }
34037 {
34038 PyThreadState* __tstate = wxPyBeginAllowThreads();
34039 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34040
34041 wxPyEndAllowThreads(__tstate);
34042 if (PyErr_Occurred()) SWIG_fail;
34043 }
34044 {
34045 #if wxUSE_UNICODE
34046 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34047 #else
34048 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34049 #endif
34050 }
34051 return resultobj;
34052 fail:
34053 return NULL;
34054 }
34055
34056
34057 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34058 PyObject *resultobj;
34059 wxMenu *arg1 = (wxMenu *) 0 ;
34060 wxString *arg2 = 0 ;
34061 bool temp2 = false ;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 char *kwnames[] = {
34065 (char *) "self",(char *) "title", NULL
34066 };
34067
34068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",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 {
34072 arg2 = wxString_in_helper(obj1);
34073 if (arg2 == NULL) SWIG_fail;
34074 temp2 = true;
34075 }
34076 {
34077 PyThreadState* __tstate = wxPyBeginAllowThreads();
34078 (arg1)->SetTitle((wxString const &)*arg2);
34079
34080 wxPyEndAllowThreads(__tstate);
34081 if (PyErr_Occurred()) SWIG_fail;
34082 }
34083 Py_INCREF(Py_None); resultobj = Py_None;
34084 {
34085 if (temp2)
34086 delete arg2;
34087 }
34088 return resultobj;
34089 fail:
34090 {
34091 if (temp2)
34092 delete arg2;
34093 }
34094 return NULL;
34095 }
34096
34097
34098 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34099 PyObject *resultobj;
34100 wxMenu *arg1 = (wxMenu *) 0 ;
34101 wxString result;
34102 PyObject * obj0 = 0 ;
34103 char *kwnames[] = {
34104 (char *) "self", NULL
34105 };
34106
34107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34109 if (SWIG_arg_fail(1)) SWIG_fail;
34110 {
34111 PyThreadState* __tstate = wxPyBeginAllowThreads();
34112 result = ((wxMenu const *)arg1)->GetTitle();
34113
34114 wxPyEndAllowThreads(__tstate);
34115 if (PyErr_Occurred()) SWIG_fail;
34116 }
34117 {
34118 #if wxUSE_UNICODE
34119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34120 #else
34121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34122 #endif
34123 }
34124 return resultobj;
34125 fail:
34126 return NULL;
34127 }
34128
34129
34130 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34131 PyObject *resultobj;
34132 wxMenu *arg1 = (wxMenu *) 0 ;
34133 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34134 PyObject * obj0 = 0 ;
34135 PyObject * obj1 = 0 ;
34136 char *kwnames[] = {
34137 (char *) "self",(char *) "handler", NULL
34138 };
34139
34140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34142 if (SWIG_arg_fail(1)) SWIG_fail;
34143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34144 if (SWIG_arg_fail(2)) SWIG_fail;
34145 {
34146 PyThreadState* __tstate = wxPyBeginAllowThreads();
34147 (arg1)->SetEventHandler(arg2);
34148
34149 wxPyEndAllowThreads(__tstate);
34150 if (PyErr_Occurred()) SWIG_fail;
34151 }
34152 Py_INCREF(Py_None); resultobj = Py_None;
34153 return resultobj;
34154 fail:
34155 return NULL;
34156 }
34157
34158
34159 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34160 PyObject *resultobj;
34161 wxMenu *arg1 = (wxMenu *) 0 ;
34162 wxEvtHandler *result;
34163 PyObject * obj0 = 0 ;
34164 char *kwnames[] = {
34165 (char *) "self", NULL
34166 };
34167
34168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34170 if (SWIG_arg_fail(1)) SWIG_fail;
34171 {
34172 PyThreadState* __tstate = wxPyBeginAllowThreads();
34173 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34174
34175 wxPyEndAllowThreads(__tstate);
34176 if (PyErr_Occurred()) SWIG_fail;
34177 }
34178 {
34179 resultobj = wxPyMake_wxObject(result, 0);
34180 }
34181 return resultobj;
34182 fail:
34183 return NULL;
34184 }
34185
34186
34187 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34188 PyObject *resultobj;
34189 wxMenu *arg1 = (wxMenu *) 0 ;
34190 wxWindow *arg2 = (wxWindow *) 0 ;
34191 PyObject * obj0 = 0 ;
34192 PyObject * obj1 = 0 ;
34193 char *kwnames[] = {
34194 (char *) "self",(char *) "win", NULL
34195 };
34196
34197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34199 if (SWIG_arg_fail(1)) SWIG_fail;
34200 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34201 if (SWIG_arg_fail(2)) SWIG_fail;
34202 {
34203 PyThreadState* __tstate = wxPyBeginAllowThreads();
34204 (arg1)->SetInvokingWindow(arg2);
34205
34206 wxPyEndAllowThreads(__tstate);
34207 if (PyErr_Occurred()) SWIG_fail;
34208 }
34209 Py_INCREF(Py_None); resultobj = Py_None;
34210 return resultobj;
34211 fail:
34212 return NULL;
34213 }
34214
34215
34216 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34217 PyObject *resultobj;
34218 wxMenu *arg1 = (wxMenu *) 0 ;
34219 wxWindow *result;
34220 PyObject * obj0 = 0 ;
34221 char *kwnames[] = {
34222 (char *) "self", NULL
34223 };
34224
34225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34227 if (SWIG_arg_fail(1)) SWIG_fail;
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34231
34232 wxPyEndAllowThreads(__tstate);
34233 if (PyErr_Occurred()) SWIG_fail;
34234 }
34235 {
34236 resultobj = wxPyMake_wxObject(result, 0);
34237 }
34238 return resultobj;
34239 fail:
34240 return NULL;
34241 }
34242
34243
34244 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34245 PyObject *resultobj;
34246 wxMenu *arg1 = (wxMenu *) 0 ;
34247 long result;
34248 PyObject * obj0 = 0 ;
34249 char *kwnames[] = {
34250 (char *) "self", NULL
34251 };
34252
34253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34255 if (SWIG_arg_fail(1)) SWIG_fail;
34256 {
34257 PyThreadState* __tstate = wxPyBeginAllowThreads();
34258 result = (long)((wxMenu const *)arg1)->GetStyle();
34259
34260 wxPyEndAllowThreads(__tstate);
34261 if (PyErr_Occurred()) SWIG_fail;
34262 }
34263 {
34264 resultobj = SWIG_From_long((long)(result));
34265 }
34266 return resultobj;
34267 fail:
34268 return NULL;
34269 }
34270
34271
34272 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34273 PyObject *resultobj;
34274 wxMenu *arg1 = (wxMenu *) 0 ;
34275 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34276 PyObject * obj0 = 0 ;
34277 PyObject * obj1 = 0 ;
34278 char *kwnames[] = {
34279 (char *) "self",(char *) "source", NULL
34280 };
34281
34282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34284 if (SWIG_arg_fail(1)) SWIG_fail;
34285 if (obj1) {
34286 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34287 if (SWIG_arg_fail(2)) SWIG_fail;
34288 }
34289 {
34290 PyThreadState* __tstate = wxPyBeginAllowThreads();
34291 (arg1)->UpdateUI(arg2);
34292
34293 wxPyEndAllowThreads(__tstate);
34294 if (PyErr_Occurred()) SWIG_fail;
34295 }
34296 Py_INCREF(Py_None); resultobj = Py_None;
34297 return resultobj;
34298 fail:
34299 return NULL;
34300 }
34301
34302
34303 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34304 PyObject *resultobj;
34305 wxMenu *arg1 = (wxMenu *) 0 ;
34306 wxMenuBar *result;
34307 PyObject * obj0 = 0 ;
34308 char *kwnames[] = {
34309 (char *) "self", NULL
34310 };
34311
34312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34314 if (SWIG_arg_fail(1)) SWIG_fail;
34315 {
34316 PyThreadState* __tstate = wxPyBeginAllowThreads();
34317 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34318
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 {
34323 resultobj = wxPyMake_wxObject(result, 0);
34324 }
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34332 PyObject *resultobj;
34333 wxMenu *arg1 = (wxMenu *) 0 ;
34334 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34335 PyObject * obj0 = 0 ;
34336 PyObject * obj1 = 0 ;
34337 char *kwnames[] = {
34338 (char *) "self",(char *) "menubar", NULL
34339 };
34340
34341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34343 if (SWIG_arg_fail(1)) SWIG_fail;
34344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34345 if (SWIG_arg_fail(2)) SWIG_fail;
34346 {
34347 PyThreadState* __tstate = wxPyBeginAllowThreads();
34348 (arg1)->Attach(arg2);
34349
34350 wxPyEndAllowThreads(__tstate);
34351 if (PyErr_Occurred()) SWIG_fail;
34352 }
34353 Py_INCREF(Py_None); resultobj = Py_None;
34354 return resultobj;
34355 fail:
34356 return NULL;
34357 }
34358
34359
34360 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34361 PyObject *resultobj;
34362 wxMenu *arg1 = (wxMenu *) 0 ;
34363 PyObject * obj0 = 0 ;
34364 char *kwnames[] = {
34365 (char *) "self", NULL
34366 };
34367
34368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34370 if (SWIG_arg_fail(1)) SWIG_fail;
34371 {
34372 PyThreadState* __tstate = wxPyBeginAllowThreads();
34373 (arg1)->Detach();
34374
34375 wxPyEndAllowThreads(__tstate);
34376 if (PyErr_Occurred()) SWIG_fail;
34377 }
34378 Py_INCREF(Py_None); resultobj = Py_None;
34379 return resultobj;
34380 fail:
34381 return NULL;
34382 }
34383
34384
34385 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34386 PyObject *resultobj;
34387 wxMenu *arg1 = (wxMenu *) 0 ;
34388 bool result;
34389 PyObject * obj0 = 0 ;
34390 char *kwnames[] = {
34391 (char *) "self", NULL
34392 };
34393
34394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34396 if (SWIG_arg_fail(1)) SWIG_fail;
34397 {
34398 PyThreadState* __tstate = wxPyBeginAllowThreads();
34399 result = (bool)((wxMenu const *)arg1)->IsAttached();
34400
34401 wxPyEndAllowThreads(__tstate);
34402 if (PyErr_Occurred()) SWIG_fail;
34403 }
34404 {
34405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34406 }
34407 return resultobj;
34408 fail:
34409 return NULL;
34410 }
34411
34412
34413 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34414 PyObject *resultobj;
34415 wxMenu *arg1 = (wxMenu *) 0 ;
34416 wxMenu *arg2 = (wxMenu *) 0 ;
34417 PyObject * obj0 = 0 ;
34418 PyObject * obj1 = 0 ;
34419 char *kwnames[] = {
34420 (char *) "self",(char *) "parent", NULL
34421 };
34422
34423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34425 if (SWIG_arg_fail(1)) SWIG_fail;
34426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34427 if (SWIG_arg_fail(2)) SWIG_fail;
34428 {
34429 PyThreadState* __tstate = wxPyBeginAllowThreads();
34430 (arg1)->SetParent(arg2);
34431
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 Py_INCREF(Py_None); resultobj = Py_None;
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34443 PyObject *resultobj;
34444 wxMenu *arg1 = (wxMenu *) 0 ;
34445 wxMenu *result;
34446 PyObject * obj0 = 0 ;
34447 char *kwnames[] = {
34448 (char *) "self", NULL
34449 };
34450
34451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34453 if (SWIG_arg_fail(1)) SWIG_fail;
34454 {
34455 PyThreadState* __tstate = wxPyBeginAllowThreads();
34456 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34457
34458 wxPyEndAllowThreads(__tstate);
34459 if (PyErr_Occurred()) SWIG_fail;
34460 }
34461 {
34462 resultobj = wxPyMake_wxObject(result, 0);
34463 }
34464 return resultobj;
34465 fail:
34466 return NULL;
34467 }
34468
34469
34470 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34471 PyObject *obj;
34472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34473 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34474 Py_INCREF(obj);
34475 return Py_BuildValue((char *)"");
34476 }
34477 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34478 PyObject *resultobj;
34479 long arg1 = (long) 0 ;
34480 wxMenuBar *result;
34481 PyObject * obj0 = 0 ;
34482 char *kwnames[] = {
34483 (char *) "style", NULL
34484 };
34485
34486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34487 if (obj0) {
34488 {
34489 arg1 = (long)(SWIG_As_long(obj0));
34490 if (SWIG_arg_fail(1)) SWIG_fail;
34491 }
34492 }
34493 {
34494 if (!wxPyCheckForApp()) SWIG_fail;
34495 PyThreadState* __tstate = wxPyBeginAllowThreads();
34496 result = (wxMenuBar *)new wxMenuBar(arg1);
34497
34498 wxPyEndAllowThreads(__tstate);
34499 if (PyErr_Occurred()) SWIG_fail;
34500 }
34501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34502 return resultobj;
34503 fail:
34504 return NULL;
34505 }
34506
34507
34508 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34509 PyObject *resultobj;
34510 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34511 wxMenu *arg2 = (wxMenu *) 0 ;
34512 wxString *arg3 = 0 ;
34513 bool result;
34514 bool temp3 = false ;
34515 PyObject * obj0 = 0 ;
34516 PyObject * obj1 = 0 ;
34517 PyObject * obj2 = 0 ;
34518 char *kwnames[] = {
34519 (char *) "self",(char *) "menu",(char *) "title", NULL
34520 };
34521
34522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34524 if (SWIG_arg_fail(1)) SWIG_fail;
34525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34526 if (SWIG_arg_fail(2)) SWIG_fail;
34527 {
34528 arg3 = wxString_in_helper(obj2);
34529 if (arg3 == NULL) SWIG_fail;
34530 temp3 = true;
34531 }
34532 {
34533 PyThreadState* __tstate = wxPyBeginAllowThreads();
34534 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34535
34536 wxPyEndAllowThreads(__tstate);
34537 if (PyErr_Occurred()) SWIG_fail;
34538 }
34539 {
34540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34541 }
34542 {
34543 if (temp3)
34544 delete arg3;
34545 }
34546 return resultobj;
34547 fail:
34548 {
34549 if (temp3)
34550 delete arg3;
34551 }
34552 return NULL;
34553 }
34554
34555
34556 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34557 PyObject *resultobj;
34558 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34559 size_t arg2 ;
34560 wxMenu *arg3 = (wxMenu *) 0 ;
34561 wxString *arg4 = 0 ;
34562 bool result;
34563 bool temp4 = false ;
34564 PyObject * obj0 = 0 ;
34565 PyObject * obj1 = 0 ;
34566 PyObject * obj2 = 0 ;
34567 PyObject * obj3 = 0 ;
34568 char *kwnames[] = {
34569 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34570 };
34571
34572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34574 if (SWIG_arg_fail(1)) SWIG_fail;
34575 {
34576 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34577 if (SWIG_arg_fail(2)) SWIG_fail;
34578 }
34579 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34580 if (SWIG_arg_fail(3)) SWIG_fail;
34581 {
34582 arg4 = wxString_in_helper(obj3);
34583 if (arg4 == NULL) SWIG_fail;
34584 temp4 = true;
34585 }
34586 {
34587 PyThreadState* __tstate = wxPyBeginAllowThreads();
34588 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34589
34590 wxPyEndAllowThreads(__tstate);
34591 if (PyErr_Occurred()) SWIG_fail;
34592 }
34593 {
34594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34595 }
34596 {
34597 if (temp4)
34598 delete arg4;
34599 }
34600 return resultobj;
34601 fail:
34602 {
34603 if (temp4)
34604 delete arg4;
34605 }
34606 return NULL;
34607 }
34608
34609
34610 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34611 PyObject *resultobj;
34612 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34613 size_t result;
34614 PyObject * obj0 = 0 ;
34615 char *kwnames[] = {
34616 (char *) "self", NULL
34617 };
34618
34619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34621 if (SWIG_arg_fail(1)) SWIG_fail;
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34625
34626 wxPyEndAllowThreads(__tstate);
34627 if (PyErr_Occurred()) SWIG_fail;
34628 }
34629 {
34630 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34631 }
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34639 PyObject *resultobj;
34640 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34641 size_t arg2 ;
34642 wxMenu *result;
34643 PyObject * obj0 = 0 ;
34644 PyObject * obj1 = 0 ;
34645 char *kwnames[] = {
34646 (char *) "self",(char *) "pos", NULL
34647 };
34648
34649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34651 if (SWIG_arg_fail(1)) SWIG_fail;
34652 {
34653 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34654 if (SWIG_arg_fail(2)) SWIG_fail;
34655 }
34656 {
34657 PyThreadState* __tstate = wxPyBeginAllowThreads();
34658 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34659
34660 wxPyEndAllowThreads(__tstate);
34661 if (PyErr_Occurred()) SWIG_fail;
34662 }
34663 {
34664 resultobj = wxPyMake_wxObject(result, 0);
34665 }
34666 return resultobj;
34667 fail:
34668 return NULL;
34669 }
34670
34671
34672 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34673 PyObject *resultobj;
34674 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34675 size_t arg2 ;
34676 wxMenu *arg3 = (wxMenu *) 0 ;
34677 wxString *arg4 = 0 ;
34678 wxMenu *result;
34679 bool temp4 = false ;
34680 PyObject * obj0 = 0 ;
34681 PyObject * obj1 = 0 ;
34682 PyObject * obj2 = 0 ;
34683 PyObject * obj3 = 0 ;
34684 char *kwnames[] = {
34685 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34686 };
34687
34688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34690 if (SWIG_arg_fail(1)) SWIG_fail;
34691 {
34692 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34693 if (SWIG_arg_fail(2)) SWIG_fail;
34694 }
34695 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34696 if (SWIG_arg_fail(3)) SWIG_fail;
34697 {
34698 arg4 = wxString_in_helper(obj3);
34699 if (arg4 == NULL) SWIG_fail;
34700 temp4 = true;
34701 }
34702 {
34703 PyThreadState* __tstate = wxPyBeginAllowThreads();
34704 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34705
34706 wxPyEndAllowThreads(__tstate);
34707 if (PyErr_Occurred()) SWIG_fail;
34708 }
34709 {
34710 resultobj = wxPyMake_wxObject(result, 0);
34711 }
34712 {
34713 if (temp4)
34714 delete arg4;
34715 }
34716 return resultobj;
34717 fail:
34718 {
34719 if (temp4)
34720 delete arg4;
34721 }
34722 return NULL;
34723 }
34724
34725
34726 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34727 PyObject *resultobj;
34728 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34729 size_t arg2 ;
34730 wxMenu *result;
34731 PyObject * obj0 = 0 ;
34732 PyObject * obj1 = 0 ;
34733 char *kwnames[] = {
34734 (char *) "self",(char *) "pos", NULL
34735 };
34736
34737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34739 if (SWIG_arg_fail(1)) SWIG_fail;
34740 {
34741 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34742 if (SWIG_arg_fail(2)) SWIG_fail;
34743 }
34744 {
34745 PyThreadState* __tstate = wxPyBeginAllowThreads();
34746 result = (wxMenu *)(arg1)->Remove(arg2);
34747
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 {
34752 resultobj = wxPyMake_wxObject(result, 0);
34753 }
34754 return resultobj;
34755 fail:
34756 return NULL;
34757 }
34758
34759
34760 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34761 PyObject *resultobj;
34762 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34763 size_t arg2 ;
34764 bool arg3 ;
34765 PyObject * obj0 = 0 ;
34766 PyObject * obj1 = 0 ;
34767 PyObject * obj2 = 0 ;
34768 char *kwnames[] = {
34769 (char *) "self",(char *) "pos",(char *) "enable", NULL
34770 };
34771
34772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34774 if (SWIG_arg_fail(1)) SWIG_fail;
34775 {
34776 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34777 if (SWIG_arg_fail(2)) SWIG_fail;
34778 }
34779 {
34780 arg3 = (bool)(SWIG_As_bool(obj2));
34781 if (SWIG_arg_fail(3)) SWIG_fail;
34782 }
34783 {
34784 PyThreadState* __tstate = wxPyBeginAllowThreads();
34785 (arg1)->EnableTop(arg2,arg3);
34786
34787 wxPyEndAllowThreads(__tstate);
34788 if (PyErr_Occurred()) SWIG_fail;
34789 }
34790 Py_INCREF(Py_None); resultobj = Py_None;
34791 return resultobj;
34792 fail:
34793 return NULL;
34794 }
34795
34796
34797 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34798 PyObject *resultobj;
34799 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34800 size_t arg2 ;
34801 bool result;
34802 PyObject * obj0 = 0 ;
34803 PyObject * obj1 = 0 ;
34804 char *kwnames[] = {
34805 (char *) "self",(char *) "pos", NULL
34806 };
34807
34808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34810 if (SWIG_arg_fail(1)) SWIG_fail;
34811 {
34812 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34813 if (SWIG_arg_fail(2)) SWIG_fail;
34814 }
34815 {
34816 PyThreadState* __tstate = wxPyBeginAllowThreads();
34817 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34818
34819 wxPyEndAllowThreads(__tstate);
34820 if (PyErr_Occurred()) SWIG_fail;
34821 }
34822 {
34823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34824 }
34825 return resultobj;
34826 fail:
34827 return NULL;
34828 }
34829
34830
34831 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34832 PyObject *resultobj;
34833 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34834 size_t arg2 ;
34835 wxString *arg3 = 0 ;
34836 bool temp3 = false ;
34837 PyObject * obj0 = 0 ;
34838 PyObject * obj1 = 0 ;
34839 PyObject * obj2 = 0 ;
34840 char *kwnames[] = {
34841 (char *) "self",(char *) "pos",(char *) "label", NULL
34842 };
34843
34844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34846 if (SWIG_arg_fail(1)) SWIG_fail;
34847 {
34848 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34849 if (SWIG_arg_fail(2)) SWIG_fail;
34850 }
34851 {
34852 arg3 = wxString_in_helper(obj2);
34853 if (arg3 == NULL) SWIG_fail;
34854 temp3 = true;
34855 }
34856 {
34857 PyThreadState* __tstate = wxPyBeginAllowThreads();
34858 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34859
34860 wxPyEndAllowThreads(__tstate);
34861 if (PyErr_Occurred()) SWIG_fail;
34862 }
34863 Py_INCREF(Py_None); resultobj = Py_None;
34864 {
34865 if (temp3)
34866 delete arg3;
34867 }
34868 return resultobj;
34869 fail:
34870 {
34871 if (temp3)
34872 delete arg3;
34873 }
34874 return NULL;
34875 }
34876
34877
34878 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34879 PyObject *resultobj;
34880 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34881 size_t arg2 ;
34882 wxString result;
34883 PyObject * obj0 = 0 ;
34884 PyObject * obj1 = 0 ;
34885 char *kwnames[] = {
34886 (char *) "self",(char *) "pos", NULL
34887 };
34888
34889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34891 if (SWIG_arg_fail(1)) SWIG_fail;
34892 {
34893 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34894 if (SWIG_arg_fail(2)) SWIG_fail;
34895 }
34896 {
34897 PyThreadState* __tstate = wxPyBeginAllowThreads();
34898 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34899
34900 wxPyEndAllowThreads(__tstate);
34901 if (PyErr_Occurred()) SWIG_fail;
34902 }
34903 {
34904 #if wxUSE_UNICODE
34905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34906 #else
34907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34908 #endif
34909 }
34910 return resultobj;
34911 fail:
34912 return NULL;
34913 }
34914
34915
34916 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34917 PyObject *resultobj;
34918 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34919 wxString *arg2 = 0 ;
34920 wxString *arg3 = 0 ;
34921 int result;
34922 bool temp2 = false ;
34923 bool temp3 = false ;
34924 PyObject * obj0 = 0 ;
34925 PyObject * obj1 = 0 ;
34926 PyObject * obj2 = 0 ;
34927 char *kwnames[] = {
34928 (char *) "self",(char *) "menu",(char *) "item", NULL
34929 };
34930
34931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34933 if (SWIG_arg_fail(1)) SWIG_fail;
34934 {
34935 arg2 = wxString_in_helper(obj1);
34936 if (arg2 == NULL) SWIG_fail;
34937 temp2 = true;
34938 }
34939 {
34940 arg3 = wxString_in_helper(obj2);
34941 if (arg3 == NULL) SWIG_fail;
34942 temp3 = true;
34943 }
34944 {
34945 PyThreadState* __tstate = wxPyBeginAllowThreads();
34946 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34947
34948 wxPyEndAllowThreads(__tstate);
34949 if (PyErr_Occurred()) SWIG_fail;
34950 }
34951 {
34952 resultobj = SWIG_From_int((int)(result));
34953 }
34954 {
34955 if (temp2)
34956 delete arg2;
34957 }
34958 {
34959 if (temp3)
34960 delete arg3;
34961 }
34962 return resultobj;
34963 fail:
34964 {
34965 if (temp2)
34966 delete arg2;
34967 }
34968 {
34969 if (temp3)
34970 delete arg3;
34971 }
34972 return NULL;
34973 }
34974
34975
34976 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34977 PyObject *resultobj;
34978 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34979 int arg2 ;
34980 wxMenuItem *result;
34981 PyObject * obj0 = 0 ;
34982 PyObject * obj1 = 0 ;
34983 char *kwnames[] = {
34984 (char *) "self",(char *) "id", NULL
34985 };
34986
34987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34989 if (SWIG_arg_fail(1)) SWIG_fail;
34990 {
34991 arg2 = (int)(SWIG_As_int(obj1));
34992 if (SWIG_arg_fail(2)) SWIG_fail;
34993 }
34994 {
34995 PyThreadState* __tstate = wxPyBeginAllowThreads();
34996 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34997
34998 wxPyEndAllowThreads(__tstate);
34999 if (PyErr_Occurred()) SWIG_fail;
35000 }
35001 {
35002 resultobj = wxPyMake_wxObject(result, 0);
35003 }
35004 return resultobj;
35005 fail:
35006 return NULL;
35007 }
35008
35009
35010 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35011 PyObject *resultobj;
35012 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35013 wxString *arg2 = 0 ;
35014 int result;
35015 bool temp2 = false ;
35016 PyObject * obj0 = 0 ;
35017 PyObject * obj1 = 0 ;
35018 char *kwnames[] = {
35019 (char *) "self",(char *) "title", NULL
35020 };
35021
35022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35024 if (SWIG_arg_fail(1)) SWIG_fail;
35025 {
35026 arg2 = wxString_in_helper(obj1);
35027 if (arg2 == NULL) SWIG_fail;
35028 temp2 = true;
35029 }
35030 {
35031 PyThreadState* __tstate = wxPyBeginAllowThreads();
35032 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35033
35034 wxPyEndAllowThreads(__tstate);
35035 if (PyErr_Occurred()) SWIG_fail;
35036 }
35037 {
35038 resultobj = SWIG_From_int((int)(result));
35039 }
35040 {
35041 if (temp2)
35042 delete arg2;
35043 }
35044 return resultobj;
35045 fail:
35046 {
35047 if (temp2)
35048 delete arg2;
35049 }
35050 return NULL;
35051 }
35052
35053
35054 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35055 PyObject *resultobj;
35056 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35057 int arg2 ;
35058 bool arg3 ;
35059 PyObject * obj0 = 0 ;
35060 PyObject * obj1 = 0 ;
35061 PyObject * obj2 = 0 ;
35062 char *kwnames[] = {
35063 (char *) "self",(char *) "id",(char *) "enable", NULL
35064 };
35065
35066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35068 if (SWIG_arg_fail(1)) SWIG_fail;
35069 {
35070 arg2 = (int)(SWIG_As_int(obj1));
35071 if (SWIG_arg_fail(2)) SWIG_fail;
35072 }
35073 {
35074 arg3 = (bool)(SWIG_As_bool(obj2));
35075 if (SWIG_arg_fail(3)) SWIG_fail;
35076 }
35077 {
35078 PyThreadState* __tstate = wxPyBeginAllowThreads();
35079 (arg1)->Enable(arg2,arg3);
35080
35081 wxPyEndAllowThreads(__tstate);
35082 if (PyErr_Occurred()) SWIG_fail;
35083 }
35084 Py_INCREF(Py_None); resultobj = Py_None;
35085 return resultobj;
35086 fail:
35087 return NULL;
35088 }
35089
35090
35091 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35092 PyObject *resultobj;
35093 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35094 int arg2 ;
35095 bool arg3 ;
35096 PyObject * obj0 = 0 ;
35097 PyObject * obj1 = 0 ;
35098 PyObject * obj2 = 0 ;
35099 char *kwnames[] = {
35100 (char *) "self",(char *) "id",(char *) "check", NULL
35101 };
35102
35103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35105 if (SWIG_arg_fail(1)) SWIG_fail;
35106 {
35107 arg2 = (int)(SWIG_As_int(obj1));
35108 if (SWIG_arg_fail(2)) SWIG_fail;
35109 }
35110 {
35111 arg3 = (bool)(SWIG_As_bool(obj2));
35112 if (SWIG_arg_fail(3)) SWIG_fail;
35113 }
35114 {
35115 PyThreadState* __tstate = wxPyBeginAllowThreads();
35116 (arg1)->Check(arg2,arg3);
35117
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 Py_INCREF(Py_None); resultobj = Py_None;
35122 return resultobj;
35123 fail:
35124 return NULL;
35125 }
35126
35127
35128 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35129 PyObject *resultobj;
35130 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35131 int arg2 ;
35132 bool result;
35133 PyObject * obj0 = 0 ;
35134 PyObject * obj1 = 0 ;
35135 char *kwnames[] = {
35136 (char *) "self",(char *) "id", NULL
35137 };
35138
35139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35141 if (SWIG_arg_fail(1)) SWIG_fail;
35142 {
35143 arg2 = (int)(SWIG_As_int(obj1));
35144 if (SWIG_arg_fail(2)) SWIG_fail;
35145 }
35146 {
35147 PyThreadState* __tstate = wxPyBeginAllowThreads();
35148 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35149
35150 wxPyEndAllowThreads(__tstate);
35151 if (PyErr_Occurred()) SWIG_fail;
35152 }
35153 {
35154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35155 }
35156 return resultobj;
35157 fail:
35158 return NULL;
35159 }
35160
35161
35162 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35163 PyObject *resultobj;
35164 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35165 int arg2 ;
35166 bool result;
35167 PyObject * obj0 = 0 ;
35168 PyObject * obj1 = 0 ;
35169 char *kwnames[] = {
35170 (char *) "self",(char *) "id", NULL
35171 };
35172
35173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35175 if (SWIG_arg_fail(1)) SWIG_fail;
35176 {
35177 arg2 = (int)(SWIG_As_int(obj1));
35178 if (SWIG_arg_fail(2)) SWIG_fail;
35179 }
35180 {
35181 PyThreadState* __tstate = wxPyBeginAllowThreads();
35182 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35183
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 {
35188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35189 }
35190 return resultobj;
35191 fail:
35192 return NULL;
35193 }
35194
35195
35196 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35197 PyObject *resultobj;
35198 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35199 int arg2 ;
35200 wxString *arg3 = 0 ;
35201 bool temp3 = false ;
35202 PyObject * obj0 = 0 ;
35203 PyObject * obj1 = 0 ;
35204 PyObject * obj2 = 0 ;
35205 char *kwnames[] = {
35206 (char *) "self",(char *) "id",(char *) "label", NULL
35207 };
35208
35209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35211 if (SWIG_arg_fail(1)) SWIG_fail;
35212 {
35213 arg2 = (int)(SWIG_As_int(obj1));
35214 if (SWIG_arg_fail(2)) SWIG_fail;
35215 }
35216 {
35217 arg3 = wxString_in_helper(obj2);
35218 if (arg3 == NULL) SWIG_fail;
35219 temp3 = true;
35220 }
35221 {
35222 PyThreadState* __tstate = wxPyBeginAllowThreads();
35223 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35224
35225 wxPyEndAllowThreads(__tstate);
35226 if (PyErr_Occurred()) SWIG_fail;
35227 }
35228 Py_INCREF(Py_None); resultobj = Py_None;
35229 {
35230 if (temp3)
35231 delete arg3;
35232 }
35233 return resultobj;
35234 fail:
35235 {
35236 if (temp3)
35237 delete arg3;
35238 }
35239 return NULL;
35240 }
35241
35242
35243 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35244 PyObject *resultobj;
35245 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35246 int arg2 ;
35247 wxString result;
35248 PyObject * obj0 = 0 ;
35249 PyObject * obj1 = 0 ;
35250 char *kwnames[] = {
35251 (char *) "self",(char *) "id", NULL
35252 };
35253
35254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35256 if (SWIG_arg_fail(1)) SWIG_fail;
35257 {
35258 arg2 = (int)(SWIG_As_int(obj1));
35259 if (SWIG_arg_fail(2)) SWIG_fail;
35260 }
35261 {
35262 PyThreadState* __tstate = wxPyBeginAllowThreads();
35263 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35264
35265 wxPyEndAllowThreads(__tstate);
35266 if (PyErr_Occurred()) SWIG_fail;
35267 }
35268 {
35269 #if wxUSE_UNICODE
35270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35271 #else
35272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35273 #endif
35274 }
35275 return resultobj;
35276 fail:
35277 return NULL;
35278 }
35279
35280
35281 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35282 PyObject *resultobj;
35283 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35284 int arg2 ;
35285 wxString *arg3 = 0 ;
35286 bool temp3 = false ;
35287 PyObject * obj0 = 0 ;
35288 PyObject * obj1 = 0 ;
35289 PyObject * obj2 = 0 ;
35290 char *kwnames[] = {
35291 (char *) "self",(char *) "id",(char *) "helpString", NULL
35292 };
35293
35294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35296 if (SWIG_arg_fail(1)) SWIG_fail;
35297 {
35298 arg2 = (int)(SWIG_As_int(obj1));
35299 if (SWIG_arg_fail(2)) SWIG_fail;
35300 }
35301 {
35302 arg3 = wxString_in_helper(obj2);
35303 if (arg3 == NULL) SWIG_fail;
35304 temp3 = true;
35305 }
35306 {
35307 PyThreadState* __tstate = wxPyBeginAllowThreads();
35308 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35309
35310 wxPyEndAllowThreads(__tstate);
35311 if (PyErr_Occurred()) SWIG_fail;
35312 }
35313 Py_INCREF(Py_None); resultobj = Py_None;
35314 {
35315 if (temp3)
35316 delete arg3;
35317 }
35318 return resultobj;
35319 fail:
35320 {
35321 if (temp3)
35322 delete arg3;
35323 }
35324 return NULL;
35325 }
35326
35327
35328 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35329 PyObject *resultobj;
35330 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35331 int arg2 ;
35332 wxString result;
35333 PyObject * obj0 = 0 ;
35334 PyObject * obj1 = 0 ;
35335 char *kwnames[] = {
35336 (char *) "self",(char *) "id", NULL
35337 };
35338
35339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35341 if (SWIG_arg_fail(1)) SWIG_fail;
35342 {
35343 arg2 = (int)(SWIG_As_int(obj1));
35344 if (SWIG_arg_fail(2)) SWIG_fail;
35345 }
35346 {
35347 PyThreadState* __tstate = wxPyBeginAllowThreads();
35348 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35349
35350 wxPyEndAllowThreads(__tstate);
35351 if (PyErr_Occurred()) SWIG_fail;
35352 }
35353 {
35354 #if wxUSE_UNICODE
35355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35356 #else
35357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35358 #endif
35359 }
35360 return resultobj;
35361 fail:
35362 return NULL;
35363 }
35364
35365
35366 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35367 PyObject *resultobj;
35368 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35369 wxFrame *result;
35370 PyObject * obj0 = 0 ;
35371 char *kwnames[] = {
35372 (char *) "self", NULL
35373 };
35374
35375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35377 if (SWIG_arg_fail(1)) SWIG_fail;
35378 {
35379 PyThreadState* __tstate = wxPyBeginAllowThreads();
35380 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35381
35382 wxPyEndAllowThreads(__tstate);
35383 if (PyErr_Occurred()) SWIG_fail;
35384 }
35385 {
35386 resultobj = wxPyMake_wxObject(result, 0);
35387 }
35388 return resultobj;
35389 fail:
35390 return NULL;
35391 }
35392
35393
35394 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35395 PyObject *resultobj;
35396 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35397 bool result;
35398 PyObject * obj0 = 0 ;
35399 char *kwnames[] = {
35400 (char *) "self", NULL
35401 };
35402
35403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35405 if (SWIG_arg_fail(1)) SWIG_fail;
35406 {
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35409
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 {
35414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35415 }
35416 return resultobj;
35417 fail:
35418 return NULL;
35419 }
35420
35421
35422 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35423 PyObject *resultobj;
35424 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35425 wxFrame *arg2 = (wxFrame *) 0 ;
35426 PyObject * obj0 = 0 ;
35427 PyObject * obj1 = 0 ;
35428 char *kwnames[] = {
35429 (char *) "self",(char *) "frame", NULL
35430 };
35431
35432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35434 if (SWIG_arg_fail(1)) SWIG_fail;
35435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35436 if (SWIG_arg_fail(2)) SWIG_fail;
35437 {
35438 PyThreadState* __tstate = wxPyBeginAllowThreads();
35439 (arg1)->Attach(arg2);
35440
35441 wxPyEndAllowThreads(__tstate);
35442 if (PyErr_Occurred()) SWIG_fail;
35443 }
35444 Py_INCREF(Py_None); resultobj = Py_None;
35445 return resultobj;
35446 fail:
35447 return NULL;
35448 }
35449
35450
35451 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35452 PyObject *resultobj;
35453 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35454 PyObject * obj0 = 0 ;
35455 char *kwnames[] = {
35456 (char *) "self", NULL
35457 };
35458
35459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35461 if (SWIG_arg_fail(1)) SWIG_fail;
35462 {
35463 PyThreadState* __tstate = wxPyBeginAllowThreads();
35464 (arg1)->Detach();
35465
35466 wxPyEndAllowThreads(__tstate);
35467 if (PyErr_Occurred()) SWIG_fail;
35468 }
35469 Py_INCREF(Py_None); resultobj = Py_None;
35470 return resultobj;
35471 fail:
35472 return NULL;
35473 }
35474
35475
35476 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35477 PyObject *obj;
35478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35479 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35480 Py_INCREF(obj);
35481 return Py_BuildValue((char *)"");
35482 }
35483 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35484 PyObject *resultobj;
35485 wxMenu *arg1 = (wxMenu *) NULL ;
35486 int arg2 = (int) wxID_ANY ;
35487 wxString const &arg3_defvalue = wxPyEmptyString ;
35488 wxString *arg3 = (wxString *) &arg3_defvalue ;
35489 wxString const &arg4_defvalue = wxPyEmptyString ;
35490 wxString *arg4 = (wxString *) &arg4_defvalue ;
35491 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35492 wxMenu *arg6 = (wxMenu *) NULL ;
35493 wxMenuItem *result;
35494 bool temp3 = false ;
35495 bool temp4 = false ;
35496 PyObject * obj0 = 0 ;
35497 PyObject * obj1 = 0 ;
35498 PyObject * obj2 = 0 ;
35499 PyObject * obj3 = 0 ;
35500 PyObject * obj4 = 0 ;
35501 PyObject * obj5 = 0 ;
35502 char *kwnames[] = {
35503 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35504 };
35505
35506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35507 if (obj0) {
35508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35509 if (SWIG_arg_fail(1)) SWIG_fail;
35510 }
35511 if (obj1) {
35512 {
35513 arg2 = (int)(SWIG_As_int(obj1));
35514 if (SWIG_arg_fail(2)) SWIG_fail;
35515 }
35516 }
35517 if (obj2) {
35518 {
35519 arg3 = wxString_in_helper(obj2);
35520 if (arg3 == NULL) SWIG_fail;
35521 temp3 = true;
35522 }
35523 }
35524 if (obj3) {
35525 {
35526 arg4 = wxString_in_helper(obj3);
35527 if (arg4 == NULL) SWIG_fail;
35528 temp4 = true;
35529 }
35530 }
35531 if (obj4) {
35532 {
35533 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35534 if (SWIG_arg_fail(5)) SWIG_fail;
35535 }
35536 }
35537 if (obj5) {
35538 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35539 if (SWIG_arg_fail(6)) SWIG_fail;
35540 }
35541 {
35542 PyThreadState* __tstate = wxPyBeginAllowThreads();
35543 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35544
35545 wxPyEndAllowThreads(__tstate);
35546 if (PyErr_Occurred()) SWIG_fail;
35547 }
35548 {
35549 resultobj = wxPyMake_wxObject(result, 1);
35550 }
35551 {
35552 if (temp3)
35553 delete arg3;
35554 }
35555 {
35556 if (temp4)
35557 delete arg4;
35558 }
35559 return resultobj;
35560 fail:
35561 {
35562 if (temp3)
35563 delete arg3;
35564 }
35565 {
35566 if (temp4)
35567 delete arg4;
35568 }
35569 return NULL;
35570 }
35571
35572
35573 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35574 PyObject *resultobj;
35575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35576 wxMenu *result;
35577 PyObject * obj0 = 0 ;
35578 char *kwnames[] = {
35579 (char *) "self", NULL
35580 };
35581
35582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35584 if (SWIG_arg_fail(1)) SWIG_fail;
35585 {
35586 PyThreadState* __tstate = wxPyBeginAllowThreads();
35587 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35588
35589 wxPyEndAllowThreads(__tstate);
35590 if (PyErr_Occurred()) SWIG_fail;
35591 }
35592 {
35593 resultobj = wxPyMake_wxObject(result, 0);
35594 }
35595 return resultobj;
35596 fail:
35597 return NULL;
35598 }
35599
35600
35601 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35602 PyObject *resultobj;
35603 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35604 wxMenu *arg2 = (wxMenu *) 0 ;
35605 PyObject * obj0 = 0 ;
35606 PyObject * obj1 = 0 ;
35607 char *kwnames[] = {
35608 (char *) "self",(char *) "menu", NULL
35609 };
35610
35611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35613 if (SWIG_arg_fail(1)) SWIG_fail;
35614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35615 if (SWIG_arg_fail(2)) SWIG_fail;
35616 {
35617 PyThreadState* __tstate = wxPyBeginAllowThreads();
35618 (arg1)->SetMenu(arg2);
35619
35620 wxPyEndAllowThreads(__tstate);
35621 if (PyErr_Occurred()) SWIG_fail;
35622 }
35623 Py_INCREF(Py_None); resultobj = Py_None;
35624 return resultobj;
35625 fail:
35626 return NULL;
35627 }
35628
35629
35630 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35631 PyObject *resultobj;
35632 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35633 int arg2 ;
35634 PyObject * obj0 = 0 ;
35635 PyObject * obj1 = 0 ;
35636 char *kwnames[] = {
35637 (char *) "self",(char *) "id", NULL
35638 };
35639
35640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35642 if (SWIG_arg_fail(1)) SWIG_fail;
35643 {
35644 arg2 = (int)(SWIG_As_int(obj1));
35645 if (SWIG_arg_fail(2)) SWIG_fail;
35646 }
35647 {
35648 PyThreadState* __tstate = wxPyBeginAllowThreads();
35649 (arg1)->SetId(arg2);
35650
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 Py_INCREF(Py_None); resultobj = Py_None;
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35662 PyObject *resultobj;
35663 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35664 int result;
35665 PyObject * obj0 = 0 ;
35666 char *kwnames[] = {
35667 (char *) "self", NULL
35668 };
35669
35670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35672 if (SWIG_arg_fail(1)) SWIG_fail;
35673 {
35674 PyThreadState* __tstate = wxPyBeginAllowThreads();
35675 result = (int)((wxMenuItem const *)arg1)->GetId();
35676
35677 wxPyEndAllowThreads(__tstate);
35678 if (PyErr_Occurred()) SWIG_fail;
35679 }
35680 {
35681 resultobj = SWIG_From_int((int)(result));
35682 }
35683 return resultobj;
35684 fail:
35685 return NULL;
35686 }
35687
35688
35689 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35690 PyObject *resultobj;
35691 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35692 bool result;
35693 PyObject * obj0 = 0 ;
35694 char *kwnames[] = {
35695 (char *) "self", NULL
35696 };
35697
35698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35700 if (SWIG_arg_fail(1)) SWIG_fail;
35701 {
35702 PyThreadState* __tstate = wxPyBeginAllowThreads();
35703 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35704
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 {
35709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35710 }
35711 return resultobj;
35712 fail:
35713 return NULL;
35714 }
35715
35716
35717 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35718 PyObject *resultobj;
35719 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35720 wxString *arg2 = 0 ;
35721 bool temp2 = false ;
35722 PyObject * obj0 = 0 ;
35723 PyObject * obj1 = 0 ;
35724 char *kwnames[] = {
35725 (char *) "self",(char *) "str", NULL
35726 };
35727
35728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35730 if (SWIG_arg_fail(1)) SWIG_fail;
35731 {
35732 arg2 = wxString_in_helper(obj1);
35733 if (arg2 == NULL) SWIG_fail;
35734 temp2 = true;
35735 }
35736 {
35737 PyThreadState* __tstate = wxPyBeginAllowThreads();
35738 (arg1)->SetText((wxString const &)*arg2);
35739
35740 wxPyEndAllowThreads(__tstate);
35741 if (PyErr_Occurred()) SWIG_fail;
35742 }
35743 Py_INCREF(Py_None); resultobj = Py_None;
35744 {
35745 if (temp2)
35746 delete arg2;
35747 }
35748 return resultobj;
35749 fail:
35750 {
35751 if (temp2)
35752 delete arg2;
35753 }
35754 return NULL;
35755 }
35756
35757
35758 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35759 PyObject *resultobj;
35760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35761 wxString result;
35762 PyObject * obj0 = 0 ;
35763 char *kwnames[] = {
35764 (char *) "self", NULL
35765 };
35766
35767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35769 if (SWIG_arg_fail(1)) SWIG_fail;
35770 {
35771 PyThreadState* __tstate = wxPyBeginAllowThreads();
35772 result = ((wxMenuItem const *)arg1)->GetLabel();
35773
35774 wxPyEndAllowThreads(__tstate);
35775 if (PyErr_Occurred()) SWIG_fail;
35776 }
35777 {
35778 #if wxUSE_UNICODE
35779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35780 #else
35781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35782 #endif
35783 }
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35791 PyObject *resultobj;
35792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35793 wxString *result;
35794 PyObject * obj0 = 0 ;
35795 char *kwnames[] = {
35796 (char *) "self", NULL
35797 };
35798
35799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35801 if (SWIG_arg_fail(1)) SWIG_fail;
35802 {
35803 PyThreadState* __tstate = wxPyBeginAllowThreads();
35804 {
35805 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35806 result = (wxString *) &_result_ref;
35807 }
35808
35809 wxPyEndAllowThreads(__tstate);
35810 if (PyErr_Occurred()) SWIG_fail;
35811 }
35812 {
35813 #if wxUSE_UNICODE
35814 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35815 #else
35816 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35817 #endif
35818 }
35819 return resultobj;
35820 fail:
35821 return NULL;
35822 }
35823
35824
35825 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35826 PyObject *resultobj;
35827 wxString *arg1 = 0 ;
35828 wxString result;
35829 bool temp1 = false ;
35830 PyObject * obj0 = 0 ;
35831 char *kwnames[] = {
35832 (char *) "text", NULL
35833 };
35834
35835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35836 {
35837 arg1 = wxString_in_helper(obj0);
35838 if (arg1 == NULL) SWIG_fail;
35839 temp1 = true;
35840 }
35841 {
35842 PyThreadState* __tstate = wxPyBeginAllowThreads();
35843 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35844
35845 wxPyEndAllowThreads(__tstate);
35846 if (PyErr_Occurred()) SWIG_fail;
35847 }
35848 {
35849 #if wxUSE_UNICODE
35850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35851 #else
35852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35853 #endif
35854 }
35855 {
35856 if (temp1)
35857 delete arg1;
35858 }
35859 return resultobj;
35860 fail:
35861 {
35862 if (temp1)
35863 delete arg1;
35864 }
35865 return NULL;
35866 }
35867
35868
35869 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35870 PyObject *resultobj;
35871 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35872 wxItemKind result;
35873 PyObject * obj0 = 0 ;
35874 char *kwnames[] = {
35875 (char *) "self", NULL
35876 };
35877
35878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35880 if (SWIG_arg_fail(1)) SWIG_fail;
35881 {
35882 PyThreadState* __tstate = wxPyBeginAllowThreads();
35883 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35884
35885 wxPyEndAllowThreads(__tstate);
35886 if (PyErr_Occurred()) SWIG_fail;
35887 }
35888 resultobj = SWIG_From_int((result));
35889 return resultobj;
35890 fail:
35891 return NULL;
35892 }
35893
35894
35895 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35896 PyObject *resultobj;
35897 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35898 wxItemKind arg2 ;
35899 PyObject * obj0 = 0 ;
35900 PyObject * obj1 = 0 ;
35901 char *kwnames[] = {
35902 (char *) "self",(char *) "kind", NULL
35903 };
35904
35905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35907 if (SWIG_arg_fail(1)) SWIG_fail;
35908 {
35909 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35910 if (SWIG_arg_fail(2)) SWIG_fail;
35911 }
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 (arg1)->SetKind((wxItemKind )arg2);
35915
35916 wxPyEndAllowThreads(__tstate);
35917 if (PyErr_Occurred()) SWIG_fail;
35918 }
35919 Py_INCREF(Py_None); resultobj = Py_None;
35920 return resultobj;
35921 fail:
35922 return NULL;
35923 }
35924
35925
35926 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35927 PyObject *resultobj;
35928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35929 bool arg2 ;
35930 PyObject * obj0 = 0 ;
35931 PyObject * obj1 = 0 ;
35932 char *kwnames[] = {
35933 (char *) "self",(char *) "checkable", NULL
35934 };
35935
35936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35938 if (SWIG_arg_fail(1)) SWIG_fail;
35939 {
35940 arg2 = (bool)(SWIG_As_bool(obj1));
35941 if (SWIG_arg_fail(2)) SWIG_fail;
35942 }
35943 {
35944 PyThreadState* __tstate = wxPyBeginAllowThreads();
35945 (arg1)->SetCheckable(arg2);
35946
35947 wxPyEndAllowThreads(__tstate);
35948 if (PyErr_Occurred()) SWIG_fail;
35949 }
35950 Py_INCREF(Py_None); resultobj = Py_None;
35951 return resultobj;
35952 fail:
35953 return NULL;
35954 }
35955
35956
35957 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35958 PyObject *resultobj;
35959 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35960 bool result;
35961 PyObject * obj0 = 0 ;
35962 char *kwnames[] = {
35963 (char *) "self", NULL
35964 };
35965
35966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35968 if (SWIG_arg_fail(1)) SWIG_fail;
35969 {
35970 PyThreadState* __tstate = wxPyBeginAllowThreads();
35971 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35972
35973 wxPyEndAllowThreads(__tstate);
35974 if (PyErr_Occurred()) SWIG_fail;
35975 }
35976 {
35977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35978 }
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35986 PyObject *resultobj;
35987 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35988 bool result;
35989 PyObject * obj0 = 0 ;
35990 char *kwnames[] = {
35991 (char *) "self", NULL
35992 };
35993
35994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35996 if (SWIG_arg_fail(1)) SWIG_fail;
35997 {
35998 PyThreadState* __tstate = wxPyBeginAllowThreads();
35999 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36000
36001 wxPyEndAllowThreads(__tstate);
36002 if (PyErr_Occurred()) SWIG_fail;
36003 }
36004 {
36005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36006 }
36007 return resultobj;
36008 fail:
36009 return NULL;
36010 }
36011
36012
36013 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36014 PyObject *resultobj;
36015 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36016 wxMenu *arg2 = (wxMenu *) 0 ;
36017 PyObject * obj0 = 0 ;
36018 PyObject * obj1 = 0 ;
36019 char *kwnames[] = {
36020 (char *) "self",(char *) "menu", NULL
36021 };
36022
36023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36025 if (SWIG_arg_fail(1)) SWIG_fail;
36026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36027 if (SWIG_arg_fail(2)) SWIG_fail;
36028 {
36029 PyThreadState* __tstate = wxPyBeginAllowThreads();
36030 (arg1)->SetSubMenu(arg2);
36031
36032 wxPyEndAllowThreads(__tstate);
36033 if (PyErr_Occurred()) SWIG_fail;
36034 }
36035 Py_INCREF(Py_None); resultobj = Py_None;
36036 return resultobj;
36037 fail:
36038 return NULL;
36039 }
36040
36041
36042 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36043 PyObject *resultobj;
36044 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36045 wxMenu *result;
36046 PyObject * obj0 = 0 ;
36047 char *kwnames[] = {
36048 (char *) "self", NULL
36049 };
36050
36051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36053 if (SWIG_arg_fail(1)) SWIG_fail;
36054 {
36055 PyThreadState* __tstate = wxPyBeginAllowThreads();
36056 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36057
36058 wxPyEndAllowThreads(__tstate);
36059 if (PyErr_Occurred()) SWIG_fail;
36060 }
36061 {
36062 resultobj = wxPyMake_wxObject(result, 0);
36063 }
36064 return resultobj;
36065 fail:
36066 return NULL;
36067 }
36068
36069
36070 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36071 PyObject *resultobj;
36072 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36073 bool arg2 = (bool) true ;
36074 PyObject * obj0 = 0 ;
36075 PyObject * obj1 = 0 ;
36076 char *kwnames[] = {
36077 (char *) "self",(char *) "enable", NULL
36078 };
36079
36080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36082 if (SWIG_arg_fail(1)) SWIG_fail;
36083 if (obj1) {
36084 {
36085 arg2 = (bool)(SWIG_As_bool(obj1));
36086 if (SWIG_arg_fail(2)) SWIG_fail;
36087 }
36088 }
36089 {
36090 PyThreadState* __tstate = wxPyBeginAllowThreads();
36091 (arg1)->Enable(arg2);
36092
36093 wxPyEndAllowThreads(__tstate);
36094 if (PyErr_Occurred()) SWIG_fail;
36095 }
36096 Py_INCREF(Py_None); resultobj = Py_None;
36097 return resultobj;
36098 fail:
36099 return NULL;
36100 }
36101
36102
36103 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36104 PyObject *resultobj;
36105 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36106 bool result;
36107 PyObject * obj0 = 0 ;
36108 char *kwnames[] = {
36109 (char *) "self", NULL
36110 };
36111
36112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36114 if (SWIG_arg_fail(1)) SWIG_fail;
36115 {
36116 PyThreadState* __tstate = wxPyBeginAllowThreads();
36117 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36118
36119 wxPyEndAllowThreads(__tstate);
36120 if (PyErr_Occurred()) SWIG_fail;
36121 }
36122 {
36123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36124 }
36125 return resultobj;
36126 fail:
36127 return NULL;
36128 }
36129
36130
36131 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36132 PyObject *resultobj;
36133 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36134 bool arg2 = (bool) true ;
36135 PyObject * obj0 = 0 ;
36136 PyObject * obj1 = 0 ;
36137 char *kwnames[] = {
36138 (char *) "self",(char *) "check", NULL
36139 };
36140
36141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36143 if (SWIG_arg_fail(1)) SWIG_fail;
36144 if (obj1) {
36145 {
36146 arg2 = (bool)(SWIG_As_bool(obj1));
36147 if (SWIG_arg_fail(2)) SWIG_fail;
36148 }
36149 }
36150 {
36151 PyThreadState* __tstate = wxPyBeginAllowThreads();
36152 (arg1)->Check(arg2);
36153
36154 wxPyEndAllowThreads(__tstate);
36155 if (PyErr_Occurred()) SWIG_fail;
36156 }
36157 Py_INCREF(Py_None); resultobj = Py_None;
36158 return resultobj;
36159 fail:
36160 return NULL;
36161 }
36162
36163
36164 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36165 PyObject *resultobj;
36166 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36167 bool result;
36168 PyObject * obj0 = 0 ;
36169 char *kwnames[] = {
36170 (char *) "self", NULL
36171 };
36172
36173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36175 if (SWIG_arg_fail(1)) SWIG_fail;
36176 {
36177 PyThreadState* __tstate = wxPyBeginAllowThreads();
36178 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36179
36180 wxPyEndAllowThreads(__tstate);
36181 if (PyErr_Occurred()) SWIG_fail;
36182 }
36183 {
36184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36185 }
36186 return resultobj;
36187 fail:
36188 return NULL;
36189 }
36190
36191
36192 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36193 PyObject *resultobj;
36194 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36195 PyObject * obj0 = 0 ;
36196 char *kwnames[] = {
36197 (char *) "self", NULL
36198 };
36199
36200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36202 if (SWIG_arg_fail(1)) SWIG_fail;
36203 {
36204 PyThreadState* __tstate = wxPyBeginAllowThreads();
36205 (arg1)->Toggle();
36206
36207 wxPyEndAllowThreads(__tstate);
36208 if (PyErr_Occurred()) SWIG_fail;
36209 }
36210 Py_INCREF(Py_None); resultobj = Py_None;
36211 return resultobj;
36212 fail:
36213 return NULL;
36214 }
36215
36216
36217 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36218 PyObject *resultobj;
36219 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36220 wxString *arg2 = 0 ;
36221 bool temp2 = false ;
36222 PyObject * obj0 = 0 ;
36223 PyObject * obj1 = 0 ;
36224 char *kwnames[] = {
36225 (char *) "self",(char *) "str", NULL
36226 };
36227
36228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36230 if (SWIG_arg_fail(1)) SWIG_fail;
36231 {
36232 arg2 = wxString_in_helper(obj1);
36233 if (arg2 == NULL) SWIG_fail;
36234 temp2 = true;
36235 }
36236 {
36237 PyThreadState* __tstate = wxPyBeginAllowThreads();
36238 (arg1)->SetHelp((wxString const &)*arg2);
36239
36240 wxPyEndAllowThreads(__tstate);
36241 if (PyErr_Occurred()) SWIG_fail;
36242 }
36243 Py_INCREF(Py_None); resultobj = Py_None;
36244 {
36245 if (temp2)
36246 delete arg2;
36247 }
36248 return resultobj;
36249 fail:
36250 {
36251 if (temp2)
36252 delete arg2;
36253 }
36254 return NULL;
36255 }
36256
36257
36258 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36259 PyObject *resultobj;
36260 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36261 wxString *result;
36262 PyObject * obj0 = 0 ;
36263 char *kwnames[] = {
36264 (char *) "self", NULL
36265 };
36266
36267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36269 if (SWIG_arg_fail(1)) SWIG_fail;
36270 {
36271 PyThreadState* __tstate = wxPyBeginAllowThreads();
36272 {
36273 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36274 result = (wxString *) &_result_ref;
36275 }
36276
36277 wxPyEndAllowThreads(__tstate);
36278 if (PyErr_Occurred()) SWIG_fail;
36279 }
36280 {
36281 #if wxUSE_UNICODE
36282 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36283 #else
36284 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36285 #endif
36286 }
36287 return resultobj;
36288 fail:
36289 return NULL;
36290 }
36291
36292
36293 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36294 PyObject *resultobj;
36295 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36296 wxAcceleratorEntry *result;
36297 PyObject * obj0 = 0 ;
36298 char *kwnames[] = {
36299 (char *) "self", NULL
36300 };
36301
36302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36304 if (SWIG_arg_fail(1)) SWIG_fail;
36305 {
36306 PyThreadState* __tstate = wxPyBeginAllowThreads();
36307 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36308
36309 wxPyEndAllowThreads(__tstate);
36310 if (PyErr_Occurred()) SWIG_fail;
36311 }
36312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36313 return resultobj;
36314 fail:
36315 return NULL;
36316 }
36317
36318
36319 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36320 PyObject *resultobj;
36321 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36322 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36323 PyObject * obj0 = 0 ;
36324 PyObject * obj1 = 0 ;
36325 char *kwnames[] = {
36326 (char *) "self",(char *) "accel", NULL
36327 };
36328
36329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36331 if (SWIG_arg_fail(1)) SWIG_fail;
36332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36333 if (SWIG_arg_fail(2)) SWIG_fail;
36334 {
36335 PyThreadState* __tstate = wxPyBeginAllowThreads();
36336 (arg1)->SetAccel(arg2);
36337
36338 wxPyEndAllowThreads(__tstate);
36339 if (PyErr_Occurred()) SWIG_fail;
36340 }
36341 Py_INCREF(Py_None); resultobj = Py_None;
36342 return resultobj;
36343 fail:
36344 return NULL;
36345 }
36346
36347
36348 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36349 PyObject *resultobj;
36350 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36351 wxFont *arg2 = 0 ;
36352 PyObject * obj0 = 0 ;
36353 PyObject * obj1 = 0 ;
36354 char *kwnames[] = {
36355 (char *) "self",(char *) "font", NULL
36356 };
36357
36358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36360 if (SWIG_arg_fail(1)) SWIG_fail;
36361 {
36362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36363 if (SWIG_arg_fail(2)) SWIG_fail;
36364 if (arg2 == NULL) {
36365 SWIG_null_ref("wxFont");
36366 }
36367 if (SWIG_arg_fail(2)) SWIG_fail;
36368 }
36369 {
36370 PyThreadState* __tstate = wxPyBeginAllowThreads();
36371 (arg1)->SetFont((wxFont const &)*arg2);
36372
36373 wxPyEndAllowThreads(__tstate);
36374 if (PyErr_Occurred()) SWIG_fail;
36375 }
36376 Py_INCREF(Py_None); resultobj = Py_None;
36377 return resultobj;
36378 fail:
36379 return NULL;
36380 }
36381
36382
36383 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36384 PyObject *resultobj;
36385 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36386 wxFont result;
36387 PyObject * obj0 = 0 ;
36388 char *kwnames[] = {
36389 (char *) "self", NULL
36390 };
36391
36392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36394 if (SWIG_arg_fail(1)) SWIG_fail;
36395 {
36396 PyThreadState* __tstate = wxPyBeginAllowThreads();
36397 result = (arg1)->GetFont();
36398
36399 wxPyEndAllowThreads(__tstate);
36400 if (PyErr_Occurred()) SWIG_fail;
36401 }
36402 {
36403 wxFont * resultptr;
36404 resultptr = new wxFont((wxFont &)(result));
36405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36406 }
36407 return resultobj;
36408 fail:
36409 return NULL;
36410 }
36411
36412
36413 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36414 PyObject *resultobj;
36415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36416 wxColour *arg2 = 0 ;
36417 wxColour temp2 ;
36418 PyObject * obj0 = 0 ;
36419 PyObject * obj1 = 0 ;
36420 char *kwnames[] = {
36421 (char *) "self",(char *) "colText", NULL
36422 };
36423
36424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36426 if (SWIG_arg_fail(1)) SWIG_fail;
36427 {
36428 arg2 = &temp2;
36429 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36430 }
36431 {
36432 PyThreadState* __tstate = wxPyBeginAllowThreads();
36433 (arg1)->SetTextColour((wxColour const &)*arg2);
36434
36435 wxPyEndAllowThreads(__tstate);
36436 if (PyErr_Occurred()) SWIG_fail;
36437 }
36438 Py_INCREF(Py_None); resultobj = Py_None;
36439 return resultobj;
36440 fail:
36441 return NULL;
36442 }
36443
36444
36445 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36446 PyObject *resultobj;
36447 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36448 wxColour result;
36449 PyObject * obj0 = 0 ;
36450 char *kwnames[] = {
36451 (char *) "self", NULL
36452 };
36453
36454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36456 if (SWIG_arg_fail(1)) SWIG_fail;
36457 {
36458 PyThreadState* __tstate = wxPyBeginAllowThreads();
36459 result = (arg1)->GetTextColour();
36460
36461 wxPyEndAllowThreads(__tstate);
36462 if (PyErr_Occurred()) SWIG_fail;
36463 }
36464 {
36465 wxColour * resultptr;
36466 resultptr = new wxColour((wxColour &)(result));
36467 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36468 }
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36476 PyObject *resultobj;
36477 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36478 wxColour *arg2 = 0 ;
36479 wxColour temp2 ;
36480 PyObject * obj0 = 0 ;
36481 PyObject * obj1 = 0 ;
36482 char *kwnames[] = {
36483 (char *) "self",(char *) "colBack", NULL
36484 };
36485
36486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36488 if (SWIG_arg_fail(1)) SWIG_fail;
36489 {
36490 arg2 = &temp2;
36491 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36492 }
36493 {
36494 PyThreadState* __tstate = wxPyBeginAllowThreads();
36495 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36496
36497 wxPyEndAllowThreads(__tstate);
36498 if (PyErr_Occurred()) SWIG_fail;
36499 }
36500 Py_INCREF(Py_None); resultobj = Py_None;
36501 return resultobj;
36502 fail:
36503 return NULL;
36504 }
36505
36506
36507 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36508 PyObject *resultobj;
36509 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36510 wxColour result;
36511 PyObject * obj0 = 0 ;
36512 char *kwnames[] = {
36513 (char *) "self", NULL
36514 };
36515
36516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36518 if (SWIG_arg_fail(1)) SWIG_fail;
36519 {
36520 PyThreadState* __tstate = wxPyBeginAllowThreads();
36521 result = (arg1)->GetBackgroundColour();
36522
36523 wxPyEndAllowThreads(__tstate);
36524 if (PyErr_Occurred()) SWIG_fail;
36525 }
36526 {
36527 wxColour * resultptr;
36528 resultptr = new wxColour((wxColour &)(result));
36529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36530 }
36531 return resultobj;
36532 fail:
36533 return NULL;
36534 }
36535
36536
36537 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36538 PyObject *resultobj;
36539 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36540 wxBitmap *arg2 = 0 ;
36541 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36542 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36543 PyObject * obj0 = 0 ;
36544 PyObject * obj1 = 0 ;
36545 PyObject * obj2 = 0 ;
36546 char *kwnames[] = {
36547 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36548 };
36549
36550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36552 if (SWIG_arg_fail(1)) SWIG_fail;
36553 {
36554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36555 if (SWIG_arg_fail(2)) SWIG_fail;
36556 if (arg2 == NULL) {
36557 SWIG_null_ref("wxBitmap");
36558 }
36559 if (SWIG_arg_fail(2)) SWIG_fail;
36560 }
36561 if (obj2) {
36562 {
36563 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36564 if (SWIG_arg_fail(3)) SWIG_fail;
36565 if (arg3 == NULL) {
36566 SWIG_null_ref("wxBitmap");
36567 }
36568 if (SWIG_arg_fail(3)) SWIG_fail;
36569 }
36570 }
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36574
36575 wxPyEndAllowThreads(__tstate);
36576 if (PyErr_Occurred()) SWIG_fail;
36577 }
36578 Py_INCREF(Py_None); resultobj = Py_None;
36579 return resultobj;
36580 fail:
36581 return NULL;
36582 }
36583
36584
36585 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36586 PyObject *resultobj;
36587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36588 wxBitmap *arg2 = 0 ;
36589 PyObject * obj0 = 0 ;
36590 PyObject * obj1 = 0 ;
36591 char *kwnames[] = {
36592 (char *) "self",(char *) "bmpDisabled", NULL
36593 };
36594
36595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36597 if (SWIG_arg_fail(1)) SWIG_fail;
36598 {
36599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36600 if (SWIG_arg_fail(2)) SWIG_fail;
36601 if (arg2 == NULL) {
36602 SWIG_null_ref("wxBitmap");
36603 }
36604 if (SWIG_arg_fail(2)) SWIG_fail;
36605 }
36606 {
36607 PyThreadState* __tstate = wxPyBeginAllowThreads();
36608 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36609
36610 wxPyEndAllowThreads(__tstate);
36611 if (PyErr_Occurred()) SWIG_fail;
36612 }
36613 Py_INCREF(Py_None); resultobj = Py_None;
36614 return resultobj;
36615 fail:
36616 return NULL;
36617 }
36618
36619
36620 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36621 PyObject *resultobj;
36622 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36623 wxBitmap *result;
36624 PyObject * obj0 = 0 ;
36625 char *kwnames[] = {
36626 (char *) "self", NULL
36627 };
36628
36629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36631 if (SWIG_arg_fail(1)) SWIG_fail;
36632 {
36633 PyThreadState* __tstate = wxPyBeginAllowThreads();
36634 {
36635 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36636 result = (wxBitmap *) &_result_ref;
36637 }
36638
36639 wxPyEndAllowThreads(__tstate);
36640 if (PyErr_Occurred()) SWIG_fail;
36641 }
36642 {
36643 wxBitmap* resultptr = new wxBitmap(*result);
36644 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36645 }
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36653 PyObject *resultobj;
36654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36655 int arg2 ;
36656 PyObject * obj0 = 0 ;
36657 PyObject * obj1 = 0 ;
36658 char *kwnames[] = {
36659 (char *) "self",(char *) "nWidth", NULL
36660 };
36661
36662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36664 if (SWIG_arg_fail(1)) SWIG_fail;
36665 {
36666 arg2 = (int)(SWIG_As_int(obj1));
36667 if (SWIG_arg_fail(2)) SWIG_fail;
36668 }
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 (arg1)->SetMarginWidth(arg2);
36672
36673 wxPyEndAllowThreads(__tstate);
36674 if (PyErr_Occurred()) SWIG_fail;
36675 }
36676 Py_INCREF(Py_None); resultobj = Py_None;
36677 return resultobj;
36678 fail:
36679 return NULL;
36680 }
36681
36682
36683 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36684 PyObject *resultobj;
36685 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36686 int result;
36687 PyObject * obj0 = 0 ;
36688 char *kwnames[] = {
36689 (char *) "self", NULL
36690 };
36691
36692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36694 if (SWIG_arg_fail(1)) SWIG_fail;
36695 {
36696 PyThreadState* __tstate = wxPyBeginAllowThreads();
36697 result = (int)(arg1)->GetMarginWidth();
36698
36699 wxPyEndAllowThreads(__tstate);
36700 if (PyErr_Occurred()) SWIG_fail;
36701 }
36702 {
36703 resultobj = SWIG_From_int((int)(result));
36704 }
36705 return resultobj;
36706 fail:
36707 return NULL;
36708 }
36709
36710
36711 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36712 PyObject *resultobj;
36713 int result;
36714 char *kwnames[] = {
36715 NULL
36716 };
36717
36718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 result = (int)wxMenuItem::GetDefaultMarginWidth();
36722
36723 wxPyEndAllowThreads(__tstate);
36724 if (PyErr_Occurred()) SWIG_fail;
36725 }
36726 {
36727 resultobj = SWIG_From_int((int)(result));
36728 }
36729 return resultobj;
36730 fail:
36731 return NULL;
36732 }
36733
36734
36735 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36736 PyObject *resultobj;
36737 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36738 bool result;
36739 PyObject * obj0 = 0 ;
36740 char *kwnames[] = {
36741 (char *) "self", NULL
36742 };
36743
36744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36746 if (SWIG_arg_fail(1)) SWIG_fail;
36747 {
36748 PyThreadState* __tstate = wxPyBeginAllowThreads();
36749 result = (bool)(arg1)->IsOwnerDrawn();
36750
36751 wxPyEndAllowThreads(__tstate);
36752 if (PyErr_Occurred()) SWIG_fail;
36753 }
36754 {
36755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36756 }
36757 return resultobj;
36758 fail:
36759 return NULL;
36760 }
36761
36762
36763 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36764 PyObject *resultobj;
36765 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36766 bool arg2 = (bool) true ;
36767 PyObject * obj0 = 0 ;
36768 PyObject * obj1 = 0 ;
36769 char *kwnames[] = {
36770 (char *) "self",(char *) "ownerDrawn", NULL
36771 };
36772
36773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36775 if (SWIG_arg_fail(1)) SWIG_fail;
36776 if (obj1) {
36777 {
36778 arg2 = (bool)(SWIG_As_bool(obj1));
36779 if (SWIG_arg_fail(2)) SWIG_fail;
36780 }
36781 }
36782 {
36783 PyThreadState* __tstate = wxPyBeginAllowThreads();
36784 (arg1)->SetOwnerDrawn(arg2);
36785
36786 wxPyEndAllowThreads(__tstate);
36787 if (PyErr_Occurred()) SWIG_fail;
36788 }
36789 Py_INCREF(Py_None); resultobj = Py_None;
36790 return resultobj;
36791 fail:
36792 return NULL;
36793 }
36794
36795
36796 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36797 PyObject *resultobj;
36798 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36799 PyObject * obj0 = 0 ;
36800 char *kwnames[] = {
36801 (char *) "self", NULL
36802 };
36803
36804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36806 if (SWIG_arg_fail(1)) SWIG_fail;
36807 {
36808 PyThreadState* __tstate = wxPyBeginAllowThreads();
36809 (arg1)->ResetOwnerDrawn();
36810
36811 wxPyEndAllowThreads(__tstate);
36812 if (PyErr_Occurred()) SWIG_fail;
36813 }
36814 Py_INCREF(Py_None); resultobj = Py_None;
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36822 PyObject *resultobj;
36823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36824 wxBitmap *arg2 = 0 ;
36825 PyObject * obj0 = 0 ;
36826 PyObject * obj1 = 0 ;
36827 char *kwnames[] = {
36828 (char *) "self",(char *) "bitmap", NULL
36829 };
36830
36831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36833 if (SWIG_arg_fail(1)) SWIG_fail;
36834 {
36835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36836 if (SWIG_arg_fail(2)) SWIG_fail;
36837 if (arg2 == NULL) {
36838 SWIG_null_ref("wxBitmap");
36839 }
36840 if (SWIG_arg_fail(2)) SWIG_fail;
36841 }
36842 {
36843 PyThreadState* __tstate = wxPyBeginAllowThreads();
36844 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36845
36846 wxPyEndAllowThreads(__tstate);
36847 if (PyErr_Occurred()) SWIG_fail;
36848 }
36849 Py_INCREF(Py_None); resultobj = Py_None;
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36857 PyObject *resultobj;
36858 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36859 wxBitmap *result;
36860 PyObject * obj0 = 0 ;
36861 char *kwnames[] = {
36862 (char *) "self", NULL
36863 };
36864
36865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36867 if (SWIG_arg_fail(1)) SWIG_fail;
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 {
36871 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36872 result = (wxBitmap *) &_result_ref;
36873 }
36874
36875 wxPyEndAllowThreads(__tstate);
36876 if (PyErr_Occurred()) SWIG_fail;
36877 }
36878 {
36879 wxBitmap* resultptr = new wxBitmap(*result);
36880 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36881 }
36882 return resultobj;
36883 fail:
36884 return NULL;
36885 }
36886
36887
36888 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36889 PyObject *obj;
36890 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36891 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36892 Py_INCREF(obj);
36893 return Py_BuildValue((char *)"");
36894 }
36895 static int _wrap_ControlNameStr_set(PyObject *) {
36896 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36897 return 1;
36898 }
36899
36900
36901 static PyObject *_wrap_ControlNameStr_get(void) {
36902 PyObject *pyobj;
36903
36904 {
36905 #if wxUSE_UNICODE
36906 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36907 #else
36908 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36909 #endif
36910 }
36911 return pyobj;
36912 }
36913
36914
36915 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36916 PyObject *resultobj;
36917 wxWindow *arg1 = (wxWindow *) 0 ;
36918 int arg2 = (int) -1 ;
36919 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36920 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36921 wxSize const &arg4_defvalue = wxDefaultSize ;
36922 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36923 long arg5 = (long) 0 ;
36924 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36925 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36926 wxString const &arg7_defvalue = wxPyControlNameStr ;
36927 wxString *arg7 = (wxString *) &arg7_defvalue ;
36928 wxControl *result;
36929 wxPoint temp3 ;
36930 wxSize temp4 ;
36931 bool temp7 = false ;
36932 PyObject * obj0 = 0 ;
36933 PyObject * obj1 = 0 ;
36934 PyObject * obj2 = 0 ;
36935 PyObject * obj3 = 0 ;
36936 PyObject * obj4 = 0 ;
36937 PyObject * obj5 = 0 ;
36938 PyObject * obj6 = 0 ;
36939 char *kwnames[] = {
36940 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36941 };
36942
36943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36945 if (SWIG_arg_fail(1)) SWIG_fail;
36946 if (obj1) {
36947 {
36948 arg2 = (int)(SWIG_As_int(obj1));
36949 if (SWIG_arg_fail(2)) SWIG_fail;
36950 }
36951 }
36952 if (obj2) {
36953 {
36954 arg3 = &temp3;
36955 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36956 }
36957 }
36958 if (obj3) {
36959 {
36960 arg4 = &temp4;
36961 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36962 }
36963 }
36964 if (obj4) {
36965 {
36966 arg5 = (long)(SWIG_As_long(obj4));
36967 if (SWIG_arg_fail(5)) SWIG_fail;
36968 }
36969 }
36970 if (obj5) {
36971 {
36972 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36973 if (SWIG_arg_fail(6)) SWIG_fail;
36974 if (arg6 == NULL) {
36975 SWIG_null_ref("wxValidator");
36976 }
36977 if (SWIG_arg_fail(6)) SWIG_fail;
36978 }
36979 }
36980 if (obj6) {
36981 {
36982 arg7 = wxString_in_helper(obj6);
36983 if (arg7 == NULL) SWIG_fail;
36984 temp7 = true;
36985 }
36986 }
36987 {
36988 if (!wxPyCheckForApp()) SWIG_fail;
36989 PyThreadState* __tstate = wxPyBeginAllowThreads();
36990 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36991
36992 wxPyEndAllowThreads(__tstate);
36993 if (PyErr_Occurred()) SWIG_fail;
36994 }
36995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36996 {
36997 if (temp7)
36998 delete arg7;
36999 }
37000 return resultobj;
37001 fail:
37002 {
37003 if (temp7)
37004 delete arg7;
37005 }
37006 return NULL;
37007 }
37008
37009
37010 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37011 PyObject *resultobj;
37012 wxControl *result;
37013 char *kwnames[] = {
37014 NULL
37015 };
37016
37017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37018 {
37019 if (!wxPyCheckForApp()) SWIG_fail;
37020 PyThreadState* __tstate = wxPyBeginAllowThreads();
37021 result = (wxControl *)new wxControl();
37022
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37027 return resultobj;
37028 fail:
37029 return NULL;
37030 }
37031
37032
37033 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37034 PyObject *resultobj;
37035 wxControl *arg1 = (wxControl *) 0 ;
37036 wxWindow *arg2 = (wxWindow *) 0 ;
37037 int arg3 = (int) -1 ;
37038 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37039 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37040 wxSize const &arg5_defvalue = wxDefaultSize ;
37041 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37042 long arg6 = (long) 0 ;
37043 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37044 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37045 wxString const &arg8_defvalue = wxPyControlNameStr ;
37046 wxString *arg8 = (wxString *) &arg8_defvalue ;
37047 bool result;
37048 wxPoint temp4 ;
37049 wxSize temp5 ;
37050 bool temp8 = false ;
37051 PyObject * obj0 = 0 ;
37052 PyObject * obj1 = 0 ;
37053 PyObject * obj2 = 0 ;
37054 PyObject * obj3 = 0 ;
37055 PyObject * obj4 = 0 ;
37056 PyObject * obj5 = 0 ;
37057 PyObject * obj6 = 0 ;
37058 PyObject * obj7 = 0 ;
37059 char *kwnames[] = {
37060 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37061 };
37062
37063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37065 if (SWIG_arg_fail(1)) SWIG_fail;
37066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37067 if (SWIG_arg_fail(2)) SWIG_fail;
37068 if (obj2) {
37069 {
37070 arg3 = (int)(SWIG_As_int(obj2));
37071 if (SWIG_arg_fail(3)) SWIG_fail;
37072 }
37073 }
37074 if (obj3) {
37075 {
37076 arg4 = &temp4;
37077 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37078 }
37079 }
37080 if (obj4) {
37081 {
37082 arg5 = &temp5;
37083 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37084 }
37085 }
37086 if (obj5) {
37087 {
37088 arg6 = (long)(SWIG_As_long(obj5));
37089 if (SWIG_arg_fail(6)) SWIG_fail;
37090 }
37091 }
37092 if (obj6) {
37093 {
37094 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37095 if (SWIG_arg_fail(7)) SWIG_fail;
37096 if (arg7 == NULL) {
37097 SWIG_null_ref("wxValidator");
37098 }
37099 if (SWIG_arg_fail(7)) SWIG_fail;
37100 }
37101 }
37102 if (obj7) {
37103 {
37104 arg8 = wxString_in_helper(obj7);
37105 if (arg8 == NULL) SWIG_fail;
37106 temp8 = true;
37107 }
37108 }
37109 {
37110 PyThreadState* __tstate = wxPyBeginAllowThreads();
37111 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37112
37113 wxPyEndAllowThreads(__tstate);
37114 if (PyErr_Occurred()) SWIG_fail;
37115 }
37116 {
37117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37118 }
37119 {
37120 if (temp8)
37121 delete arg8;
37122 }
37123 return resultobj;
37124 fail:
37125 {
37126 if (temp8)
37127 delete arg8;
37128 }
37129 return NULL;
37130 }
37131
37132
37133 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37134 PyObject *resultobj;
37135 wxControl *arg1 = (wxControl *) 0 ;
37136 wxCommandEvent *arg2 = 0 ;
37137 PyObject * obj0 = 0 ;
37138 PyObject * obj1 = 0 ;
37139 char *kwnames[] = {
37140 (char *) "self",(char *) "event", NULL
37141 };
37142
37143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37145 if (SWIG_arg_fail(1)) SWIG_fail;
37146 {
37147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37148 if (SWIG_arg_fail(2)) SWIG_fail;
37149 if (arg2 == NULL) {
37150 SWIG_null_ref("wxCommandEvent");
37151 }
37152 if (SWIG_arg_fail(2)) SWIG_fail;
37153 }
37154 {
37155 PyThreadState* __tstate = wxPyBeginAllowThreads();
37156 (arg1)->Command(*arg2);
37157
37158 wxPyEndAllowThreads(__tstate);
37159 if (PyErr_Occurred()) SWIG_fail;
37160 }
37161 Py_INCREF(Py_None); resultobj = Py_None;
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37169 PyObject *resultobj;
37170 wxControl *arg1 = (wxControl *) 0 ;
37171 wxString result;
37172 PyObject * obj0 = 0 ;
37173 char *kwnames[] = {
37174 (char *) "self", NULL
37175 };
37176
37177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37179 if (SWIG_arg_fail(1)) SWIG_fail;
37180 {
37181 PyThreadState* __tstate = wxPyBeginAllowThreads();
37182 result = (arg1)->GetLabel();
37183
37184 wxPyEndAllowThreads(__tstate);
37185 if (PyErr_Occurred()) SWIG_fail;
37186 }
37187 {
37188 #if wxUSE_UNICODE
37189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37190 #else
37191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37192 #endif
37193 }
37194 return resultobj;
37195 fail:
37196 return NULL;
37197 }
37198
37199
37200 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37201 PyObject *resultobj;
37202 wxControl *arg1 = (wxControl *) 0 ;
37203 wxString *arg2 = 0 ;
37204 bool temp2 = false ;
37205 PyObject * obj0 = 0 ;
37206 PyObject * obj1 = 0 ;
37207 char *kwnames[] = {
37208 (char *) "self",(char *) "label", NULL
37209 };
37210
37211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37213 if (SWIG_arg_fail(1)) SWIG_fail;
37214 {
37215 arg2 = wxString_in_helper(obj1);
37216 if (arg2 == NULL) SWIG_fail;
37217 temp2 = true;
37218 }
37219 {
37220 PyThreadState* __tstate = wxPyBeginAllowThreads();
37221 (arg1)->SetLabel((wxString const &)*arg2);
37222
37223 wxPyEndAllowThreads(__tstate);
37224 if (PyErr_Occurred()) SWIG_fail;
37225 }
37226 Py_INCREF(Py_None); resultobj = Py_None;
37227 {
37228 if (temp2)
37229 delete arg2;
37230 }
37231 return resultobj;
37232 fail:
37233 {
37234 if (temp2)
37235 delete arg2;
37236 }
37237 return NULL;
37238 }
37239
37240
37241 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37242 PyObject *resultobj;
37243 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37244 wxVisualAttributes result;
37245 PyObject * obj0 = 0 ;
37246 char *kwnames[] = {
37247 (char *) "variant", NULL
37248 };
37249
37250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37251 if (obj0) {
37252 {
37253 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37254 if (SWIG_arg_fail(1)) SWIG_fail;
37255 }
37256 }
37257 {
37258 if (!wxPyCheckForApp()) SWIG_fail;
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37261
37262 wxPyEndAllowThreads(__tstate);
37263 if (PyErr_Occurred()) SWIG_fail;
37264 }
37265 {
37266 wxVisualAttributes * resultptr;
37267 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37268 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37269 }
37270 return resultobj;
37271 fail:
37272 return NULL;
37273 }
37274
37275
37276 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37277 PyObject *obj;
37278 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37279 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37280 Py_INCREF(obj);
37281 return Py_BuildValue((char *)"");
37282 }
37283 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37284 PyObject *resultobj;
37285 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37286 wxString *arg2 = 0 ;
37287 PyObject *arg3 = (PyObject *) NULL ;
37288 int result;
37289 bool temp2 = false ;
37290 PyObject * obj0 = 0 ;
37291 PyObject * obj1 = 0 ;
37292 PyObject * obj2 = 0 ;
37293 char *kwnames[] = {
37294 (char *) "self",(char *) "item",(char *) "clientData", NULL
37295 };
37296
37297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37299 if (SWIG_arg_fail(1)) SWIG_fail;
37300 {
37301 arg2 = wxString_in_helper(obj1);
37302 if (arg2 == NULL) SWIG_fail;
37303 temp2 = true;
37304 }
37305 if (obj2) {
37306 arg3 = obj2;
37307 }
37308 {
37309 PyThreadState* __tstate = wxPyBeginAllowThreads();
37310 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37311
37312 wxPyEndAllowThreads(__tstate);
37313 if (PyErr_Occurred()) SWIG_fail;
37314 }
37315 {
37316 resultobj = SWIG_From_int((int)(result));
37317 }
37318 {
37319 if (temp2)
37320 delete arg2;
37321 }
37322 return resultobj;
37323 fail:
37324 {
37325 if (temp2)
37326 delete arg2;
37327 }
37328 return NULL;
37329 }
37330
37331
37332 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37333 PyObject *resultobj;
37334 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37335 wxArrayString *arg2 = 0 ;
37336 bool temp2 = false ;
37337 PyObject * obj0 = 0 ;
37338 PyObject * obj1 = 0 ;
37339 char *kwnames[] = {
37340 (char *) "self",(char *) "strings", NULL
37341 };
37342
37343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37345 if (SWIG_arg_fail(1)) SWIG_fail;
37346 {
37347 if (! PySequence_Check(obj1)) {
37348 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37349 SWIG_fail;
37350 }
37351 arg2 = new wxArrayString;
37352 temp2 = true;
37353 int i, len=PySequence_Length(obj1);
37354 for (i=0; i<len; i++) {
37355 PyObject* item = PySequence_GetItem(obj1, i);
37356 #if wxUSE_UNICODE
37357 PyObject* str = PyObject_Unicode(item);
37358 #else
37359 PyObject* str = PyObject_Str(item);
37360 #endif
37361 if (PyErr_Occurred()) SWIG_fail;
37362 arg2->Add(Py2wxString(str));
37363 Py_DECREF(item);
37364 Py_DECREF(str);
37365 }
37366 }
37367 {
37368 PyThreadState* __tstate = wxPyBeginAllowThreads();
37369 (arg1)->Append((wxArrayString const &)*arg2);
37370
37371 wxPyEndAllowThreads(__tstate);
37372 if (PyErr_Occurred()) SWIG_fail;
37373 }
37374 Py_INCREF(Py_None); resultobj = Py_None;
37375 {
37376 if (temp2) delete arg2;
37377 }
37378 return resultobj;
37379 fail:
37380 {
37381 if (temp2) delete arg2;
37382 }
37383 return NULL;
37384 }
37385
37386
37387 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37388 PyObject *resultobj;
37389 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37390 wxString *arg2 = 0 ;
37391 int arg3 ;
37392 PyObject *arg4 = (PyObject *) NULL ;
37393 int result;
37394 bool temp2 = false ;
37395 PyObject * obj0 = 0 ;
37396 PyObject * obj1 = 0 ;
37397 PyObject * obj2 = 0 ;
37398 PyObject * obj3 = 0 ;
37399 char *kwnames[] = {
37400 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37401 };
37402
37403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37405 if (SWIG_arg_fail(1)) SWIG_fail;
37406 {
37407 arg2 = wxString_in_helper(obj1);
37408 if (arg2 == NULL) SWIG_fail;
37409 temp2 = true;
37410 }
37411 {
37412 arg3 = (int)(SWIG_As_int(obj2));
37413 if (SWIG_arg_fail(3)) SWIG_fail;
37414 }
37415 if (obj3) {
37416 arg4 = obj3;
37417 }
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37421
37422 wxPyEndAllowThreads(__tstate);
37423 if (PyErr_Occurred()) SWIG_fail;
37424 }
37425 {
37426 resultobj = SWIG_From_int((int)(result));
37427 }
37428 {
37429 if (temp2)
37430 delete arg2;
37431 }
37432 return resultobj;
37433 fail:
37434 {
37435 if (temp2)
37436 delete arg2;
37437 }
37438 return NULL;
37439 }
37440
37441
37442 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37443 PyObject *resultobj;
37444 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37445 PyObject * obj0 = 0 ;
37446 char *kwnames[] = {
37447 (char *) "self", NULL
37448 };
37449
37450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37452 if (SWIG_arg_fail(1)) SWIG_fail;
37453 {
37454 PyThreadState* __tstate = wxPyBeginAllowThreads();
37455 (arg1)->Clear();
37456
37457 wxPyEndAllowThreads(__tstate);
37458 if (PyErr_Occurred()) SWIG_fail;
37459 }
37460 Py_INCREF(Py_None); resultobj = Py_None;
37461 return resultobj;
37462 fail:
37463 return NULL;
37464 }
37465
37466
37467 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37468 PyObject *resultobj;
37469 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37470 int arg2 ;
37471 PyObject * obj0 = 0 ;
37472 PyObject * obj1 = 0 ;
37473 char *kwnames[] = {
37474 (char *) "self",(char *) "n", NULL
37475 };
37476
37477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37479 if (SWIG_arg_fail(1)) SWIG_fail;
37480 {
37481 arg2 = (int)(SWIG_As_int(obj1));
37482 if (SWIG_arg_fail(2)) SWIG_fail;
37483 }
37484 {
37485 PyThreadState* __tstate = wxPyBeginAllowThreads();
37486 (arg1)->Delete(arg2);
37487
37488 wxPyEndAllowThreads(__tstate);
37489 if (PyErr_Occurred()) SWIG_fail;
37490 }
37491 Py_INCREF(Py_None); resultobj = Py_None;
37492 return resultobj;
37493 fail:
37494 return NULL;
37495 }
37496
37497
37498 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37499 PyObject *resultobj;
37500 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37501 int arg2 ;
37502 PyObject *result;
37503 PyObject * obj0 = 0 ;
37504 PyObject * obj1 = 0 ;
37505 char *kwnames[] = {
37506 (char *) "self",(char *) "n", NULL
37507 };
37508
37509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37511 if (SWIG_arg_fail(1)) SWIG_fail;
37512 {
37513 arg2 = (int)(SWIG_As_int(obj1));
37514 if (SWIG_arg_fail(2)) SWIG_fail;
37515 }
37516 {
37517 PyThreadState* __tstate = wxPyBeginAllowThreads();
37518 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37519
37520 wxPyEndAllowThreads(__tstate);
37521 if (PyErr_Occurred()) SWIG_fail;
37522 }
37523 resultobj = result;
37524 return resultobj;
37525 fail:
37526 return NULL;
37527 }
37528
37529
37530 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37531 PyObject *resultobj;
37532 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37533 int arg2 ;
37534 PyObject *arg3 = (PyObject *) 0 ;
37535 PyObject * obj0 = 0 ;
37536 PyObject * obj1 = 0 ;
37537 PyObject * obj2 = 0 ;
37538 char *kwnames[] = {
37539 (char *) "self",(char *) "n",(char *) "clientData", NULL
37540 };
37541
37542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37544 if (SWIG_arg_fail(1)) SWIG_fail;
37545 {
37546 arg2 = (int)(SWIG_As_int(obj1));
37547 if (SWIG_arg_fail(2)) SWIG_fail;
37548 }
37549 arg3 = obj2;
37550 {
37551 PyThreadState* __tstate = wxPyBeginAllowThreads();
37552 wxItemContainer_SetClientData(arg1,arg2,arg3);
37553
37554 wxPyEndAllowThreads(__tstate);
37555 if (PyErr_Occurred()) SWIG_fail;
37556 }
37557 Py_INCREF(Py_None); resultobj = Py_None;
37558 return resultobj;
37559 fail:
37560 return NULL;
37561 }
37562
37563
37564 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37565 PyObject *resultobj;
37566 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37567 int result;
37568 PyObject * obj0 = 0 ;
37569 char *kwnames[] = {
37570 (char *) "self", NULL
37571 };
37572
37573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37575 if (SWIG_arg_fail(1)) SWIG_fail;
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 result = (int)((wxItemContainer const *)arg1)->GetCount();
37579
37580 wxPyEndAllowThreads(__tstate);
37581 if (PyErr_Occurred()) SWIG_fail;
37582 }
37583 {
37584 resultobj = SWIG_From_int((int)(result));
37585 }
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37593 PyObject *resultobj;
37594 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37595 bool result;
37596 PyObject * obj0 = 0 ;
37597 char *kwnames[] = {
37598 (char *) "self", NULL
37599 };
37600
37601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37603 if (SWIG_arg_fail(1)) SWIG_fail;
37604 {
37605 PyThreadState* __tstate = wxPyBeginAllowThreads();
37606 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37607
37608 wxPyEndAllowThreads(__tstate);
37609 if (PyErr_Occurred()) SWIG_fail;
37610 }
37611 {
37612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37613 }
37614 return resultobj;
37615 fail:
37616 return NULL;
37617 }
37618
37619
37620 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37621 PyObject *resultobj;
37622 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37623 int arg2 ;
37624 wxString result;
37625 PyObject * obj0 = 0 ;
37626 PyObject * obj1 = 0 ;
37627 char *kwnames[] = {
37628 (char *) "self",(char *) "n", NULL
37629 };
37630
37631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37633 if (SWIG_arg_fail(1)) SWIG_fail;
37634 {
37635 arg2 = (int)(SWIG_As_int(obj1));
37636 if (SWIG_arg_fail(2)) SWIG_fail;
37637 }
37638 {
37639 PyThreadState* __tstate = wxPyBeginAllowThreads();
37640 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37641
37642 wxPyEndAllowThreads(__tstate);
37643 if (PyErr_Occurred()) SWIG_fail;
37644 }
37645 {
37646 #if wxUSE_UNICODE
37647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37648 #else
37649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37650 #endif
37651 }
37652 return resultobj;
37653 fail:
37654 return NULL;
37655 }
37656
37657
37658 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37659 PyObject *resultobj;
37660 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37661 wxArrayString result;
37662 PyObject * obj0 = 0 ;
37663 char *kwnames[] = {
37664 (char *) "self", NULL
37665 };
37666
37667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37669 if (SWIG_arg_fail(1)) SWIG_fail;
37670 {
37671 PyThreadState* __tstate = wxPyBeginAllowThreads();
37672 result = ((wxItemContainer const *)arg1)->GetStrings();
37673
37674 wxPyEndAllowThreads(__tstate);
37675 if (PyErr_Occurred()) SWIG_fail;
37676 }
37677 {
37678 resultobj = wxArrayString2PyList_helper(result);
37679 }
37680 return resultobj;
37681 fail:
37682 return NULL;
37683 }
37684
37685
37686 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37687 PyObject *resultobj;
37688 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37689 int arg2 ;
37690 wxString *arg3 = 0 ;
37691 bool temp3 = false ;
37692 PyObject * obj0 = 0 ;
37693 PyObject * obj1 = 0 ;
37694 PyObject * obj2 = 0 ;
37695 char *kwnames[] = {
37696 (char *) "self",(char *) "n",(char *) "s", NULL
37697 };
37698
37699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37701 if (SWIG_arg_fail(1)) SWIG_fail;
37702 {
37703 arg2 = (int)(SWIG_As_int(obj1));
37704 if (SWIG_arg_fail(2)) SWIG_fail;
37705 }
37706 {
37707 arg3 = wxString_in_helper(obj2);
37708 if (arg3 == NULL) SWIG_fail;
37709 temp3 = true;
37710 }
37711 {
37712 PyThreadState* __tstate = wxPyBeginAllowThreads();
37713 (arg1)->SetString(arg2,(wxString const &)*arg3);
37714
37715 wxPyEndAllowThreads(__tstate);
37716 if (PyErr_Occurred()) SWIG_fail;
37717 }
37718 Py_INCREF(Py_None); resultobj = Py_None;
37719 {
37720 if (temp3)
37721 delete arg3;
37722 }
37723 return resultobj;
37724 fail:
37725 {
37726 if (temp3)
37727 delete arg3;
37728 }
37729 return NULL;
37730 }
37731
37732
37733 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37734 PyObject *resultobj;
37735 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37736 wxString *arg2 = 0 ;
37737 int result;
37738 bool temp2 = false ;
37739 PyObject * obj0 = 0 ;
37740 PyObject * obj1 = 0 ;
37741 char *kwnames[] = {
37742 (char *) "self",(char *) "s", NULL
37743 };
37744
37745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37747 if (SWIG_arg_fail(1)) SWIG_fail;
37748 {
37749 arg2 = wxString_in_helper(obj1);
37750 if (arg2 == NULL) SWIG_fail;
37751 temp2 = true;
37752 }
37753 {
37754 PyThreadState* __tstate = wxPyBeginAllowThreads();
37755 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37756
37757 wxPyEndAllowThreads(__tstate);
37758 if (PyErr_Occurred()) SWIG_fail;
37759 }
37760 {
37761 resultobj = SWIG_From_int((int)(result));
37762 }
37763 {
37764 if (temp2)
37765 delete arg2;
37766 }
37767 return resultobj;
37768 fail:
37769 {
37770 if (temp2)
37771 delete arg2;
37772 }
37773 return NULL;
37774 }
37775
37776
37777 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37778 PyObject *resultobj;
37779 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37780 int arg2 ;
37781 PyObject * obj0 = 0 ;
37782 PyObject * obj1 = 0 ;
37783 char *kwnames[] = {
37784 (char *) "self",(char *) "n", NULL
37785 };
37786
37787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37789 if (SWIG_arg_fail(1)) SWIG_fail;
37790 {
37791 arg2 = (int)(SWIG_As_int(obj1));
37792 if (SWIG_arg_fail(2)) SWIG_fail;
37793 }
37794 {
37795 PyThreadState* __tstate = wxPyBeginAllowThreads();
37796 (arg1)->SetSelection(arg2);
37797
37798 wxPyEndAllowThreads(__tstate);
37799 if (PyErr_Occurred()) SWIG_fail;
37800 }
37801 Py_INCREF(Py_None); resultobj = Py_None;
37802 return resultobj;
37803 fail:
37804 return NULL;
37805 }
37806
37807
37808 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37809 PyObject *resultobj;
37810 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37811 int result;
37812 PyObject * obj0 = 0 ;
37813 char *kwnames[] = {
37814 (char *) "self", NULL
37815 };
37816
37817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37819 if (SWIG_arg_fail(1)) SWIG_fail;
37820 {
37821 PyThreadState* __tstate = wxPyBeginAllowThreads();
37822 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37823
37824 wxPyEndAllowThreads(__tstate);
37825 if (PyErr_Occurred()) SWIG_fail;
37826 }
37827 {
37828 resultobj = SWIG_From_int((int)(result));
37829 }
37830 return resultobj;
37831 fail:
37832 return NULL;
37833 }
37834
37835
37836 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37837 PyObject *resultobj;
37838 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37839 wxString *arg2 = 0 ;
37840 bool result;
37841 bool temp2 = false ;
37842 PyObject * obj0 = 0 ;
37843 PyObject * obj1 = 0 ;
37844 char *kwnames[] = {
37845 (char *) "self",(char *) "s", NULL
37846 };
37847
37848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37850 if (SWIG_arg_fail(1)) SWIG_fail;
37851 {
37852 arg2 = wxString_in_helper(obj1);
37853 if (arg2 == NULL) SWIG_fail;
37854 temp2 = true;
37855 }
37856 {
37857 PyThreadState* __tstate = wxPyBeginAllowThreads();
37858 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37859
37860 wxPyEndAllowThreads(__tstate);
37861 if (PyErr_Occurred()) SWIG_fail;
37862 }
37863 {
37864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37865 }
37866 {
37867 if (temp2)
37868 delete arg2;
37869 }
37870 return resultobj;
37871 fail:
37872 {
37873 if (temp2)
37874 delete arg2;
37875 }
37876 return NULL;
37877 }
37878
37879
37880 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37881 PyObject *resultobj;
37882 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37883 wxString result;
37884 PyObject * obj0 = 0 ;
37885 char *kwnames[] = {
37886 (char *) "self", NULL
37887 };
37888
37889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37891 if (SWIG_arg_fail(1)) SWIG_fail;
37892 {
37893 PyThreadState* __tstate = wxPyBeginAllowThreads();
37894 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37895
37896 wxPyEndAllowThreads(__tstate);
37897 if (PyErr_Occurred()) SWIG_fail;
37898 }
37899 {
37900 #if wxUSE_UNICODE
37901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37902 #else
37903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37904 #endif
37905 }
37906 return resultobj;
37907 fail:
37908 return NULL;
37909 }
37910
37911
37912 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37913 PyObject *resultobj;
37914 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37915 int arg2 ;
37916 PyObject * obj0 = 0 ;
37917 PyObject * obj1 = 0 ;
37918 char *kwnames[] = {
37919 (char *) "self",(char *) "n", NULL
37920 };
37921
37922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37924 if (SWIG_arg_fail(1)) SWIG_fail;
37925 {
37926 arg2 = (int)(SWIG_As_int(obj1));
37927 if (SWIG_arg_fail(2)) SWIG_fail;
37928 }
37929 {
37930 PyThreadState* __tstate = wxPyBeginAllowThreads();
37931 (arg1)->Select(arg2);
37932
37933 wxPyEndAllowThreads(__tstate);
37934 if (PyErr_Occurred()) SWIG_fail;
37935 }
37936 Py_INCREF(Py_None); resultobj = Py_None;
37937 return resultobj;
37938 fail:
37939 return NULL;
37940 }
37941
37942
37943 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37944 PyObject *obj;
37945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37946 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37947 Py_INCREF(obj);
37948 return Py_BuildValue((char *)"");
37949 }
37950 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37951 PyObject *obj;
37952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37953 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37954 Py_INCREF(obj);
37955 return Py_BuildValue((char *)"");
37956 }
37957 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37958 PyObject *resultobj;
37959 wxSizerItem *result;
37960 char *kwnames[] = {
37961 NULL
37962 };
37963
37964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37965 {
37966 PyThreadState* __tstate = wxPyBeginAllowThreads();
37967 result = (wxSizerItem *)new wxSizerItem();
37968
37969 wxPyEndAllowThreads(__tstate);
37970 if (PyErr_Occurred()) SWIG_fail;
37971 }
37972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37973 return resultobj;
37974 fail:
37975 return NULL;
37976 }
37977
37978
37979 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37980 PyObject *resultobj;
37981 wxWindow *arg1 = (wxWindow *) 0 ;
37982 int arg2 ;
37983 int arg3 ;
37984 int arg4 ;
37985 PyObject *arg5 = (PyObject *) NULL ;
37986 wxSizerItem *result;
37987 PyObject * obj0 = 0 ;
37988 PyObject * obj1 = 0 ;
37989 PyObject * obj2 = 0 ;
37990 PyObject * obj3 = 0 ;
37991 PyObject * obj4 = 0 ;
37992 char *kwnames[] = {
37993 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37994 };
37995
37996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37998 if (SWIG_arg_fail(1)) SWIG_fail;
37999 {
38000 arg2 = (int)(SWIG_As_int(obj1));
38001 if (SWIG_arg_fail(2)) SWIG_fail;
38002 }
38003 {
38004 arg3 = (int)(SWIG_As_int(obj2));
38005 if (SWIG_arg_fail(3)) SWIG_fail;
38006 }
38007 {
38008 arg4 = (int)(SWIG_As_int(obj3));
38009 if (SWIG_arg_fail(4)) SWIG_fail;
38010 }
38011 if (obj4) {
38012 arg5 = obj4;
38013 }
38014 {
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38017
38018 wxPyEndAllowThreads(__tstate);
38019 if (PyErr_Occurred()) SWIG_fail;
38020 }
38021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38022 return resultobj;
38023 fail:
38024 return NULL;
38025 }
38026
38027
38028 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38029 PyObject *resultobj;
38030 int arg1 ;
38031 int arg2 ;
38032 int arg3 ;
38033 int arg4 ;
38034 int arg5 ;
38035 PyObject *arg6 = (PyObject *) NULL ;
38036 wxSizerItem *result;
38037 PyObject * obj0 = 0 ;
38038 PyObject * obj1 = 0 ;
38039 PyObject * obj2 = 0 ;
38040 PyObject * obj3 = 0 ;
38041 PyObject * obj4 = 0 ;
38042 PyObject * obj5 = 0 ;
38043 char *kwnames[] = {
38044 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38045 };
38046
38047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38048 {
38049 arg1 = (int)(SWIG_As_int(obj0));
38050 if (SWIG_arg_fail(1)) SWIG_fail;
38051 }
38052 {
38053 arg2 = (int)(SWIG_As_int(obj1));
38054 if (SWIG_arg_fail(2)) SWIG_fail;
38055 }
38056 {
38057 arg3 = (int)(SWIG_As_int(obj2));
38058 if (SWIG_arg_fail(3)) SWIG_fail;
38059 }
38060 {
38061 arg4 = (int)(SWIG_As_int(obj3));
38062 if (SWIG_arg_fail(4)) SWIG_fail;
38063 }
38064 {
38065 arg5 = (int)(SWIG_As_int(obj4));
38066 if (SWIG_arg_fail(5)) SWIG_fail;
38067 }
38068 if (obj5) {
38069 arg6 = obj5;
38070 }
38071 {
38072 PyThreadState* __tstate = wxPyBeginAllowThreads();
38073 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38074
38075 wxPyEndAllowThreads(__tstate);
38076 if (PyErr_Occurred()) SWIG_fail;
38077 }
38078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38079 return resultobj;
38080 fail:
38081 return NULL;
38082 }
38083
38084
38085 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38086 PyObject *resultobj;
38087 wxSizer *arg1 = (wxSizer *) 0 ;
38088 int arg2 ;
38089 int arg3 ;
38090 int arg4 ;
38091 PyObject *arg5 = (PyObject *) NULL ;
38092 wxSizerItem *result;
38093 PyObject * obj0 = 0 ;
38094 PyObject * obj1 = 0 ;
38095 PyObject * obj2 = 0 ;
38096 PyObject * obj3 = 0 ;
38097 PyObject * obj4 = 0 ;
38098 char *kwnames[] = {
38099 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38100 };
38101
38102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38104 if (SWIG_arg_fail(1)) SWIG_fail;
38105 {
38106 arg2 = (int)(SWIG_As_int(obj1));
38107 if (SWIG_arg_fail(2)) SWIG_fail;
38108 }
38109 {
38110 arg3 = (int)(SWIG_As_int(obj2));
38111 if (SWIG_arg_fail(3)) SWIG_fail;
38112 }
38113 {
38114 arg4 = (int)(SWIG_As_int(obj3));
38115 if (SWIG_arg_fail(4)) SWIG_fail;
38116 }
38117 if (obj4) {
38118 arg5 = obj4;
38119 }
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38123
38124 wxPyEndAllowThreads(__tstate);
38125 if (PyErr_Occurred()) SWIG_fail;
38126 }
38127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38128 return resultobj;
38129 fail:
38130 return NULL;
38131 }
38132
38133
38134 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38135 PyObject *resultobj;
38136 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38137 PyObject * obj0 = 0 ;
38138 char *kwnames[] = {
38139 (char *) "self", NULL
38140 };
38141
38142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38144 if (SWIG_arg_fail(1)) SWIG_fail;
38145 {
38146 PyThreadState* __tstate = wxPyBeginAllowThreads();
38147 (arg1)->DeleteWindows();
38148
38149 wxPyEndAllowThreads(__tstate);
38150 if (PyErr_Occurred()) SWIG_fail;
38151 }
38152 Py_INCREF(Py_None); resultobj = Py_None;
38153 return resultobj;
38154 fail:
38155 return NULL;
38156 }
38157
38158
38159 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38160 PyObject *resultobj;
38161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38162 PyObject * obj0 = 0 ;
38163 char *kwnames[] = {
38164 (char *) "self", NULL
38165 };
38166
38167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38169 if (SWIG_arg_fail(1)) SWIG_fail;
38170 {
38171 PyThreadState* __tstate = wxPyBeginAllowThreads();
38172 (arg1)->DetachSizer();
38173
38174 wxPyEndAllowThreads(__tstate);
38175 if (PyErr_Occurred()) SWIG_fail;
38176 }
38177 Py_INCREF(Py_None); resultobj = Py_None;
38178 return resultobj;
38179 fail:
38180 return NULL;
38181 }
38182
38183
38184 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38185 PyObject *resultobj;
38186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38187 wxSize result;
38188 PyObject * obj0 = 0 ;
38189 char *kwnames[] = {
38190 (char *) "self", NULL
38191 };
38192
38193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38195 if (SWIG_arg_fail(1)) SWIG_fail;
38196 {
38197 PyThreadState* __tstate = wxPyBeginAllowThreads();
38198 result = (arg1)->GetSize();
38199
38200 wxPyEndAllowThreads(__tstate);
38201 if (PyErr_Occurred()) SWIG_fail;
38202 }
38203 {
38204 wxSize * resultptr;
38205 resultptr = new wxSize((wxSize &)(result));
38206 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38207 }
38208 return resultobj;
38209 fail:
38210 return NULL;
38211 }
38212
38213
38214 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38215 PyObject *resultobj;
38216 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38217 wxSize result;
38218 PyObject * obj0 = 0 ;
38219 char *kwnames[] = {
38220 (char *) "self", NULL
38221 };
38222
38223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38225 if (SWIG_arg_fail(1)) SWIG_fail;
38226 {
38227 PyThreadState* __tstate = wxPyBeginAllowThreads();
38228 result = (arg1)->CalcMin();
38229
38230 wxPyEndAllowThreads(__tstate);
38231 if (PyErr_Occurred()) SWIG_fail;
38232 }
38233 {
38234 wxSize * resultptr;
38235 resultptr = new wxSize((wxSize &)(result));
38236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38237 }
38238 return resultobj;
38239 fail:
38240 return NULL;
38241 }
38242
38243
38244 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38245 PyObject *resultobj;
38246 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38247 wxPoint arg2 ;
38248 wxSize arg3 ;
38249 PyObject * obj0 = 0 ;
38250 PyObject * obj1 = 0 ;
38251 PyObject * obj2 = 0 ;
38252 char *kwnames[] = {
38253 (char *) "self",(char *) "pos",(char *) "size", NULL
38254 };
38255
38256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38258 if (SWIG_arg_fail(1)) SWIG_fail;
38259 {
38260 wxPoint * argp;
38261 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38262 if (SWIG_arg_fail(2)) SWIG_fail;
38263 if (argp == NULL) {
38264 SWIG_null_ref("wxPoint");
38265 }
38266 if (SWIG_arg_fail(2)) SWIG_fail;
38267 arg2 = *argp;
38268 }
38269 {
38270 wxSize * argp;
38271 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38272 if (SWIG_arg_fail(3)) SWIG_fail;
38273 if (argp == NULL) {
38274 SWIG_null_ref("wxSize");
38275 }
38276 if (SWIG_arg_fail(3)) SWIG_fail;
38277 arg3 = *argp;
38278 }
38279 {
38280 PyThreadState* __tstate = wxPyBeginAllowThreads();
38281 (arg1)->SetDimension(arg2,arg3);
38282
38283 wxPyEndAllowThreads(__tstate);
38284 if (PyErr_Occurred()) SWIG_fail;
38285 }
38286 Py_INCREF(Py_None); resultobj = Py_None;
38287 return resultobj;
38288 fail:
38289 return NULL;
38290 }
38291
38292
38293 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38294 PyObject *resultobj;
38295 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38296 wxSize result;
38297 PyObject * obj0 = 0 ;
38298 char *kwnames[] = {
38299 (char *) "self", NULL
38300 };
38301
38302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38304 if (SWIG_arg_fail(1)) SWIG_fail;
38305 {
38306 PyThreadState* __tstate = wxPyBeginAllowThreads();
38307 result = (arg1)->GetMinSize();
38308
38309 wxPyEndAllowThreads(__tstate);
38310 if (PyErr_Occurred()) SWIG_fail;
38311 }
38312 {
38313 wxSize * resultptr;
38314 resultptr = new wxSize((wxSize &)(result));
38315 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38316 }
38317 return resultobj;
38318 fail:
38319 return NULL;
38320 }
38321
38322
38323 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38324 PyObject *resultobj;
38325 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38326 wxSize result;
38327 PyObject * obj0 = 0 ;
38328 char *kwnames[] = {
38329 (char *) "self", NULL
38330 };
38331
38332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38334 if (SWIG_arg_fail(1)) SWIG_fail;
38335 {
38336 PyThreadState* __tstate = wxPyBeginAllowThreads();
38337 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38338
38339 wxPyEndAllowThreads(__tstate);
38340 if (PyErr_Occurred()) SWIG_fail;
38341 }
38342 {
38343 wxSize * resultptr;
38344 resultptr = new wxSize((wxSize &)(result));
38345 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38346 }
38347 return resultobj;
38348 fail:
38349 return NULL;
38350 }
38351
38352
38353 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38354 PyObject *resultobj;
38355 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38356 int arg2 ;
38357 int arg3 ;
38358 PyObject * obj0 = 0 ;
38359 PyObject * obj1 = 0 ;
38360 PyObject * obj2 = 0 ;
38361 char *kwnames[] = {
38362 (char *) "self",(char *) "x",(char *) "y", NULL
38363 };
38364
38365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38367 if (SWIG_arg_fail(1)) SWIG_fail;
38368 {
38369 arg2 = (int)(SWIG_As_int(obj1));
38370 if (SWIG_arg_fail(2)) SWIG_fail;
38371 }
38372 {
38373 arg3 = (int)(SWIG_As_int(obj2));
38374 if (SWIG_arg_fail(3)) SWIG_fail;
38375 }
38376 {
38377 PyThreadState* __tstate = wxPyBeginAllowThreads();
38378 (arg1)->SetInitSize(arg2,arg3);
38379
38380 wxPyEndAllowThreads(__tstate);
38381 if (PyErr_Occurred()) SWIG_fail;
38382 }
38383 Py_INCREF(Py_None); resultobj = Py_None;
38384 return resultobj;
38385 fail:
38386 return NULL;
38387 }
38388
38389
38390 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38391 PyObject *resultobj;
38392 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38393 int arg2 ;
38394 int arg3 ;
38395 PyObject * obj0 = 0 ;
38396 PyObject * obj1 = 0 ;
38397 PyObject * obj2 = 0 ;
38398 char *kwnames[] = {
38399 (char *) "self",(char *) "width",(char *) "height", NULL
38400 };
38401
38402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38404 if (SWIG_arg_fail(1)) SWIG_fail;
38405 {
38406 arg2 = (int)(SWIG_As_int(obj1));
38407 if (SWIG_arg_fail(2)) SWIG_fail;
38408 }
38409 {
38410 arg3 = (int)(SWIG_As_int(obj2));
38411 if (SWIG_arg_fail(3)) SWIG_fail;
38412 }
38413 {
38414 PyThreadState* __tstate = wxPyBeginAllowThreads();
38415 (arg1)->SetRatio(arg2,arg3);
38416
38417 wxPyEndAllowThreads(__tstate);
38418 if (PyErr_Occurred()) SWIG_fail;
38419 }
38420 Py_INCREF(Py_None); resultobj = Py_None;
38421 return resultobj;
38422 fail:
38423 return NULL;
38424 }
38425
38426
38427 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38428 PyObject *resultobj;
38429 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38430 wxSize arg2 ;
38431 PyObject * obj0 = 0 ;
38432 PyObject * obj1 = 0 ;
38433 char *kwnames[] = {
38434 (char *) "self",(char *) "size", NULL
38435 };
38436
38437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38439 if (SWIG_arg_fail(1)) SWIG_fail;
38440 {
38441 wxSize * argp;
38442 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38443 if (SWIG_arg_fail(2)) SWIG_fail;
38444 if (argp == NULL) {
38445 SWIG_null_ref("wxSize");
38446 }
38447 if (SWIG_arg_fail(2)) SWIG_fail;
38448 arg2 = *argp;
38449 }
38450 {
38451 PyThreadState* __tstate = wxPyBeginAllowThreads();
38452 (arg1)->SetRatio(arg2);
38453
38454 wxPyEndAllowThreads(__tstate);
38455 if (PyErr_Occurred()) SWIG_fail;
38456 }
38457 Py_INCREF(Py_None); resultobj = Py_None;
38458 return resultobj;
38459 fail:
38460 return NULL;
38461 }
38462
38463
38464 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38465 PyObject *resultobj;
38466 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38467 float arg2 ;
38468 PyObject * obj0 = 0 ;
38469 PyObject * obj1 = 0 ;
38470 char *kwnames[] = {
38471 (char *) "self",(char *) "ratio", NULL
38472 };
38473
38474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38476 if (SWIG_arg_fail(1)) SWIG_fail;
38477 {
38478 arg2 = (float)(SWIG_As_float(obj1));
38479 if (SWIG_arg_fail(2)) SWIG_fail;
38480 }
38481 {
38482 PyThreadState* __tstate = wxPyBeginAllowThreads();
38483 (arg1)->SetRatio(arg2);
38484
38485 wxPyEndAllowThreads(__tstate);
38486 if (PyErr_Occurred()) SWIG_fail;
38487 }
38488 Py_INCREF(Py_None); resultobj = Py_None;
38489 return resultobj;
38490 fail:
38491 return NULL;
38492 }
38493
38494
38495 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38496 PyObject *resultobj;
38497 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38498 float result;
38499 PyObject * obj0 = 0 ;
38500 char *kwnames[] = {
38501 (char *) "self", NULL
38502 };
38503
38504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38506 if (SWIG_arg_fail(1)) SWIG_fail;
38507 {
38508 PyThreadState* __tstate = wxPyBeginAllowThreads();
38509 result = (float)(arg1)->GetRatio();
38510
38511 wxPyEndAllowThreads(__tstate);
38512 if (PyErr_Occurred()) SWIG_fail;
38513 }
38514 {
38515 resultobj = SWIG_From_float((float)(result));
38516 }
38517 return resultobj;
38518 fail:
38519 return NULL;
38520 }
38521
38522
38523 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38524 PyObject *resultobj;
38525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38526 wxRect result;
38527 PyObject * obj0 = 0 ;
38528 char *kwnames[] = {
38529 (char *) "self", NULL
38530 };
38531
38532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38534 if (SWIG_arg_fail(1)) SWIG_fail;
38535 {
38536 PyThreadState* __tstate = wxPyBeginAllowThreads();
38537 result = (arg1)->GetRect();
38538
38539 wxPyEndAllowThreads(__tstate);
38540 if (PyErr_Occurred()) SWIG_fail;
38541 }
38542 {
38543 wxRect * resultptr;
38544 resultptr = new wxRect((wxRect &)(result));
38545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38546 }
38547 return resultobj;
38548 fail:
38549 return NULL;
38550 }
38551
38552
38553 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38554 PyObject *resultobj;
38555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38556 bool result;
38557 PyObject * obj0 = 0 ;
38558 char *kwnames[] = {
38559 (char *) "self", NULL
38560 };
38561
38562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38564 if (SWIG_arg_fail(1)) SWIG_fail;
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 result = (bool)(arg1)->IsWindow();
38568
38569 wxPyEndAllowThreads(__tstate);
38570 if (PyErr_Occurred()) SWIG_fail;
38571 }
38572 {
38573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38574 }
38575 return resultobj;
38576 fail:
38577 return NULL;
38578 }
38579
38580
38581 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38582 PyObject *resultobj;
38583 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38584 bool result;
38585 PyObject * obj0 = 0 ;
38586 char *kwnames[] = {
38587 (char *) "self", NULL
38588 };
38589
38590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38592 if (SWIG_arg_fail(1)) SWIG_fail;
38593 {
38594 PyThreadState* __tstate = wxPyBeginAllowThreads();
38595 result = (bool)(arg1)->IsSizer();
38596
38597 wxPyEndAllowThreads(__tstate);
38598 if (PyErr_Occurred()) SWIG_fail;
38599 }
38600 {
38601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38602 }
38603 return resultobj;
38604 fail:
38605 return NULL;
38606 }
38607
38608
38609 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38610 PyObject *resultobj;
38611 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38612 bool result;
38613 PyObject * obj0 = 0 ;
38614 char *kwnames[] = {
38615 (char *) "self", NULL
38616 };
38617
38618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38620 if (SWIG_arg_fail(1)) SWIG_fail;
38621 {
38622 PyThreadState* __tstate = wxPyBeginAllowThreads();
38623 result = (bool)(arg1)->IsSpacer();
38624
38625 wxPyEndAllowThreads(__tstate);
38626 if (PyErr_Occurred()) SWIG_fail;
38627 }
38628 {
38629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38630 }
38631 return resultobj;
38632 fail:
38633 return NULL;
38634 }
38635
38636
38637 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38638 PyObject *resultobj;
38639 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38640 int arg2 ;
38641 PyObject * obj0 = 0 ;
38642 PyObject * obj1 = 0 ;
38643 char *kwnames[] = {
38644 (char *) "self",(char *) "proportion", NULL
38645 };
38646
38647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38649 if (SWIG_arg_fail(1)) SWIG_fail;
38650 {
38651 arg2 = (int)(SWIG_As_int(obj1));
38652 if (SWIG_arg_fail(2)) SWIG_fail;
38653 }
38654 {
38655 PyThreadState* __tstate = wxPyBeginAllowThreads();
38656 (arg1)->SetProportion(arg2);
38657
38658 wxPyEndAllowThreads(__tstate);
38659 if (PyErr_Occurred()) SWIG_fail;
38660 }
38661 Py_INCREF(Py_None); resultobj = Py_None;
38662 return resultobj;
38663 fail:
38664 return NULL;
38665 }
38666
38667
38668 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38669 PyObject *resultobj;
38670 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38671 int result;
38672 PyObject * obj0 = 0 ;
38673 char *kwnames[] = {
38674 (char *) "self", NULL
38675 };
38676
38677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38679 if (SWIG_arg_fail(1)) SWIG_fail;
38680 {
38681 PyThreadState* __tstate = wxPyBeginAllowThreads();
38682 result = (int)(arg1)->GetProportion();
38683
38684 wxPyEndAllowThreads(__tstate);
38685 if (PyErr_Occurred()) SWIG_fail;
38686 }
38687 {
38688 resultobj = SWIG_From_int((int)(result));
38689 }
38690 return resultobj;
38691 fail:
38692 return NULL;
38693 }
38694
38695
38696 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38697 PyObject *resultobj;
38698 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38699 int arg2 ;
38700 PyObject * obj0 = 0 ;
38701 PyObject * obj1 = 0 ;
38702 char *kwnames[] = {
38703 (char *) "self",(char *) "flag", NULL
38704 };
38705
38706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38708 if (SWIG_arg_fail(1)) SWIG_fail;
38709 {
38710 arg2 = (int)(SWIG_As_int(obj1));
38711 if (SWIG_arg_fail(2)) SWIG_fail;
38712 }
38713 {
38714 PyThreadState* __tstate = wxPyBeginAllowThreads();
38715 (arg1)->SetFlag(arg2);
38716
38717 wxPyEndAllowThreads(__tstate);
38718 if (PyErr_Occurred()) SWIG_fail;
38719 }
38720 Py_INCREF(Py_None); resultobj = Py_None;
38721 return resultobj;
38722 fail:
38723 return NULL;
38724 }
38725
38726
38727 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38728 PyObject *resultobj;
38729 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38730 int result;
38731 PyObject * obj0 = 0 ;
38732 char *kwnames[] = {
38733 (char *) "self", NULL
38734 };
38735
38736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38738 if (SWIG_arg_fail(1)) SWIG_fail;
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 result = (int)(arg1)->GetFlag();
38742
38743 wxPyEndAllowThreads(__tstate);
38744 if (PyErr_Occurred()) SWIG_fail;
38745 }
38746 {
38747 resultobj = SWIG_From_int((int)(result));
38748 }
38749 return resultobj;
38750 fail:
38751 return NULL;
38752 }
38753
38754
38755 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38756 PyObject *resultobj;
38757 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38758 int arg2 ;
38759 PyObject * obj0 = 0 ;
38760 PyObject * obj1 = 0 ;
38761 char *kwnames[] = {
38762 (char *) "self",(char *) "border", NULL
38763 };
38764
38765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38767 if (SWIG_arg_fail(1)) SWIG_fail;
38768 {
38769 arg2 = (int)(SWIG_As_int(obj1));
38770 if (SWIG_arg_fail(2)) SWIG_fail;
38771 }
38772 {
38773 PyThreadState* __tstate = wxPyBeginAllowThreads();
38774 (arg1)->SetBorder(arg2);
38775
38776 wxPyEndAllowThreads(__tstate);
38777 if (PyErr_Occurred()) SWIG_fail;
38778 }
38779 Py_INCREF(Py_None); resultobj = Py_None;
38780 return resultobj;
38781 fail:
38782 return NULL;
38783 }
38784
38785
38786 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38787 PyObject *resultobj;
38788 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38789 int result;
38790 PyObject * obj0 = 0 ;
38791 char *kwnames[] = {
38792 (char *) "self", NULL
38793 };
38794
38795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38797 if (SWIG_arg_fail(1)) SWIG_fail;
38798 {
38799 PyThreadState* __tstate = wxPyBeginAllowThreads();
38800 result = (int)(arg1)->GetBorder();
38801
38802 wxPyEndAllowThreads(__tstate);
38803 if (PyErr_Occurred()) SWIG_fail;
38804 }
38805 {
38806 resultobj = SWIG_From_int((int)(result));
38807 }
38808 return resultobj;
38809 fail:
38810 return NULL;
38811 }
38812
38813
38814 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38815 PyObject *resultobj;
38816 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38817 wxWindow *result;
38818 PyObject * obj0 = 0 ;
38819 char *kwnames[] = {
38820 (char *) "self", NULL
38821 };
38822
38823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38825 if (SWIG_arg_fail(1)) SWIG_fail;
38826 {
38827 PyThreadState* __tstate = wxPyBeginAllowThreads();
38828 result = (wxWindow *)(arg1)->GetWindow();
38829
38830 wxPyEndAllowThreads(__tstate);
38831 if (PyErr_Occurred()) SWIG_fail;
38832 }
38833 {
38834 resultobj = wxPyMake_wxObject(result, 0);
38835 }
38836 return resultobj;
38837 fail:
38838 return NULL;
38839 }
38840
38841
38842 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38843 PyObject *resultobj;
38844 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38845 wxWindow *arg2 = (wxWindow *) 0 ;
38846 PyObject * obj0 = 0 ;
38847 PyObject * obj1 = 0 ;
38848 char *kwnames[] = {
38849 (char *) "self",(char *) "window", NULL
38850 };
38851
38852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38854 if (SWIG_arg_fail(1)) SWIG_fail;
38855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38856 if (SWIG_arg_fail(2)) SWIG_fail;
38857 {
38858 PyThreadState* __tstate = wxPyBeginAllowThreads();
38859 (arg1)->SetWindow(arg2);
38860
38861 wxPyEndAllowThreads(__tstate);
38862 if (PyErr_Occurred()) SWIG_fail;
38863 }
38864 Py_INCREF(Py_None); resultobj = Py_None;
38865 return resultobj;
38866 fail:
38867 return NULL;
38868 }
38869
38870
38871 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38872 PyObject *resultobj;
38873 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38874 wxSizer *result;
38875 PyObject * obj0 = 0 ;
38876 char *kwnames[] = {
38877 (char *) "self", NULL
38878 };
38879
38880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38882 if (SWIG_arg_fail(1)) SWIG_fail;
38883 {
38884 PyThreadState* __tstate = wxPyBeginAllowThreads();
38885 result = (wxSizer *)(arg1)->GetSizer();
38886
38887 wxPyEndAllowThreads(__tstate);
38888 if (PyErr_Occurred()) SWIG_fail;
38889 }
38890 {
38891 resultobj = wxPyMake_wxSizer(result, 0);
38892 }
38893 return resultobj;
38894 fail:
38895 return NULL;
38896 }
38897
38898
38899 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38900 PyObject *resultobj;
38901 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38902 wxSizer *arg2 = (wxSizer *) 0 ;
38903 PyObject * obj0 = 0 ;
38904 PyObject * obj1 = 0 ;
38905 char *kwnames[] = {
38906 (char *) "self",(char *) "sizer", NULL
38907 };
38908
38909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38911 if (SWIG_arg_fail(1)) SWIG_fail;
38912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38913 if (SWIG_arg_fail(2)) SWIG_fail;
38914 {
38915 PyThreadState* __tstate = wxPyBeginAllowThreads();
38916 (arg1)->SetSizer(arg2);
38917
38918 wxPyEndAllowThreads(__tstate);
38919 if (PyErr_Occurred()) SWIG_fail;
38920 }
38921 Py_INCREF(Py_None); resultobj = Py_None;
38922 return resultobj;
38923 fail:
38924 return NULL;
38925 }
38926
38927
38928 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38929 PyObject *resultobj;
38930 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38931 wxSize *result;
38932 PyObject * obj0 = 0 ;
38933 char *kwnames[] = {
38934 (char *) "self", NULL
38935 };
38936
38937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38939 if (SWIG_arg_fail(1)) SWIG_fail;
38940 {
38941 PyThreadState* __tstate = wxPyBeginAllowThreads();
38942 {
38943 wxSize const &_result_ref = (arg1)->GetSpacer();
38944 result = (wxSize *) &_result_ref;
38945 }
38946
38947 wxPyEndAllowThreads(__tstate);
38948 if (PyErr_Occurred()) SWIG_fail;
38949 }
38950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38951 return resultobj;
38952 fail:
38953 return NULL;
38954 }
38955
38956
38957 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38958 PyObject *resultobj;
38959 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38960 wxSize *arg2 = 0 ;
38961 wxSize temp2 ;
38962 PyObject * obj0 = 0 ;
38963 PyObject * obj1 = 0 ;
38964 char *kwnames[] = {
38965 (char *) "self",(char *) "size", NULL
38966 };
38967
38968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38970 if (SWIG_arg_fail(1)) SWIG_fail;
38971 {
38972 arg2 = &temp2;
38973 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38974 }
38975 {
38976 PyThreadState* __tstate = wxPyBeginAllowThreads();
38977 (arg1)->SetSpacer((wxSize const &)*arg2);
38978
38979 wxPyEndAllowThreads(__tstate);
38980 if (PyErr_Occurred()) SWIG_fail;
38981 }
38982 Py_INCREF(Py_None); resultobj = Py_None;
38983 return resultobj;
38984 fail:
38985 return NULL;
38986 }
38987
38988
38989 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38990 PyObject *resultobj;
38991 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38992 bool arg2 ;
38993 PyObject * obj0 = 0 ;
38994 PyObject * obj1 = 0 ;
38995 char *kwnames[] = {
38996 (char *) "self",(char *) "show", NULL
38997 };
38998
38999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39001 if (SWIG_arg_fail(1)) SWIG_fail;
39002 {
39003 arg2 = (bool)(SWIG_As_bool(obj1));
39004 if (SWIG_arg_fail(2)) SWIG_fail;
39005 }
39006 {
39007 PyThreadState* __tstate = wxPyBeginAllowThreads();
39008 (arg1)->Show(arg2);
39009
39010 wxPyEndAllowThreads(__tstate);
39011 if (PyErr_Occurred()) SWIG_fail;
39012 }
39013 Py_INCREF(Py_None); resultobj = Py_None;
39014 return resultobj;
39015 fail:
39016 return NULL;
39017 }
39018
39019
39020 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39021 PyObject *resultobj;
39022 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39023 bool result;
39024 PyObject * obj0 = 0 ;
39025 char *kwnames[] = {
39026 (char *) "self", NULL
39027 };
39028
39029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39031 if (SWIG_arg_fail(1)) SWIG_fail;
39032 {
39033 PyThreadState* __tstate = wxPyBeginAllowThreads();
39034 result = (bool)(arg1)->IsShown();
39035
39036 wxPyEndAllowThreads(__tstate);
39037 if (PyErr_Occurred()) SWIG_fail;
39038 }
39039 {
39040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39041 }
39042 return resultobj;
39043 fail:
39044 return NULL;
39045 }
39046
39047
39048 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39049 PyObject *resultobj;
39050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39051 wxPoint result;
39052 PyObject * obj0 = 0 ;
39053 char *kwnames[] = {
39054 (char *) "self", NULL
39055 };
39056
39057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39059 if (SWIG_arg_fail(1)) SWIG_fail;
39060 {
39061 PyThreadState* __tstate = wxPyBeginAllowThreads();
39062 result = (arg1)->GetPosition();
39063
39064 wxPyEndAllowThreads(__tstate);
39065 if (PyErr_Occurred()) SWIG_fail;
39066 }
39067 {
39068 wxPoint * resultptr;
39069 resultptr = new wxPoint((wxPoint &)(result));
39070 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39071 }
39072 return resultobj;
39073 fail:
39074 return NULL;
39075 }
39076
39077
39078 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39079 PyObject *resultobj;
39080 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39081 PyObject *result;
39082 PyObject * obj0 = 0 ;
39083 char *kwnames[] = {
39084 (char *) "self", NULL
39085 };
39086
39087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39089 if (SWIG_arg_fail(1)) SWIG_fail;
39090 {
39091 PyThreadState* __tstate = wxPyBeginAllowThreads();
39092 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39093
39094 wxPyEndAllowThreads(__tstate);
39095 if (PyErr_Occurred()) SWIG_fail;
39096 }
39097 resultobj = result;
39098 return resultobj;
39099 fail:
39100 return NULL;
39101 }
39102
39103
39104 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39105 PyObject *obj;
39106 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39107 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39108 Py_INCREF(obj);
39109 return Py_BuildValue((char *)"");
39110 }
39111 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39112 PyObject *resultobj;
39113 wxSizer *arg1 = (wxSizer *) 0 ;
39114 PyObject *arg2 = (PyObject *) 0 ;
39115 PyObject * obj0 = 0 ;
39116 PyObject * obj1 = 0 ;
39117 char *kwnames[] = {
39118 (char *) "self",(char *) "_self", NULL
39119 };
39120
39121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39123 if (SWIG_arg_fail(1)) SWIG_fail;
39124 arg2 = obj1;
39125 {
39126 PyThreadState* __tstate = wxPyBeginAllowThreads();
39127 wxSizer__setOORInfo(arg1,arg2);
39128
39129 wxPyEndAllowThreads(__tstate);
39130 if (PyErr_Occurred()) SWIG_fail;
39131 }
39132 Py_INCREF(Py_None); resultobj = Py_None;
39133 return resultobj;
39134 fail:
39135 return NULL;
39136 }
39137
39138
39139 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39140 PyObject *resultobj;
39141 wxSizer *arg1 = (wxSizer *) 0 ;
39142 PyObject *arg2 = (PyObject *) 0 ;
39143 int arg3 = (int) 0 ;
39144 int arg4 = (int) 0 ;
39145 int arg5 = (int) 0 ;
39146 PyObject *arg6 = (PyObject *) NULL ;
39147 wxSizerItem *result;
39148 PyObject * obj0 = 0 ;
39149 PyObject * obj1 = 0 ;
39150 PyObject * obj2 = 0 ;
39151 PyObject * obj3 = 0 ;
39152 PyObject * obj4 = 0 ;
39153 PyObject * obj5 = 0 ;
39154 char *kwnames[] = {
39155 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39156 };
39157
39158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39160 if (SWIG_arg_fail(1)) SWIG_fail;
39161 arg2 = obj1;
39162 if (obj2) {
39163 {
39164 arg3 = (int)(SWIG_As_int(obj2));
39165 if (SWIG_arg_fail(3)) SWIG_fail;
39166 }
39167 }
39168 if (obj3) {
39169 {
39170 arg4 = (int)(SWIG_As_int(obj3));
39171 if (SWIG_arg_fail(4)) SWIG_fail;
39172 }
39173 }
39174 if (obj4) {
39175 {
39176 arg5 = (int)(SWIG_As_int(obj4));
39177 if (SWIG_arg_fail(5)) SWIG_fail;
39178 }
39179 }
39180 if (obj5) {
39181 arg6 = obj5;
39182 }
39183 {
39184 PyThreadState* __tstate = wxPyBeginAllowThreads();
39185 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39186
39187 wxPyEndAllowThreads(__tstate);
39188 if (PyErr_Occurred()) SWIG_fail;
39189 }
39190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39191 return resultobj;
39192 fail:
39193 return NULL;
39194 }
39195
39196
39197 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39198 PyObject *resultobj;
39199 wxSizer *arg1 = (wxSizer *) 0 ;
39200 int arg2 ;
39201 PyObject *arg3 = (PyObject *) 0 ;
39202 int arg4 = (int) 0 ;
39203 int arg5 = (int) 0 ;
39204 int arg6 = (int) 0 ;
39205 PyObject *arg7 = (PyObject *) NULL ;
39206 wxSizerItem *result;
39207 PyObject * obj0 = 0 ;
39208 PyObject * obj1 = 0 ;
39209 PyObject * obj2 = 0 ;
39210 PyObject * obj3 = 0 ;
39211 PyObject * obj4 = 0 ;
39212 PyObject * obj5 = 0 ;
39213 PyObject * obj6 = 0 ;
39214 char *kwnames[] = {
39215 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39216 };
39217
39218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39220 if (SWIG_arg_fail(1)) SWIG_fail;
39221 {
39222 arg2 = (int)(SWIG_As_int(obj1));
39223 if (SWIG_arg_fail(2)) SWIG_fail;
39224 }
39225 arg3 = obj2;
39226 if (obj3) {
39227 {
39228 arg4 = (int)(SWIG_As_int(obj3));
39229 if (SWIG_arg_fail(4)) SWIG_fail;
39230 }
39231 }
39232 if (obj4) {
39233 {
39234 arg5 = (int)(SWIG_As_int(obj4));
39235 if (SWIG_arg_fail(5)) SWIG_fail;
39236 }
39237 }
39238 if (obj5) {
39239 {
39240 arg6 = (int)(SWIG_As_int(obj5));
39241 if (SWIG_arg_fail(6)) SWIG_fail;
39242 }
39243 }
39244 if (obj6) {
39245 arg7 = obj6;
39246 }
39247 {
39248 PyThreadState* __tstate = wxPyBeginAllowThreads();
39249 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39250
39251 wxPyEndAllowThreads(__tstate);
39252 if (PyErr_Occurred()) SWIG_fail;
39253 }
39254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39255 return resultobj;
39256 fail:
39257 return NULL;
39258 }
39259
39260
39261 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39262 PyObject *resultobj;
39263 wxSizer *arg1 = (wxSizer *) 0 ;
39264 PyObject *arg2 = (PyObject *) 0 ;
39265 int arg3 = (int) 0 ;
39266 int arg4 = (int) 0 ;
39267 int arg5 = (int) 0 ;
39268 PyObject *arg6 = (PyObject *) NULL ;
39269 wxSizerItem *result;
39270 PyObject * obj0 = 0 ;
39271 PyObject * obj1 = 0 ;
39272 PyObject * obj2 = 0 ;
39273 PyObject * obj3 = 0 ;
39274 PyObject * obj4 = 0 ;
39275 PyObject * obj5 = 0 ;
39276 char *kwnames[] = {
39277 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39278 };
39279
39280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39282 if (SWIG_arg_fail(1)) SWIG_fail;
39283 arg2 = obj1;
39284 if (obj2) {
39285 {
39286 arg3 = (int)(SWIG_As_int(obj2));
39287 if (SWIG_arg_fail(3)) SWIG_fail;
39288 }
39289 }
39290 if (obj3) {
39291 {
39292 arg4 = (int)(SWIG_As_int(obj3));
39293 if (SWIG_arg_fail(4)) SWIG_fail;
39294 }
39295 }
39296 if (obj4) {
39297 {
39298 arg5 = (int)(SWIG_As_int(obj4));
39299 if (SWIG_arg_fail(5)) SWIG_fail;
39300 }
39301 }
39302 if (obj5) {
39303 arg6 = obj5;
39304 }
39305 {
39306 PyThreadState* __tstate = wxPyBeginAllowThreads();
39307 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39308
39309 wxPyEndAllowThreads(__tstate);
39310 if (PyErr_Occurred()) SWIG_fail;
39311 }
39312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39313 return resultobj;
39314 fail:
39315 return NULL;
39316 }
39317
39318
39319 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39320 PyObject *resultobj;
39321 wxSizer *arg1 = (wxSizer *) 0 ;
39322 PyObject *arg2 = (PyObject *) 0 ;
39323 bool result;
39324 PyObject * obj0 = 0 ;
39325 PyObject * obj1 = 0 ;
39326 char *kwnames[] = {
39327 (char *) "self",(char *) "item", NULL
39328 };
39329
39330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39332 if (SWIG_arg_fail(1)) SWIG_fail;
39333 arg2 = obj1;
39334 {
39335 PyThreadState* __tstate = wxPyBeginAllowThreads();
39336 result = (bool)wxSizer_Remove(arg1,arg2);
39337
39338 wxPyEndAllowThreads(__tstate);
39339 if (PyErr_Occurred()) SWIG_fail;
39340 }
39341 {
39342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39343 }
39344 return resultobj;
39345 fail:
39346 return NULL;
39347 }
39348
39349
39350 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39351 PyObject *resultobj;
39352 wxSizer *arg1 = (wxSizer *) 0 ;
39353 PyObject *arg2 = (PyObject *) 0 ;
39354 bool result;
39355 PyObject * obj0 = 0 ;
39356 PyObject * obj1 = 0 ;
39357 char *kwnames[] = {
39358 (char *) "self",(char *) "item", NULL
39359 };
39360
39361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39363 if (SWIG_arg_fail(1)) SWIG_fail;
39364 arg2 = obj1;
39365 {
39366 PyThreadState* __tstate = wxPyBeginAllowThreads();
39367 result = (bool)wxSizer_Detach(arg1,arg2);
39368
39369 wxPyEndAllowThreads(__tstate);
39370 if (PyErr_Occurred()) SWIG_fail;
39371 }
39372 {
39373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39374 }
39375 return resultobj;
39376 fail:
39377 return NULL;
39378 }
39379
39380
39381 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39382 PyObject *resultobj;
39383 wxSizer *arg1 = (wxSizer *) 0 ;
39384 PyObject *arg2 = (PyObject *) 0 ;
39385 wxSizerItem *result;
39386 PyObject * obj0 = 0 ;
39387 PyObject * obj1 = 0 ;
39388 char *kwnames[] = {
39389 (char *) "self",(char *) "item", NULL
39390 };
39391
39392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39394 if (SWIG_arg_fail(1)) SWIG_fail;
39395 arg2 = obj1;
39396 {
39397 PyThreadState* __tstate = wxPyBeginAllowThreads();
39398 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39399
39400 wxPyEndAllowThreads(__tstate);
39401 if (PyErr_Occurred()) SWIG_fail;
39402 }
39403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39404 return resultobj;
39405 fail:
39406 return NULL;
39407 }
39408
39409
39410 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39411 PyObject *resultobj;
39412 wxSizer *arg1 = (wxSizer *) 0 ;
39413 PyObject *arg2 = (PyObject *) 0 ;
39414 wxSize *arg3 = 0 ;
39415 wxSize temp3 ;
39416 PyObject * obj0 = 0 ;
39417 PyObject * obj1 = 0 ;
39418 PyObject * obj2 = 0 ;
39419 char *kwnames[] = {
39420 (char *) "self",(char *) "item",(char *) "size", NULL
39421 };
39422
39423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39425 if (SWIG_arg_fail(1)) SWIG_fail;
39426 arg2 = obj1;
39427 {
39428 arg3 = &temp3;
39429 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39430 }
39431 {
39432 PyThreadState* __tstate = wxPyBeginAllowThreads();
39433 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39434
39435 wxPyEndAllowThreads(__tstate);
39436 if (PyErr_Occurred()) SWIG_fail;
39437 }
39438 Py_INCREF(Py_None); resultobj = Py_None;
39439 return resultobj;
39440 fail:
39441 return NULL;
39442 }
39443
39444
39445 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39446 PyObject *resultobj;
39447 wxSizer *arg1 = (wxSizer *) 0 ;
39448 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39449 wxSizerItem *result;
39450 PyObject * obj0 = 0 ;
39451 PyObject * obj1 = 0 ;
39452 char *kwnames[] = {
39453 (char *) "self",(char *) "item", NULL
39454 };
39455
39456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39458 if (SWIG_arg_fail(1)) SWIG_fail;
39459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39460 if (SWIG_arg_fail(2)) SWIG_fail;
39461 {
39462 PyThreadState* __tstate = wxPyBeginAllowThreads();
39463 result = (wxSizerItem *)(arg1)->Add(arg2);
39464
39465 wxPyEndAllowThreads(__tstate);
39466 if (PyErr_Occurred()) SWIG_fail;
39467 }
39468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39469 return resultobj;
39470 fail:
39471 return NULL;
39472 }
39473
39474
39475 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39476 PyObject *resultobj;
39477 wxSizer *arg1 = (wxSizer *) 0 ;
39478 size_t arg2 ;
39479 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39480 wxSizerItem *result;
39481 PyObject * obj0 = 0 ;
39482 PyObject * obj1 = 0 ;
39483 PyObject * obj2 = 0 ;
39484 char *kwnames[] = {
39485 (char *) "self",(char *) "index",(char *) "item", NULL
39486 };
39487
39488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39490 if (SWIG_arg_fail(1)) SWIG_fail;
39491 {
39492 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39493 if (SWIG_arg_fail(2)) SWIG_fail;
39494 }
39495 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39496 if (SWIG_arg_fail(3)) SWIG_fail;
39497 {
39498 PyThreadState* __tstate = wxPyBeginAllowThreads();
39499 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39500
39501 wxPyEndAllowThreads(__tstate);
39502 if (PyErr_Occurred()) SWIG_fail;
39503 }
39504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39505 return resultobj;
39506 fail:
39507 return NULL;
39508 }
39509
39510
39511 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39512 PyObject *resultobj;
39513 wxSizer *arg1 = (wxSizer *) 0 ;
39514 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39515 wxSizerItem *result;
39516 PyObject * obj0 = 0 ;
39517 PyObject * obj1 = 0 ;
39518 char *kwnames[] = {
39519 (char *) "self",(char *) "item", NULL
39520 };
39521
39522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39524 if (SWIG_arg_fail(1)) SWIG_fail;
39525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39526 if (SWIG_arg_fail(2)) SWIG_fail;
39527 {
39528 PyThreadState* __tstate = wxPyBeginAllowThreads();
39529 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39530
39531 wxPyEndAllowThreads(__tstate);
39532 if (PyErr_Occurred()) SWIG_fail;
39533 }
39534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39535 return resultobj;
39536 fail:
39537 return NULL;
39538 }
39539
39540
39541 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39542 PyObject *resultobj;
39543 wxSizer *arg1 = (wxSizer *) 0 ;
39544 int arg2 ;
39545 int arg3 ;
39546 int arg4 ;
39547 int arg5 ;
39548 PyObject * obj0 = 0 ;
39549 PyObject * obj1 = 0 ;
39550 PyObject * obj2 = 0 ;
39551 PyObject * obj3 = 0 ;
39552 PyObject * obj4 = 0 ;
39553 char *kwnames[] = {
39554 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39555 };
39556
39557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39559 if (SWIG_arg_fail(1)) SWIG_fail;
39560 {
39561 arg2 = (int)(SWIG_As_int(obj1));
39562 if (SWIG_arg_fail(2)) SWIG_fail;
39563 }
39564 {
39565 arg3 = (int)(SWIG_As_int(obj2));
39566 if (SWIG_arg_fail(3)) SWIG_fail;
39567 }
39568 {
39569 arg4 = (int)(SWIG_As_int(obj3));
39570 if (SWIG_arg_fail(4)) SWIG_fail;
39571 }
39572 {
39573 arg5 = (int)(SWIG_As_int(obj4));
39574 if (SWIG_arg_fail(5)) SWIG_fail;
39575 }
39576 {
39577 PyThreadState* __tstate = wxPyBeginAllowThreads();
39578 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39579
39580 wxPyEndAllowThreads(__tstate);
39581 if (PyErr_Occurred()) SWIG_fail;
39582 }
39583 Py_INCREF(Py_None); resultobj = Py_None;
39584 return resultobj;
39585 fail:
39586 return NULL;
39587 }
39588
39589
39590 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39591 PyObject *resultobj;
39592 wxSizer *arg1 = (wxSizer *) 0 ;
39593 wxSize *arg2 = 0 ;
39594 wxSize temp2 ;
39595 PyObject * obj0 = 0 ;
39596 PyObject * obj1 = 0 ;
39597 char *kwnames[] = {
39598 (char *) "self",(char *) "size", NULL
39599 };
39600
39601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39603 if (SWIG_arg_fail(1)) SWIG_fail;
39604 {
39605 arg2 = &temp2;
39606 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39607 }
39608 {
39609 PyThreadState* __tstate = wxPyBeginAllowThreads();
39610 (arg1)->SetMinSize((wxSize const &)*arg2);
39611
39612 wxPyEndAllowThreads(__tstate);
39613 if (PyErr_Occurred()) SWIG_fail;
39614 }
39615 Py_INCREF(Py_None); resultobj = Py_None;
39616 return resultobj;
39617 fail:
39618 return NULL;
39619 }
39620
39621
39622 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39623 PyObject *resultobj;
39624 wxSizer *arg1 = (wxSizer *) 0 ;
39625 wxSize result;
39626 PyObject * obj0 = 0 ;
39627 char *kwnames[] = {
39628 (char *) "self", NULL
39629 };
39630
39631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39633 if (SWIG_arg_fail(1)) SWIG_fail;
39634 {
39635 PyThreadState* __tstate = wxPyBeginAllowThreads();
39636 result = (arg1)->GetSize();
39637
39638 wxPyEndAllowThreads(__tstate);
39639 if (PyErr_Occurred()) SWIG_fail;
39640 }
39641 {
39642 wxSize * resultptr;
39643 resultptr = new wxSize((wxSize &)(result));
39644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39645 }
39646 return resultobj;
39647 fail:
39648 return NULL;
39649 }
39650
39651
39652 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39653 PyObject *resultobj;
39654 wxSizer *arg1 = (wxSizer *) 0 ;
39655 wxPoint result;
39656 PyObject * obj0 = 0 ;
39657 char *kwnames[] = {
39658 (char *) "self", NULL
39659 };
39660
39661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39663 if (SWIG_arg_fail(1)) SWIG_fail;
39664 {
39665 PyThreadState* __tstate = wxPyBeginAllowThreads();
39666 result = (arg1)->GetPosition();
39667
39668 wxPyEndAllowThreads(__tstate);
39669 if (PyErr_Occurred()) SWIG_fail;
39670 }
39671 {
39672 wxPoint * resultptr;
39673 resultptr = new wxPoint((wxPoint &)(result));
39674 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39675 }
39676 return resultobj;
39677 fail:
39678 return NULL;
39679 }
39680
39681
39682 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39683 PyObject *resultobj;
39684 wxSizer *arg1 = (wxSizer *) 0 ;
39685 wxSize result;
39686 PyObject * obj0 = 0 ;
39687 char *kwnames[] = {
39688 (char *) "self", NULL
39689 };
39690
39691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39693 if (SWIG_arg_fail(1)) SWIG_fail;
39694 {
39695 PyThreadState* __tstate = wxPyBeginAllowThreads();
39696 result = (arg1)->GetMinSize();
39697
39698 wxPyEndAllowThreads(__tstate);
39699 if (PyErr_Occurred()) SWIG_fail;
39700 }
39701 {
39702 wxSize * resultptr;
39703 resultptr = new wxSize((wxSize &)(result));
39704 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39705 }
39706 return resultobj;
39707 fail:
39708 return NULL;
39709 }
39710
39711
39712 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39713 PyObject *resultobj;
39714 wxSizer *arg1 = (wxSizer *) 0 ;
39715 PyObject * obj0 = 0 ;
39716 char *kwnames[] = {
39717 (char *) "self", NULL
39718 };
39719
39720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39722 if (SWIG_arg_fail(1)) SWIG_fail;
39723 {
39724 PyThreadState* __tstate = wxPyBeginAllowThreads();
39725 (arg1)->RecalcSizes();
39726
39727 wxPyEndAllowThreads(__tstate);
39728 if (PyErr_Occurred()) SWIG_fail;
39729 }
39730 Py_INCREF(Py_None); resultobj = Py_None;
39731 return resultobj;
39732 fail:
39733 return NULL;
39734 }
39735
39736
39737 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39738 PyObject *resultobj;
39739 wxSizer *arg1 = (wxSizer *) 0 ;
39740 wxSize result;
39741 PyObject * obj0 = 0 ;
39742 char *kwnames[] = {
39743 (char *) "self", NULL
39744 };
39745
39746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39748 if (SWIG_arg_fail(1)) SWIG_fail;
39749 {
39750 PyThreadState* __tstate = wxPyBeginAllowThreads();
39751 result = (arg1)->CalcMin();
39752
39753 wxPyEndAllowThreads(__tstate);
39754 if (PyErr_Occurred()) SWIG_fail;
39755 }
39756 {
39757 wxSize * resultptr;
39758 resultptr = new wxSize((wxSize &)(result));
39759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39760 }
39761 return resultobj;
39762 fail:
39763 return NULL;
39764 }
39765
39766
39767 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39768 PyObject *resultobj;
39769 wxSizer *arg1 = (wxSizer *) 0 ;
39770 PyObject * obj0 = 0 ;
39771 char *kwnames[] = {
39772 (char *) "self", NULL
39773 };
39774
39775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39777 if (SWIG_arg_fail(1)) SWIG_fail;
39778 {
39779 PyThreadState* __tstate = wxPyBeginAllowThreads();
39780 (arg1)->Layout();
39781
39782 wxPyEndAllowThreads(__tstate);
39783 if (PyErr_Occurred()) SWIG_fail;
39784 }
39785 Py_INCREF(Py_None); resultobj = Py_None;
39786 return resultobj;
39787 fail:
39788 return NULL;
39789 }
39790
39791
39792 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39793 PyObject *resultobj;
39794 wxSizer *arg1 = (wxSizer *) 0 ;
39795 wxWindow *arg2 = (wxWindow *) 0 ;
39796 wxSize result;
39797 PyObject * obj0 = 0 ;
39798 PyObject * obj1 = 0 ;
39799 char *kwnames[] = {
39800 (char *) "self",(char *) "window", NULL
39801 };
39802
39803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39805 if (SWIG_arg_fail(1)) SWIG_fail;
39806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39807 if (SWIG_arg_fail(2)) SWIG_fail;
39808 {
39809 PyThreadState* __tstate = wxPyBeginAllowThreads();
39810 result = (arg1)->Fit(arg2);
39811
39812 wxPyEndAllowThreads(__tstate);
39813 if (PyErr_Occurred()) SWIG_fail;
39814 }
39815 {
39816 wxSize * resultptr;
39817 resultptr = new wxSize((wxSize &)(result));
39818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39819 }
39820 return resultobj;
39821 fail:
39822 return NULL;
39823 }
39824
39825
39826 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39827 PyObject *resultobj;
39828 wxSizer *arg1 = (wxSizer *) 0 ;
39829 wxWindow *arg2 = (wxWindow *) 0 ;
39830 PyObject * obj0 = 0 ;
39831 PyObject * obj1 = 0 ;
39832 char *kwnames[] = {
39833 (char *) "self",(char *) "window", NULL
39834 };
39835
39836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39838 if (SWIG_arg_fail(1)) SWIG_fail;
39839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39840 if (SWIG_arg_fail(2)) SWIG_fail;
39841 {
39842 PyThreadState* __tstate = wxPyBeginAllowThreads();
39843 (arg1)->FitInside(arg2);
39844
39845 wxPyEndAllowThreads(__tstate);
39846 if (PyErr_Occurred()) SWIG_fail;
39847 }
39848 Py_INCREF(Py_None); resultobj = Py_None;
39849 return resultobj;
39850 fail:
39851 return NULL;
39852 }
39853
39854
39855 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39856 PyObject *resultobj;
39857 wxSizer *arg1 = (wxSizer *) 0 ;
39858 wxWindow *arg2 = (wxWindow *) 0 ;
39859 PyObject * obj0 = 0 ;
39860 PyObject * obj1 = 0 ;
39861 char *kwnames[] = {
39862 (char *) "self",(char *) "window", NULL
39863 };
39864
39865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39867 if (SWIG_arg_fail(1)) SWIG_fail;
39868 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39869 if (SWIG_arg_fail(2)) SWIG_fail;
39870 {
39871 PyThreadState* __tstate = wxPyBeginAllowThreads();
39872 (arg1)->SetSizeHints(arg2);
39873
39874 wxPyEndAllowThreads(__tstate);
39875 if (PyErr_Occurred()) SWIG_fail;
39876 }
39877 Py_INCREF(Py_None); resultobj = Py_None;
39878 return resultobj;
39879 fail:
39880 return NULL;
39881 }
39882
39883
39884 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39885 PyObject *resultobj;
39886 wxSizer *arg1 = (wxSizer *) 0 ;
39887 wxWindow *arg2 = (wxWindow *) 0 ;
39888 PyObject * obj0 = 0 ;
39889 PyObject * obj1 = 0 ;
39890 char *kwnames[] = {
39891 (char *) "self",(char *) "window", NULL
39892 };
39893
39894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39896 if (SWIG_arg_fail(1)) SWIG_fail;
39897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39898 if (SWIG_arg_fail(2)) SWIG_fail;
39899 {
39900 PyThreadState* __tstate = wxPyBeginAllowThreads();
39901 (arg1)->SetVirtualSizeHints(arg2);
39902
39903 wxPyEndAllowThreads(__tstate);
39904 if (PyErr_Occurred()) SWIG_fail;
39905 }
39906 Py_INCREF(Py_None); resultobj = Py_None;
39907 return resultobj;
39908 fail:
39909 return NULL;
39910 }
39911
39912
39913 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39914 PyObject *resultobj;
39915 wxSizer *arg1 = (wxSizer *) 0 ;
39916 bool arg2 = (bool) false ;
39917 PyObject * obj0 = 0 ;
39918 PyObject * obj1 = 0 ;
39919 char *kwnames[] = {
39920 (char *) "self",(char *) "deleteWindows", NULL
39921 };
39922
39923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39925 if (SWIG_arg_fail(1)) SWIG_fail;
39926 if (obj1) {
39927 {
39928 arg2 = (bool)(SWIG_As_bool(obj1));
39929 if (SWIG_arg_fail(2)) SWIG_fail;
39930 }
39931 }
39932 {
39933 PyThreadState* __tstate = wxPyBeginAllowThreads();
39934 (arg1)->Clear(arg2);
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_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj;
39948 wxSizer *arg1 = (wxSizer *) 0 ;
39949 PyObject * obj0 = 0 ;
39950 char *kwnames[] = {
39951 (char *) "self", NULL
39952 };
39953
39954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39956 if (SWIG_arg_fail(1)) SWIG_fail;
39957 {
39958 PyThreadState* __tstate = wxPyBeginAllowThreads();
39959 (arg1)->DeleteWindows();
39960
39961 wxPyEndAllowThreads(__tstate);
39962 if (PyErr_Occurred()) SWIG_fail;
39963 }
39964 Py_INCREF(Py_None); resultobj = Py_None;
39965 return resultobj;
39966 fail:
39967 return NULL;
39968 }
39969
39970
39971 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39972 PyObject *resultobj;
39973 wxSizer *arg1 = (wxSizer *) 0 ;
39974 PyObject *result;
39975 PyObject * obj0 = 0 ;
39976 char *kwnames[] = {
39977 (char *) "self", NULL
39978 };
39979
39980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39982 if (SWIG_arg_fail(1)) SWIG_fail;
39983 {
39984 PyThreadState* __tstate = wxPyBeginAllowThreads();
39985 result = (PyObject *)wxSizer_GetChildren(arg1);
39986
39987 wxPyEndAllowThreads(__tstate);
39988 if (PyErr_Occurred()) SWIG_fail;
39989 }
39990 resultobj = result;
39991 return resultobj;
39992 fail:
39993 return NULL;
39994 }
39995
39996
39997 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39998 PyObject *resultobj;
39999 wxSizer *arg1 = (wxSizer *) 0 ;
40000 PyObject *arg2 = (PyObject *) 0 ;
40001 bool arg3 = (bool) true ;
40002 bool arg4 = (bool) false ;
40003 bool result;
40004 PyObject * obj0 = 0 ;
40005 PyObject * obj1 = 0 ;
40006 PyObject * obj2 = 0 ;
40007 PyObject * obj3 = 0 ;
40008 char *kwnames[] = {
40009 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40010 };
40011
40012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40014 if (SWIG_arg_fail(1)) SWIG_fail;
40015 arg2 = obj1;
40016 if (obj2) {
40017 {
40018 arg3 = (bool)(SWIG_As_bool(obj2));
40019 if (SWIG_arg_fail(3)) SWIG_fail;
40020 }
40021 }
40022 if (obj3) {
40023 {
40024 arg4 = (bool)(SWIG_As_bool(obj3));
40025 if (SWIG_arg_fail(4)) SWIG_fail;
40026 }
40027 }
40028 {
40029 PyThreadState* __tstate = wxPyBeginAllowThreads();
40030 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40031
40032 wxPyEndAllowThreads(__tstate);
40033 if (PyErr_Occurred()) SWIG_fail;
40034 }
40035 {
40036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40037 }
40038 return resultobj;
40039 fail:
40040 return NULL;
40041 }
40042
40043
40044 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40045 PyObject *resultobj;
40046 wxSizer *arg1 = (wxSizer *) 0 ;
40047 PyObject *arg2 = (PyObject *) 0 ;
40048 bool result;
40049 PyObject * obj0 = 0 ;
40050 PyObject * obj1 = 0 ;
40051 char *kwnames[] = {
40052 (char *) "self",(char *) "item", NULL
40053 };
40054
40055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40057 if (SWIG_arg_fail(1)) SWIG_fail;
40058 arg2 = obj1;
40059 {
40060 PyThreadState* __tstate = wxPyBeginAllowThreads();
40061 result = (bool)wxSizer_IsShown(arg1,arg2);
40062
40063 wxPyEndAllowThreads(__tstate);
40064 if (PyErr_Occurred()) SWIG_fail;
40065 }
40066 {
40067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40068 }
40069 return resultobj;
40070 fail:
40071 return NULL;
40072 }
40073
40074
40075 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40076 PyObject *resultobj;
40077 wxSizer *arg1 = (wxSizer *) 0 ;
40078 bool arg2 ;
40079 PyObject * obj0 = 0 ;
40080 PyObject * obj1 = 0 ;
40081 char *kwnames[] = {
40082 (char *) "self",(char *) "show", NULL
40083 };
40084
40085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40087 if (SWIG_arg_fail(1)) SWIG_fail;
40088 {
40089 arg2 = (bool)(SWIG_As_bool(obj1));
40090 if (SWIG_arg_fail(2)) SWIG_fail;
40091 }
40092 {
40093 PyThreadState* __tstate = wxPyBeginAllowThreads();
40094 (arg1)->ShowItems(arg2);
40095
40096 wxPyEndAllowThreads(__tstate);
40097 if (PyErr_Occurred()) SWIG_fail;
40098 }
40099 Py_INCREF(Py_None); resultobj = Py_None;
40100 return resultobj;
40101 fail:
40102 return NULL;
40103 }
40104
40105
40106 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40107 PyObject *obj;
40108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40109 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40110 Py_INCREF(obj);
40111 return Py_BuildValue((char *)"");
40112 }
40113 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40114 PyObject *resultobj;
40115 wxPySizer *result;
40116 char *kwnames[] = {
40117 NULL
40118 };
40119
40120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40121 {
40122 PyThreadState* __tstate = wxPyBeginAllowThreads();
40123 result = (wxPySizer *)new wxPySizer();
40124
40125 wxPyEndAllowThreads(__tstate);
40126 if (PyErr_Occurred()) SWIG_fail;
40127 }
40128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40129 return resultobj;
40130 fail:
40131 return NULL;
40132 }
40133
40134
40135 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40136 PyObject *resultobj;
40137 wxPySizer *arg1 = (wxPySizer *) 0 ;
40138 PyObject *arg2 = (PyObject *) 0 ;
40139 PyObject *arg3 = (PyObject *) 0 ;
40140 PyObject * obj0 = 0 ;
40141 PyObject * obj1 = 0 ;
40142 PyObject * obj2 = 0 ;
40143 char *kwnames[] = {
40144 (char *) "self",(char *) "self",(char *) "_class", NULL
40145 };
40146
40147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40149 if (SWIG_arg_fail(1)) SWIG_fail;
40150 arg2 = obj1;
40151 arg3 = obj2;
40152 {
40153 PyThreadState* __tstate = wxPyBeginAllowThreads();
40154 (arg1)->_setCallbackInfo(arg2,arg3);
40155
40156 wxPyEndAllowThreads(__tstate);
40157 if (PyErr_Occurred()) SWIG_fail;
40158 }
40159 Py_INCREF(Py_None); resultobj = Py_None;
40160 return resultobj;
40161 fail:
40162 return NULL;
40163 }
40164
40165
40166 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40167 PyObject *obj;
40168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40169 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40170 Py_INCREF(obj);
40171 return Py_BuildValue((char *)"");
40172 }
40173 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40174 PyObject *resultobj;
40175 int arg1 = (int) wxHORIZONTAL ;
40176 wxBoxSizer *result;
40177 PyObject * obj0 = 0 ;
40178 char *kwnames[] = {
40179 (char *) "orient", NULL
40180 };
40181
40182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40183 if (obj0) {
40184 {
40185 arg1 = (int)(SWIG_As_int(obj0));
40186 if (SWIG_arg_fail(1)) SWIG_fail;
40187 }
40188 }
40189 {
40190 PyThreadState* __tstate = wxPyBeginAllowThreads();
40191 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40192
40193 wxPyEndAllowThreads(__tstate);
40194 if (PyErr_Occurred()) SWIG_fail;
40195 }
40196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40197 return resultobj;
40198 fail:
40199 return NULL;
40200 }
40201
40202
40203 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40204 PyObject *resultobj;
40205 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40206 int result;
40207 PyObject * obj0 = 0 ;
40208 char *kwnames[] = {
40209 (char *) "self", NULL
40210 };
40211
40212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40214 if (SWIG_arg_fail(1)) SWIG_fail;
40215 {
40216 PyThreadState* __tstate = wxPyBeginAllowThreads();
40217 result = (int)(arg1)->GetOrientation();
40218
40219 wxPyEndAllowThreads(__tstate);
40220 if (PyErr_Occurred()) SWIG_fail;
40221 }
40222 {
40223 resultobj = SWIG_From_int((int)(result));
40224 }
40225 return resultobj;
40226 fail:
40227 return NULL;
40228 }
40229
40230
40231 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40232 PyObject *resultobj;
40233 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40234 int arg2 ;
40235 PyObject * obj0 = 0 ;
40236 PyObject * obj1 = 0 ;
40237 char *kwnames[] = {
40238 (char *) "self",(char *) "orient", NULL
40239 };
40240
40241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40243 if (SWIG_arg_fail(1)) SWIG_fail;
40244 {
40245 arg2 = (int)(SWIG_As_int(obj1));
40246 if (SWIG_arg_fail(2)) SWIG_fail;
40247 }
40248 {
40249 PyThreadState* __tstate = wxPyBeginAllowThreads();
40250 (arg1)->SetOrientation(arg2);
40251
40252 wxPyEndAllowThreads(__tstate);
40253 if (PyErr_Occurred()) SWIG_fail;
40254 }
40255 Py_INCREF(Py_None); resultobj = Py_None;
40256 return resultobj;
40257 fail:
40258 return NULL;
40259 }
40260
40261
40262 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40263 PyObject *obj;
40264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40265 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40266 Py_INCREF(obj);
40267 return Py_BuildValue((char *)"");
40268 }
40269 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40270 PyObject *resultobj;
40271 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40272 int arg2 = (int) wxHORIZONTAL ;
40273 wxStaticBoxSizer *result;
40274 PyObject * obj0 = 0 ;
40275 PyObject * obj1 = 0 ;
40276 char *kwnames[] = {
40277 (char *) "box",(char *) "orient", NULL
40278 };
40279
40280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40282 if (SWIG_arg_fail(1)) SWIG_fail;
40283 if (obj1) {
40284 {
40285 arg2 = (int)(SWIG_As_int(obj1));
40286 if (SWIG_arg_fail(2)) SWIG_fail;
40287 }
40288 }
40289 {
40290 PyThreadState* __tstate = wxPyBeginAllowThreads();
40291 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40292
40293 wxPyEndAllowThreads(__tstate);
40294 if (PyErr_Occurred()) SWIG_fail;
40295 }
40296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40297 return resultobj;
40298 fail:
40299 return NULL;
40300 }
40301
40302
40303 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40304 PyObject *resultobj;
40305 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40306 wxStaticBox *result;
40307 PyObject * obj0 = 0 ;
40308 char *kwnames[] = {
40309 (char *) "self", NULL
40310 };
40311
40312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40314 if (SWIG_arg_fail(1)) SWIG_fail;
40315 {
40316 PyThreadState* __tstate = wxPyBeginAllowThreads();
40317 result = (wxStaticBox *)(arg1)->GetStaticBox();
40318
40319 wxPyEndAllowThreads(__tstate);
40320 if (PyErr_Occurred()) SWIG_fail;
40321 }
40322 {
40323 resultobj = wxPyMake_wxObject(result, 0);
40324 }
40325 return resultobj;
40326 fail:
40327 return NULL;
40328 }
40329
40330
40331 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40332 PyObject *obj;
40333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40334 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40335 Py_INCREF(obj);
40336 return Py_BuildValue((char *)"");
40337 }
40338 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40339 PyObject *resultobj;
40340 int arg1 = (int) 1 ;
40341 int arg2 = (int) 0 ;
40342 int arg3 = (int) 0 ;
40343 int arg4 = (int) 0 ;
40344 wxGridSizer *result;
40345 PyObject * obj0 = 0 ;
40346 PyObject * obj1 = 0 ;
40347 PyObject * obj2 = 0 ;
40348 PyObject * obj3 = 0 ;
40349 char *kwnames[] = {
40350 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40351 };
40352
40353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40354 if (obj0) {
40355 {
40356 arg1 = (int)(SWIG_As_int(obj0));
40357 if (SWIG_arg_fail(1)) SWIG_fail;
40358 }
40359 }
40360 if (obj1) {
40361 {
40362 arg2 = (int)(SWIG_As_int(obj1));
40363 if (SWIG_arg_fail(2)) SWIG_fail;
40364 }
40365 }
40366 if (obj2) {
40367 {
40368 arg3 = (int)(SWIG_As_int(obj2));
40369 if (SWIG_arg_fail(3)) SWIG_fail;
40370 }
40371 }
40372 if (obj3) {
40373 {
40374 arg4 = (int)(SWIG_As_int(obj3));
40375 if (SWIG_arg_fail(4)) SWIG_fail;
40376 }
40377 }
40378 {
40379 PyThreadState* __tstate = wxPyBeginAllowThreads();
40380 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40381
40382 wxPyEndAllowThreads(__tstate);
40383 if (PyErr_Occurred()) SWIG_fail;
40384 }
40385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40386 return resultobj;
40387 fail:
40388 return NULL;
40389 }
40390
40391
40392 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40393 PyObject *resultobj;
40394 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40395 int arg2 ;
40396 PyObject * obj0 = 0 ;
40397 PyObject * obj1 = 0 ;
40398 char *kwnames[] = {
40399 (char *) "self",(char *) "cols", NULL
40400 };
40401
40402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40404 if (SWIG_arg_fail(1)) SWIG_fail;
40405 {
40406 arg2 = (int)(SWIG_As_int(obj1));
40407 if (SWIG_arg_fail(2)) SWIG_fail;
40408 }
40409 {
40410 PyThreadState* __tstate = wxPyBeginAllowThreads();
40411 (arg1)->SetCols(arg2);
40412
40413 wxPyEndAllowThreads(__tstate);
40414 if (PyErr_Occurred()) SWIG_fail;
40415 }
40416 Py_INCREF(Py_None); resultobj = Py_None;
40417 return resultobj;
40418 fail:
40419 return NULL;
40420 }
40421
40422
40423 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40424 PyObject *resultobj;
40425 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40426 int arg2 ;
40427 PyObject * obj0 = 0 ;
40428 PyObject * obj1 = 0 ;
40429 char *kwnames[] = {
40430 (char *) "self",(char *) "rows", NULL
40431 };
40432
40433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40435 if (SWIG_arg_fail(1)) SWIG_fail;
40436 {
40437 arg2 = (int)(SWIG_As_int(obj1));
40438 if (SWIG_arg_fail(2)) SWIG_fail;
40439 }
40440 {
40441 PyThreadState* __tstate = wxPyBeginAllowThreads();
40442 (arg1)->SetRows(arg2);
40443
40444 wxPyEndAllowThreads(__tstate);
40445 if (PyErr_Occurred()) SWIG_fail;
40446 }
40447 Py_INCREF(Py_None); resultobj = Py_None;
40448 return resultobj;
40449 fail:
40450 return NULL;
40451 }
40452
40453
40454 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40455 PyObject *resultobj;
40456 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40457 int arg2 ;
40458 PyObject * obj0 = 0 ;
40459 PyObject * obj1 = 0 ;
40460 char *kwnames[] = {
40461 (char *) "self",(char *) "gap", NULL
40462 };
40463
40464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40466 if (SWIG_arg_fail(1)) SWIG_fail;
40467 {
40468 arg2 = (int)(SWIG_As_int(obj1));
40469 if (SWIG_arg_fail(2)) SWIG_fail;
40470 }
40471 {
40472 PyThreadState* __tstate = wxPyBeginAllowThreads();
40473 (arg1)->SetVGap(arg2);
40474
40475 wxPyEndAllowThreads(__tstate);
40476 if (PyErr_Occurred()) SWIG_fail;
40477 }
40478 Py_INCREF(Py_None); resultobj = Py_None;
40479 return resultobj;
40480 fail:
40481 return NULL;
40482 }
40483
40484
40485 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40486 PyObject *resultobj;
40487 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40488 int arg2 ;
40489 PyObject * obj0 = 0 ;
40490 PyObject * obj1 = 0 ;
40491 char *kwnames[] = {
40492 (char *) "self",(char *) "gap", NULL
40493 };
40494
40495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40497 if (SWIG_arg_fail(1)) SWIG_fail;
40498 {
40499 arg2 = (int)(SWIG_As_int(obj1));
40500 if (SWIG_arg_fail(2)) SWIG_fail;
40501 }
40502 {
40503 PyThreadState* __tstate = wxPyBeginAllowThreads();
40504 (arg1)->SetHGap(arg2);
40505
40506 wxPyEndAllowThreads(__tstate);
40507 if (PyErr_Occurred()) SWIG_fail;
40508 }
40509 Py_INCREF(Py_None); resultobj = Py_None;
40510 return resultobj;
40511 fail:
40512 return NULL;
40513 }
40514
40515
40516 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40517 PyObject *resultobj;
40518 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40519 int result;
40520 PyObject * obj0 = 0 ;
40521 char *kwnames[] = {
40522 (char *) "self", NULL
40523 };
40524
40525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40527 if (SWIG_arg_fail(1)) SWIG_fail;
40528 {
40529 PyThreadState* __tstate = wxPyBeginAllowThreads();
40530 result = (int)(arg1)->GetCols();
40531
40532 wxPyEndAllowThreads(__tstate);
40533 if (PyErr_Occurred()) SWIG_fail;
40534 }
40535 {
40536 resultobj = SWIG_From_int((int)(result));
40537 }
40538 return resultobj;
40539 fail:
40540 return NULL;
40541 }
40542
40543
40544 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40545 PyObject *resultobj;
40546 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40547 int result;
40548 PyObject * obj0 = 0 ;
40549 char *kwnames[] = {
40550 (char *) "self", NULL
40551 };
40552
40553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40555 if (SWIG_arg_fail(1)) SWIG_fail;
40556 {
40557 PyThreadState* __tstate = wxPyBeginAllowThreads();
40558 result = (int)(arg1)->GetRows();
40559
40560 wxPyEndAllowThreads(__tstate);
40561 if (PyErr_Occurred()) SWIG_fail;
40562 }
40563 {
40564 resultobj = SWIG_From_int((int)(result));
40565 }
40566 return resultobj;
40567 fail:
40568 return NULL;
40569 }
40570
40571
40572 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40573 PyObject *resultobj;
40574 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40575 int result;
40576 PyObject * obj0 = 0 ;
40577 char *kwnames[] = {
40578 (char *) "self", NULL
40579 };
40580
40581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40583 if (SWIG_arg_fail(1)) SWIG_fail;
40584 {
40585 PyThreadState* __tstate = wxPyBeginAllowThreads();
40586 result = (int)(arg1)->GetVGap();
40587
40588 wxPyEndAllowThreads(__tstate);
40589 if (PyErr_Occurred()) SWIG_fail;
40590 }
40591 {
40592 resultobj = SWIG_From_int((int)(result));
40593 }
40594 return resultobj;
40595 fail:
40596 return NULL;
40597 }
40598
40599
40600 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40601 PyObject *resultobj;
40602 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40603 int result;
40604 PyObject * obj0 = 0 ;
40605 char *kwnames[] = {
40606 (char *) "self", NULL
40607 };
40608
40609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40611 if (SWIG_arg_fail(1)) SWIG_fail;
40612 {
40613 PyThreadState* __tstate = wxPyBeginAllowThreads();
40614 result = (int)(arg1)->GetHGap();
40615
40616 wxPyEndAllowThreads(__tstate);
40617 if (PyErr_Occurred()) SWIG_fail;
40618 }
40619 {
40620 resultobj = SWIG_From_int((int)(result));
40621 }
40622 return resultobj;
40623 fail:
40624 return NULL;
40625 }
40626
40627
40628 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40629 PyObject *obj;
40630 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40631 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40632 Py_INCREF(obj);
40633 return Py_BuildValue((char *)"");
40634 }
40635 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40636 PyObject *resultobj;
40637 int arg1 = (int) 1 ;
40638 int arg2 = (int) 0 ;
40639 int arg3 = (int) 0 ;
40640 int arg4 = (int) 0 ;
40641 wxFlexGridSizer *result;
40642 PyObject * obj0 = 0 ;
40643 PyObject * obj1 = 0 ;
40644 PyObject * obj2 = 0 ;
40645 PyObject * obj3 = 0 ;
40646 char *kwnames[] = {
40647 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40648 };
40649
40650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40651 if (obj0) {
40652 {
40653 arg1 = (int)(SWIG_As_int(obj0));
40654 if (SWIG_arg_fail(1)) SWIG_fail;
40655 }
40656 }
40657 if (obj1) {
40658 {
40659 arg2 = (int)(SWIG_As_int(obj1));
40660 if (SWIG_arg_fail(2)) SWIG_fail;
40661 }
40662 }
40663 if (obj2) {
40664 {
40665 arg3 = (int)(SWIG_As_int(obj2));
40666 if (SWIG_arg_fail(3)) SWIG_fail;
40667 }
40668 }
40669 if (obj3) {
40670 {
40671 arg4 = (int)(SWIG_As_int(obj3));
40672 if (SWIG_arg_fail(4)) SWIG_fail;
40673 }
40674 }
40675 {
40676 PyThreadState* __tstate = wxPyBeginAllowThreads();
40677 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40678
40679 wxPyEndAllowThreads(__tstate);
40680 if (PyErr_Occurred()) SWIG_fail;
40681 }
40682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40683 return resultobj;
40684 fail:
40685 return NULL;
40686 }
40687
40688
40689 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40690 PyObject *resultobj;
40691 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40692 size_t arg2 ;
40693 int arg3 = (int) 0 ;
40694 PyObject * obj0 = 0 ;
40695 PyObject * obj1 = 0 ;
40696 PyObject * obj2 = 0 ;
40697 char *kwnames[] = {
40698 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40699 };
40700
40701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40703 if (SWIG_arg_fail(1)) SWIG_fail;
40704 {
40705 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40706 if (SWIG_arg_fail(2)) SWIG_fail;
40707 }
40708 if (obj2) {
40709 {
40710 arg3 = (int)(SWIG_As_int(obj2));
40711 if (SWIG_arg_fail(3)) SWIG_fail;
40712 }
40713 }
40714 {
40715 PyThreadState* __tstate = wxPyBeginAllowThreads();
40716 (arg1)->AddGrowableRow(arg2,arg3);
40717
40718 wxPyEndAllowThreads(__tstate);
40719 if (PyErr_Occurred()) SWIG_fail;
40720 }
40721 Py_INCREF(Py_None); resultobj = Py_None;
40722 return resultobj;
40723 fail:
40724 return NULL;
40725 }
40726
40727
40728 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40729 PyObject *resultobj;
40730 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40731 size_t arg2 ;
40732 PyObject * obj0 = 0 ;
40733 PyObject * obj1 = 0 ;
40734 char *kwnames[] = {
40735 (char *) "self",(char *) "idx", NULL
40736 };
40737
40738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40740 if (SWIG_arg_fail(1)) SWIG_fail;
40741 {
40742 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40743 if (SWIG_arg_fail(2)) SWIG_fail;
40744 }
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 (arg1)->RemoveGrowableRow(arg2);
40748
40749 wxPyEndAllowThreads(__tstate);
40750 if (PyErr_Occurred()) SWIG_fail;
40751 }
40752 Py_INCREF(Py_None); resultobj = Py_None;
40753 return resultobj;
40754 fail:
40755 return NULL;
40756 }
40757
40758
40759 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40760 PyObject *resultobj;
40761 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40762 size_t arg2 ;
40763 int arg3 = (int) 0 ;
40764 PyObject * obj0 = 0 ;
40765 PyObject * obj1 = 0 ;
40766 PyObject * obj2 = 0 ;
40767 char *kwnames[] = {
40768 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40769 };
40770
40771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40773 if (SWIG_arg_fail(1)) SWIG_fail;
40774 {
40775 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40776 if (SWIG_arg_fail(2)) SWIG_fail;
40777 }
40778 if (obj2) {
40779 {
40780 arg3 = (int)(SWIG_As_int(obj2));
40781 if (SWIG_arg_fail(3)) SWIG_fail;
40782 }
40783 }
40784 {
40785 PyThreadState* __tstate = wxPyBeginAllowThreads();
40786 (arg1)->AddGrowableCol(arg2,arg3);
40787
40788 wxPyEndAllowThreads(__tstate);
40789 if (PyErr_Occurred()) SWIG_fail;
40790 }
40791 Py_INCREF(Py_None); resultobj = Py_None;
40792 return resultobj;
40793 fail:
40794 return NULL;
40795 }
40796
40797
40798 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40799 PyObject *resultobj;
40800 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40801 size_t arg2 ;
40802 PyObject * obj0 = 0 ;
40803 PyObject * obj1 = 0 ;
40804 char *kwnames[] = {
40805 (char *) "self",(char *) "idx", NULL
40806 };
40807
40808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40810 if (SWIG_arg_fail(1)) SWIG_fail;
40811 {
40812 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40813 if (SWIG_arg_fail(2)) SWIG_fail;
40814 }
40815 {
40816 PyThreadState* __tstate = wxPyBeginAllowThreads();
40817 (arg1)->RemoveGrowableCol(arg2);
40818
40819 wxPyEndAllowThreads(__tstate);
40820 if (PyErr_Occurred()) SWIG_fail;
40821 }
40822 Py_INCREF(Py_None); resultobj = Py_None;
40823 return resultobj;
40824 fail:
40825 return NULL;
40826 }
40827
40828
40829 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40830 PyObject *resultobj;
40831 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40832 int arg2 ;
40833 PyObject * obj0 = 0 ;
40834 PyObject * obj1 = 0 ;
40835 char *kwnames[] = {
40836 (char *) "self",(char *) "direction", NULL
40837 };
40838
40839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40841 if (SWIG_arg_fail(1)) SWIG_fail;
40842 {
40843 arg2 = (int)(SWIG_As_int(obj1));
40844 if (SWIG_arg_fail(2)) SWIG_fail;
40845 }
40846 {
40847 PyThreadState* __tstate = wxPyBeginAllowThreads();
40848 (arg1)->SetFlexibleDirection(arg2);
40849
40850 wxPyEndAllowThreads(__tstate);
40851 if (PyErr_Occurred()) SWIG_fail;
40852 }
40853 Py_INCREF(Py_None); resultobj = Py_None;
40854 return resultobj;
40855 fail:
40856 return NULL;
40857 }
40858
40859
40860 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40861 PyObject *resultobj;
40862 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40863 int result;
40864 PyObject * obj0 = 0 ;
40865 char *kwnames[] = {
40866 (char *) "self", NULL
40867 };
40868
40869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40871 if (SWIG_arg_fail(1)) SWIG_fail;
40872 {
40873 PyThreadState* __tstate = wxPyBeginAllowThreads();
40874 result = (int)(arg1)->GetFlexibleDirection();
40875
40876 wxPyEndAllowThreads(__tstate);
40877 if (PyErr_Occurred()) SWIG_fail;
40878 }
40879 {
40880 resultobj = SWIG_From_int((int)(result));
40881 }
40882 return resultobj;
40883 fail:
40884 return NULL;
40885 }
40886
40887
40888 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40889 PyObject *resultobj;
40890 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40891 wxFlexSizerGrowMode arg2 ;
40892 PyObject * obj0 = 0 ;
40893 PyObject * obj1 = 0 ;
40894 char *kwnames[] = {
40895 (char *) "self",(char *) "mode", NULL
40896 };
40897
40898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40900 if (SWIG_arg_fail(1)) SWIG_fail;
40901 {
40902 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40903 if (SWIG_arg_fail(2)) SWIG_fail;
40904 }
40905 {
40906 PyThreadState* __tstate = wxPyBeginAllowThreads();
40907 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40908
40909 wxPyEndAllowThreads(__tstate);
40910 if (PyErr_Occurred()) SWIG_fail;
40911 }
40912 Py_INCREF(Py_None); resultobj = Py_None;
40913 return resultobj;
40914 fail:
40915 return NULL;
40916 }
40917
40918
40919 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40920 PyObject *resultobj;
40921 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40922 wxFlexSizerGrowMode result;
40923 PyObject * obj0 = 0 ;
40924 char *kwnames[] = {
40925 (char *) "self", NULL
40926 };
40927
40928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40930 if (SWIG_arg_fail(1)) SWIG_fail;
40931 {
40932 PyThreadState* __tstate = wxPyBeginAllowThreads();
40933 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40934
40935 wxPyEndAllowThreads(__tstate);
40936 if (PyErr_Occurred()) SWIG_fail;
40937 }
40938 resultobj = SWIG_From_int((result));
40939 return resultobj;
40940 fail:
40941 return NULL;
40942 }
40943
40944
40945 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40946 PyObject *resultobj;
40947 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40948 wxArrayInt *result;
40949 PyObject * obj0 = 0 ;
40950 char *kwnames[] = {
40951 (char *) "self", NULL
40952 };
40953
40954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40956 if (SWIG_arg_fail(1)) SWIG_fail;
40957 {
40958 PyThreadState* __tstate = wxPyBeginAllowThreads();
40959 {
40960 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40961 result = (wxArrayInt *) &_result_ref;
40962 }
40963
40964 wxPyEndAllowThreads(__tstate);
40965 if (PyErr_Occurred()) SWIG_fail;
40966 }
40967 {
40968 resultobj = PyList_New(0);
40969 size_t idx;
40970 for (idx = 0; idx < result->GetCount(); idx += 1) {
40971 PyObject* val = PyInt_FromLong( result->Item(idx) );
40972 PyList_Append(resultobj, val);
40973 Py_DECREF(val);
40974 }
40975 }
40976 return resultobj;
40977 fail:
40978 return NULL;
40979 }
40980
40981
40982 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40983 PyObject *resultobj;
40984 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40985 wxArrayInt *result;
40986 PyObject * obj0 = 0 ;
40987 char *kwnames[] = {
40988 (char *) "self", NULL
40989 };
40990
40991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40993 if (SWIG_arg_fail(1)) SWIG_fail;
40994 {
40995 PyThreadState* __tstate = wxPyBeginAllowThreads();
40996 {
40997 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40998 result = (wxArrayInt *) &_result_ref;
40999 }
41000
41001 wxPyEndAllowThreads(__tstate);
41002 if (PyErr_Occurred()) SWIG_fail;
41003 }
41004 {
41005 resultobj = PyList_New(0);
41006 size_t idx;
41007 for (idx = 0; idx < result->GetCount(); idx += 1) {
41008 PyObject* val = PyInt_FromLong( result->Item(idx) );
41009 PyList_Append(resultobj, val);
41010 Py_DECREF(val);
41011 }
41012 }
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41020 PyObject *obj;
41021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41022 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41023 Py_INCREF(obj);
41024 return Py_BuildValue((char *)"");
41025 }
41026 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41027 PyObject *resultobj;
41028 wxStdDialogButtonSizer *result;
41029 char *kwnames[] = {
41030 NULL
41031 };
41032
41033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41034 {
41035 PyThreadState* __tstate = wxPyBeginAllowThreads();
41036 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41037
41038 wxPyEndAllowThreads(__tstate);
41039 if (PyErr_Occurred()) SWIG_fail;
41040 }
41041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41042 return resultobj;
41043 fail:
41044 return NULL;
41045 }
41046
41047
41048 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41049 PyObject *resultobj;
41050 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41051 wxButton *arg2 = (wxButton *) 0 ;
41052 PyObject * obj0 = 0 ;
41053 PyObject * obj1 = 0 ;
41054 char *kwnames[] = {
41055 (char *) "self",(char *) "button", NULL
41056 };
41057
41058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41060 if (SWIG_arg_fail(1)) SWIG_fail;
41061 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41062 if (SWIG_arg_fail(2)) SWIG_fail;
41063 {
41064 PyThreadState* __tstate = wxPyBeginAllowThreads();
41065 (arg1)->AddButton(arg2);
41066
41067 wxPyEndAllowThreads(__tstate);
41068 if (PyErr_Occurred()) SWIG_fail;
41069 }
41070 Py_INCREF(Py_None); resultobj = Py_None;
41071 return resultobj;
41072 fail:
41073 return NULL;
41074 }
41075
41076
41077 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41078 PyObject *resultobj;
41079 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41080 PyObject * obj0 = 0 ;
41081 char *kwnames[] = {
41082 (char *) "self", NULL
41083 };
41084
41085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41087 if (SWIG_arg_fail(1)) SWIG_fail;
41088 {
41089 PyThreadState* __tstate = wxPyBeginAllowThreads();
41090 (arg1)->Realize();
41091
41092 wxPyEndAllowThreads(__tstate);
41093 if (PyErr_Occurred()) SWIG_fail;
41094 }
41095 Py_INCREF(Py_None); resultobj = Py_None;
41096 return resultobj;
41097 fail:
41098 return NULL;
41099 }
41100
41101
41102 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41103 PyObject *resultobj;
41104 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41105 wxButton *arg2 = (wxButton *) 0 ;
41106 PyObject * obj0 = 0 ;
41107 PyObject * obj1 = 0 ;
41108 char *kwnames[] = {
41109 (char *) "self",(char *) "button", NULL
41110 };
41111
41112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41114 if (SWIG_arg_fail(1)) SWIG_fail;
41115 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41116 if (SWIG_arg_fail(2)) SWIG_fail;
41117 {
41118 PyThreadState* __tstate = wxPyBeginAllowThreads();
41119 (arg1)->SetAffirmativeButton(arg2);
41120
41121 wxPyEndAllowThreads(__tstate);
41122 if (PyErr_Occurred()) SWIG_fail;
41123 }
41124 Py_INCREF(Py_None); resultobj = Py_None;
41125 return resultobj;
41126 fail:
41127 return NULL;
41128 }
41129
41130
41131 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41132 PyObject *resultobj;
41133 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41134 wxButton *arg2 = (wxButton *) 0 ;
41135 PyObject * obj0 = 0 ;
41136 PyObject * obj1 = 0 ;
41137 char *kwnames[] = {
41138 (char *) "self",(char *) "button", NULL
41139 };
41140
41141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41143 if (SWIG_arg_fail(1)) SWIG_fail;
41144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41145 if (SWIG_arg_fail(2)) SWIG_fail;
41146 {
41147 PyThreadState* __tstate = wxPyBeginAllowThreads();
41148 (arg1)->SetNegativeButton(arg2);
41149
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 Py_INCREF(Py_None); resultobj = Py_None;
41154 return resultobj;
41155 fail:
41156 return NULL;
41157 }
41158
41159
41160 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41161 PyObject *resultobj;
41162 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41163 wxButton *arg2 = (wxButton *) 0 ;
41164 PyObject * obj0 = 0 ;
41165 PyObject * obj1 = 0 ;
41166 char *kwnames[] = {
41167 (char *) "self",(char *) "button", NULL
41168 };
41169
41170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41172 if (SWIG_arg_fail(1)) SWIG_fail;
41173 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41174 if (SWIG_arg_fail(2)) SWIG_fail;
41175 {
41176 PyThreadState* __tstate = wxPyBeginAllowThreads();
41177 (arg1)->SetCancelButton(arg2);
41178
41179 wxPyEndAllowThreads(__tstate);
41180 if (PyErr_Occurred()) SWIG_fail;
41181 }
41182 Py_INCREF(Py_None); resultobj = Py_None;
41183 return resultobj;
41184 fail:
41185 return NULL;
41186 }
41187
41188
41189 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41190 PyObject *resultobj;
41191 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41192 wxButton *result;
41193 PyObject * obj0 = 0 ;
41194 char *kwnames[] = {
41195 (char *) "self", NULL
41196 };
41197
41198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41200 if (SWIG_arg_fail(1)) SWIG_fail;
41201 {
41202 PyThreadState* __tstate = wxPyBeginAllowThreads();
41203 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41204
41205 wxPyEndAllowThreads(__tstate);
41206 if (PyErr_Occurred()) SWIG_fail;
41207 }
41208 {
41209 resultobj = wxPyMake_wxObject(result, 0);
41210 }
41211 return resultobj;
41212 fail:
41213 return NULL;
41214 }
41215
41216
41217 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41218 PyObject *resultobj;
41219 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41220 wxButton *result;
41221 PyObject * obj0 = 0 ;
41222 char *kwnames[] = {
41223 (char *) "self", NULL
41224 };
41225
41226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41228 if (SWIG_arg_fail(1)) SWIG_fail;
41229 {
41230 PyThreadState* __tstate = wxPyBeginAllowThreads();
41231 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41232
41233 wxPyEndAllowThreads(__tstate);
41234 if (PyErr_Occurred()) SWIG_fail;
41235 }
41236 {
41237 resultobj = wxPyMake_wxObject(result, 0);
41238 }
41239 return resultobj;
41240 fail:
41241 return NULL;
41242 }
41243
41244
41245 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41246 PyObject *resultobj;
41247 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41248 wxButton *result;
41249 PyObject * obj0 = 0 ;
41250 char *kwnames[] = {
41251 (char *) "self", NULL
41252 };
41253
41254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41256 if (SWIG_arg_fail(1)) SWIG_fail;
41257 {
41258 PyThreadState* __tstate = wxPyBeginAllowThreads();
41259 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41260
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 {
41265 resultobj = wxPyMake_wxObject(result, 0);
41266 }
41267 return resultobj;
41268 fail:
41269 return NULL;
41270 }
41271
41272
41273 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41274 PyObject *resultobj;
41275 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41276 wxButton *result;
41277 PyObject * obj0 = 0 ;
41278 char *kwnames[] = {
41279 (char *) "self", NULL
41280 };
41281
41282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41284 if (SWIG_arg_fail(1)) SWIG_fail;
41285 {
41286 PyThreadState* __tstate = wxPyBeginAllowThreads();
41287 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41288
41289 wxPyEndAllowThreads(__tstate);
41290 if (PyErr_Occurred()) SWIG_fail;
41291 }
41292 {
41293 resultobj = wxPyMake_wxObject(result, 0);
41294 }
41295 return resultobj;
41296 fail:
41297 return NULL;
41298 }
41299
41300
41301 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41302 PyObject *resultobj;
41303 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41304 wxButton *result;
41305 PyObject * obj0 = 0 ;
41306 char *kwnames[] = {
41307 (char *) "self", NULL
41308 };
41309
41310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41312 if (SWIG_arg_fail(1)) SWIG_fail;
41313 {
41314 PyThreadState* __tstate = wxPyBeginAllowThreads();
41315 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41316
41317 wxPyEndAllowThreads(__tstate);
41318 if (PyErr_Occurred()) SWIG_fail;
41319 }
41320 {
41321 resultobj = wxPyMake_wxObject(result, 0);
41322 }
41323 return resultobj;
41324 fail:
41325 return NULL;
41326 }
41327
41328
41329 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41330 PyObject *obj;
41331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41332 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41333 Py_INCREF(obj);
41334 return Py_BuildValue((char *)"");
41335 }
41336 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41337 PyObject *resultobj;
41338 int arg1 = (int) 0 ;
41339 int arg2 = (int) 0 ;
41340 wxGBPosition *result;
41341 PyObject * obj0 = 0 ;
41342 PyObject * obj1 = 0 ;
41343 char *kwnames[] = {
41344 (char *) "row",(char *) "col", NULL
41345 };
41346
41347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41348 if (obj0) {
41349 {
41350 arg1 = (int)(SWIG_As_int(obj0));
41351 if (SWIG_arg_fail(1)) SWIG_fail;
41352 }
41353 }
41354 if (obj1) {
41355 {
41356 arg2 = (int)(SWIG_As_int(obj1));
41357 if (SWIG_arg_fail(2)) SWIG_fail;
41358 }
41359 }
41360 {
41361 PyThreadState* __tstate = wxPyBeginAllowThreads();
41362 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41363
41364 wxPyEndAllowThreads(__tstate);
41365 if (PyErr_Occurred()) SWIG_fail;
41366 }
41367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41368 return resultobj;
41369 fail:
41370 return NULL;
41371 }
41372
41373
41374 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41375 PyObject *resultobj;
41376 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41377 int result;
41378 PyObject * obj0 = 0 ;
41379 char *kwnames[] = {
41380 (char *) "self", NULL
41381 };
41382
41383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41385 if (SWIG_arg_fail(1)) SWIG_fail;
41386 {
41387 PyThreadState* __tstate = wxPyBeginAllowThreads();
41388 result = (int)((wxGBPosition const *)arg1)->GetRow();
41389
41390 wxPyEndAllowThreads(__tstate);
41391 if (PyErr_Occurred()) SWIG_fail;
41392 }
41393 {
41394 resultobj = SWIG_From_int((int)(result));
41395 }
41396 return resultobj;
41397 fail:
41398 return NULL;
41399 }
41400
41401
41402 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41403 PyObject *resultobj;
41404 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41405 int result;
41406 PyObject * obj0 = 0 ;
41407 char *kwnames[] = {
41408 (char *) "self", NULL
41409 };
41410
41411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41413 if (SWIG_arg_fail(1)) SWIG_fail;
41414 {
41415 PyThreadState* __tstate = wxPyBeginAllowThreads();
41416 result = (int)((wxGBPosition const *)arg1)->GetCol();
41417
41418 wxPyEndAllowThreads(__tstate);
41419 if (PyErr_Occurred()) SWIG_fail;
41420 }
41421 {
41422 resultobj = SWIG_From_int((int)(result));
41423 }
41424 return resultobj;
41425 fail:
41426 return NULL;
41427 }
41428
41429
41430 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41431 PyObject *resultobj;
41432 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41433 int arg2 ;
41434 PyObject * obj0 = 0 ;
41435 PyObject * obj1 = 0 ;
41436 char *kwnames[] = {
41437 (char *) "self",(char *) "row", NULL
41438 };
41439
41440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41442 if (SWIG_arg_fail(1)) SWIG_fail;
41443 {
41444 arg2 = (int)(SWIG_As_int(obj1));
41445 if (SWIG_arg_fail(2)) SWIG_fail;
41446 }
41447 {
41448 PyThreadState* __tstate = wxPyBeginAllowThreads();
41449 (arg1)->SetRow(arg2);
41450
41451 wxPyEndAllowThreads(__tstate);
41452 if (PyErr_Occurred()) SWIG_fail;
41453 }
41454 Py_INCREF(Py_None); resultobj = Py_None;
41455 return resultobj;
41456 fail:
41457 return NULL;
41458 }
41459
41460
41461 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41462 PyObject *resultobj;
41463 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41464 int arg2 ;
41465 PyObject * obj0 = 0 ;
41466 PyObject * obj1 = 0 ;
41467 char *kwnames[] = {
41468 (char *) "self",(char *) "col", NULL
41469 };
41470
41471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41473 if (SWIG_arg_fail(1)) SWIG_fail;
41474 {
41475 arg2 = (int)(SWIG_As_int(obj1));
41476 if (SWIG_arg_fail(2)) SWIG_fail;
41477 }
41478 {
41479 PyThreadState* __tstate = wxPyBeginAllowThreads();
41480 (arg1)->SetCol(arg2);
41481
41482 wxPyEndAllowThreads(__tstate);
41483 if (PyErr_Occurred()) SWIG_fail;
41484 }
41485 Py_INCREF(Py_None); resultobj = Py_None;
41486 return resultobj;
41487 fail:
41488 return NULL;
41489 }
41490
41491
41492 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41493 PyObject *resultobj;
41494 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41495 wxGBPosition *arg2 = 0 ;
41496 bool result;
41497 wxGBPosition temp2 ;
41498 PyObject * obj0 = 0 ;
41499 PyObject * obj1 = 0 ;
41500 char *kwnames[] = {
41501 (char *) "self",(char *) "other", NULL
41502 };
41503
41504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41506 if (SWIG_arg_fail(1)) SWIG_fail;
41507 {
41508 arg2 = &temp2;
41509 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41510 }
41511 {
41512 PyThreadState* __tstate = wxPyBeginAllowThreads();
41513 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41514
41515 wxPyEndAllowThreads(__tstate);
41516 if (PyErr_Occurred()) SWIG_fail;
41517 }
41518 {
41519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41520 }
41521 return resultobj;
41522 fail:
41523 return NULL;
41524 }
41525
41526
41527 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41528 PyObject *resultobj;
41529 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41530 wxGBPosition *arg2 = 0 ;
41531 bool result;
41532 wxGBPosition temp2 ;
41533 PyObject * obj0 = 0 ;
41534 PyObject * obj1 = 0 ;
41535 char *kwnames[] = {
41536 (char *) "self",(char *) "other", NULL
41537 };
41538
41539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41541 if (SWIG_arg_fail(1)) SWIG_fail;
41542 {
41543 arg2 = &temp2;
41544 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41545 }
41546 {
41547 PyThreadState* __tstate = wxPyBeginAllowThreads();
41548 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41549
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 {
41554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41555 }
41556 return resultobj;
41557 fail:
41558 return NULL;
41559 }
41560
41561
41562 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41563 PyObject *resultobj;
41564 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41565 int arg2 = (int) 0 ;
41566 int arg3 = (int) 0 ;
41567 PyObject * obj0 = 0 ;
41568 PyObject * obj1 = 0 ;
41569 PyObject * obj2 = 0 ;
41570 char *kwnames[] = {
41571 (char *) "self",(char *) "row",(char *) "col", NULL
41572 };
41573
41574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41576 if (SWIG_arg_fail(1)) SWIG_fail;
41577 if (obj1) {
41578 {
41579 arg2 = (int)(SWIG_As_int(obj1));
41580 if (SWIG_arg_fail(2)) SWIG_fail;
41581 }
41582 }
41583 if (obj2) {
41584 {
41585 arg3 = (int)(SWIG_As_int(obj2));
41586 if (SWIG_arg_fail(3)) SWIG_fail;
41587 }
41588 }
41589 {
41590 PyThreadState* __tstate = wxPyBeginAllowThreads();
41591 wxGBPosition_Set(arg1,arg2,arg3);
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_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41604 PyObject *resultobj;
41605 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41606 PyObject *result;
41607 PyObject * obj0 = 0 ;
41608 char *kwnames[] = {
41609 (char *) "self", NULL
41610 };
41611
41612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41614 if (SWIG_arg_fail(1)) SWIG_fail;
41615 {
41616 PyThreadState* __tstate = wxPyBeginAllowThreads();
41617 result = (PyObject *)wxGBPosition_Get(arg1);
41618
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 resultobj = result;
41623 return resultobj;
41624 fail:
41625 return NULL;
41626 }
41627
41628
41629 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41630 PyObject *obj;
41631 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41632 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41633 Py_INCREF(obj);
41634 return Py_BuildValue((char *)"");
41635 }
41636 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41637 PyObject *resultobj;
41638 int arg1 = (int) 1 ;
41639 int arg2 = (int) 1 ;
41640 wxGBSpan *result;
41641 PyObject * obj0 = 0 ;
41642 PyObject * obj1 = 0 ;
41643 char *kwnames[] = {
41644 (char *) "rowspan",(char *) "colspan", NULL
41645 };
41646
41647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41648 if (obj0) {
41649 {
41650 arg1 = (int)(SWIG_As_int(obj0));
41651 if (SWIG_arg_fail(1)) SWIG_fail;
41652 }
41653 }
41654 if (obj1) {
41655 {
41656 arg2 = (int)(SWIG_As_int(obj1));
41657 if (SWIG_arg_fail(2)) SWIG_fail;
41658 }
41659 }
41660 {
41661 PyThreadState* __tstate = wxPyBeginAllowThreads();
41662 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41663
41664 wxPyEndAllowThreads(__tstate);
41665 if (PyErr_Occurred()) SWIG_fail;
41666 }
41667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41668 return resultobj;
41669 fail:
41670 return NULL;
41671 }
41672
41673
41674 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41675 PyObject *resultobj;
41676 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41677 int result;
41678 PyObject * obj0 = 0 ;
41679 char *kwnames[] = {
41680 (char *) "self", NULL
41681 };
41682
41683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41685 if (SWIG_arg_fail(1)) SWIG_fail;
41686 {
41687 PyThreadState* __tstate = wxPyBeginAllowThreads();
41688 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41689
41690 wxPyEndAllowThreads(__tstate);
41691 if (PyErr_Occurred()) SWIG_fail;
41692 }
41693 {
41694 resultobj = SWIG_From_int((int)(result));
41695 }
41696 return resultobj;
41697 fail:
41698 return NULL;
41699 }
41700
41701
41702 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41703 PyObject *resultobj;
41704 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41705 int result;
41706 PyObject * obj0 = 0 ;
41707 char *kwnames[] = {
41708 (char *) "self", NULL
41709 };
41710
41711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41713 if (SWIG_arg_fail(1)) SWIG_fail;
41714 {
41715 PyThreadState* __tstate = wxPyBeginAllowThreads();
41716 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41717
41718 wxPyEndAllowThreads(__tstate);
41719 if (PyErr_Occurred()) SWIG_fail;
41720 }
41721 {
41722 resultobj = SWIG_From_int((int)(result));
41723 }
41724 return resultobj;
41725 fail:
41726 return NULL;
41727 }
41728
41729
41730 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41731 PyObject *resultobj;
41732 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41733 int arg2 ;
41734 PyObject * obj0 = 0 ;
41735 PyObject * obj1 = 0 ;
41736 char *kwnames[] = {
41737 (char *) "self",(char *) "rowspan", NULL
41738 };
41739
41740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41742 if (SWIG_arg_fail(1)) SWIG_fail;
41743 {
41744 arg2 = (int)(SWIG_As_int(obj1));
41745 if (SWIG_arg_fail(2)) SWIG_fail;
41746 }
41747 {
41748 PyThreadState* __tstate = wxPyBeginAllowThreads();
41749 (arg1)->SetRowspan(arg2);
41750
41751 wxPyEndAllowThreads(__tstate);
41752 if (PyErr_Occurred()) SWIG_fail;
41753 }
41754 Py_INCREF(Py_None); resultobj = Py_None;
41755 return resultobj;
41756 fail:
41757 return NULL;
41758 }
41759
41760
41761 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41762 PyObject *resultobj;
41763 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41764 int arg2 ;
41765 PyObject * obj0 = 0 ;
41766 PyObject * obj1 = 0 ;
41767 char *kwnames[] = {
41768 (char *) "self",(char *) "colspan", NULL
41769 };
41770
41771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41773 if (SWIG_arg_fail(1)) SWIG_fail;
41774 {
41775 arg2 = (int)(SWIG_As_int(obj1));
41776 if (SWIG_arg_fail(2)) SWIG_fail;
41777 }
41778 {
41779 PyThreadState* __tstate = wxPyBeginAllowThreads();
41780 (arg1)->SetColspan(arg2);
41781
41782 wxPyEndAllowThreads(__tstate);
41783 if (PyErr_Occurred()) SWIG_fail;
41784 }
41785 Py_INCREF(Py_None); resultobj = Py_None;
41786 return resultobj;
41787 fail:
41788 return NULL;
41789 }
41790
41791
41792 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41793 PyObject *resultobj;
41794 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41795 wxGBSpan *arg2 = 0 ;
41796 bool result;
41797 wxGBSpan temp2 ;
41798 PyObject * obj0 = 0 ;
41799 PyObject * obj1 = 0 ;
41800 char *kwnames[] = {
41801 (char *) "self",(char *) "other", NULL
41802 };
41803
41804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41806 if (SWIG_arg_fail(1)) SWIG_fail;
41807 {
41808 arg2 = &temp2;
41809 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41810 }
41811 {
41812 PyThreadState* __tstate = wxPyBeginAllowThreads();
41813 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41814
41815 wxPyEndAllowThreads(__tstate);
41816 if (PyErr_Occurred()) SWIG_fail;
41817 }
41818 {
41819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41820 }
41821 return resultobj;
41822 fail:
41823 return NULL;
41824 }
41825
41826
41827 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41828 PyObject *resultobj;
41829 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41830 wxGBSpan *arg2 = 0 ;
41831 bool result;
41832 wxGBSpan temp2 ;
41833 PyObject * obj0 = 0 ;
41834 PyObject * obj1 = 0 ;
41835 char *kwnames[] = {
41836 (char *) "self",(char *) "other", NULL
41837 };
41838
41839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41841 if (SWIG_arg_fail(1)) SWIG_fail;
41842 {
41843 arg2 = &temp2;
41844 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41845 }
41846 {
41847 PyThreadState* __tstate = wxPyBeginAllowThreads();
41848 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41849
41850 wxPyEndAllowThreads(__tstate);
41851 if (PyErr_Occurred()) SWIG_fail;
41852 }
41853 {
41854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41855 }
41856 return resultobj;
41857 fail:
41858 return NULL;
41859 }
41860
41861
41862 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41863 PyObject *resultobj;
41864 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41865 int arg2 = (int) 1 ;
41866 int arg3 = (int) 1 ;
41867 PyObject * obj0 = 0 ;
41868 PyObject * obj1 = 0 ;
41869 PyObject * obj2 = 0 ;
41870 char *kwnames[] = {
41871 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41872 };
41873
41874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41876 if (SWIG_arg_fail(1)) SWIG_fail;
41877 if (obj1) {
41878 {
41879 arg2 = (int)(SWIG_As_int(obj1));
41880 if (SWIG_arg_fail(2)) SWIG_fail;
41881 }
41882 }
41883 if (obj2) {
41884 {
41885 arg3 = (int)(SWIG_As_int(obj2));
41886 if (SWIG_arg_fail(3)) SWIG_fail;
41887 }
41888 }
41889 {
41890 PyThreadState* __tstate = wxPyBeginAllowThreads();
41891 wxGBSpan_Set(arg1,arg2,arg3);
41892
41893 wxPyEndAllowThreads(__tstate);
41894 if (PyErr_Occurred()) SWIG_fail;
41895 }
41896 Py_INCREF(Py_None); resultobj = Py_None;
41897 return resultobj;
41898 fail:
41899 return NULL;
41900 }
41901
41902
41903 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41904 PyObject *resultobj;
41905 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41906 PyObject *result;
41907 PyObject * obj0 = 0 ;
41908 char *kwnames[] = {
41909 (char *) "self", NULL
41910 };
41911
41912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41914 if (SWIG_arg_fail(1)) SWIG_fail;
41915 {
41916 PyThreadState* __tstate = wxPyBeginAllowThreads();
41917 result = (PyObject *)wxGBSpan_Get(arg1);
41918
41919 wxPyEndAllowThreads(__tstate);
41920 if (PyErr_Occurred()) SWIG_fail;
41921 }
41922 resultobj = result;
41923 return resultobj;
41924 fail:
41925 return NULL;
41926 }
41927
41928
41929 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41930 PyObject *obj;
41931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41932 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41933 Py_INCREF(obj);
41934 return Py_BuildValue((char *)"");
41935 }
41936 static int _wrap_DefaultSpan_set(PyObject *) {
41937 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41938 return 1;
41939 }
41940
41941
41942 static PyObject *_wrap_DefaultSpan_get(void) {
41943 PyObject *pyobj;
41944
41945 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41946 return pyobj;
41947 }
41948
41949
41950 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41951 PyObject *resultobj;
41952 wxGBSizerItem *result;
41953 char *kwnames[] = {
41954 NULL
41955 };
41956
41957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41958 {
41959 PyThreadState* __tstate = wxPyBeginAllowThreads();
41960 result = (wxGBSizerItem *)new wxGBSizerItem();
41961
41962 wxPyEndAllowThreads(__tstate);
41963 if (PyErr_Occurred()) SWIG_fail;
41964 }
41965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41966 return resultobj;
41967 fail:
41968 return NULL;
41969 }
41970
41971
41972 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41973 PyObject *resultobj;
41974 wxWindow *arg1 = (wxWindow *) 0 ;
41975 wxGBPosition *arg2 = 0 ;
41976 wxGBSpan *arg3 = 0 ;
41977 int arg4 ;
41978 int arg5 ;
41979 PyObject *arg6 = (PyObject *) NULL ;
41980 wxGBSizerItem *result;
41981 wxGBPosition temp2 ;
41982 wxGBSpan temp3 ;
41983 PyObject * obj0 = 0 ;
41984 PyObject * obj1 = 0 ;
41985 PyObject * obj2 = 0 ;
41986 PyObject * obj3 = 0 ;
41987 PyObject * obj4 = 0 ;
41988 PyObject * obj5 = 0 ;
41989 char *kwnames[] = {
41990 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41991 };
41992
41993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41995 if (SWIG_arg_fail(1)) SWIG_fail;
41996 {
41997 arg2 = &temp2;
41998 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41999 }
42000 {
42001 arg3 = &temp3;
42002 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42003 }
42004 {
42005 arg4 = (int)(SWIG_As_int(obj3));
42006 if (SWIG_arg_fail(4)) SWIG_fail;
42007 }
42008 {
42009 arg5 = (int)(SWIG_As_int(obj4));
42010 if (SWIG_arg_fail(5)) SWIG_fail;
42011 }
42012 if (obj5) {
42013 arg6 = obj5;
42014 }
42015 {
42016 PyThreadState* __tstate = wxPyBeginAllowThreads();
42017 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42018
42019 wxPyEndAllowThreads(__tstate);
42020 if (PyErr_Occurred()) SWIG_fail;
42021 }
42022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42023 return resultobj;
42024 fail:
42025 return NULL;
42026 }
42027
42028
42029 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42030 PyObject *resultobj;
42031 wxSizer *arg1 = (wxSizer *) 0 ;
42032 wxGBPosition *arg2 = 0 ;
42033 wxGBSpan *arg3 = 0 ;
42034 int arg4 ;
42035 int arg5 ;
42036 PyObject *arg6 = (PyObject *) NULL ;
42037 wxGBSizerItem *result;
42038 wxGBPosition temp2 ;
42039 wxGBSpan temp3 ;
42040 PyObject * obj0 = 0 ;
42041 PyObject * obj1 = 0 ;
42042 PyObject * obj2 = 0 ;
42043 PyObject * obj3 = 0 ;
42044 PyObject * obj4 = 0 ;
42045 PyObject * obj5 = 0 ;
42046 char *kwnames[] = {
42047 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42048 };
42049
42050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42052 if (SWIG_arg_fail(1)) SWIG_fail;
42053 {
42054 arg2 = &temp2;
42055 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42056 }
42057 {
42058 arg3 = &temp3;
42059 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42060 }
42061 {
42062 arg4 = (int)(SWIG_As_int(obj3));
42063 if (SWIG_arg_fail(4)) SWIG_fail;
42064 }
42065 {
42066 arg5 = (int)(SWIG_As_int(obj4));
42067 if (SWIG_arg_fail(5)) SWIG_fail;
42068 }
42069 if (obj5) {
42070 arg6 = obj5;
42071 }
42072 {
42073 PyThreadState* __tstate = wxPyBeginAllowThreads();
42074 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42075
42076 wxPyEndAllowThreads(__tstate);
42077 if (PyErr_Occurred()) SWIG_fail;
42078 }
42079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42080 return resultobj;
42081 fail:
42082 return NULL;
42083 }
42084
42085
42086 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42087 PyObject *resultobj;
42088 int arg1 ;
42089 int arg2 ;
42090 wxGBPosition *arg3 = 0 ;
42091 wxGBSpan *arg4 = 0 ;
42092 int arg5 ;
42093 int arg6 ;
42094 PyObject *arg7 = (PyObject *) NULL ;
42095 wxGBSizerItem *result;
42096 wxGBPosition temp3 ;
42097 wxGBSpan temp4 ;
42098 PyObject * obj0 = 0 ;
42099 PyObject * obj1 = 0 ;
42100 PyObject * obj2 = 0 ;
42101 PyObject * obj3 = 0 ;
42102 PyObject * obj4 = 0 ;
42103 PyObject * obj5 = 0 ;
42104 PyObject * obj6 = 0 ;
42105 char *kwnames[] = {
42106 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42107 };
42108
42109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42110 {
42111 arg1 = (int)(SWIG_As_int(obj0));
42112 if (SWIG_arg_fail(1)) SWIG_fail;
42113 }
42114 {
42115 arg2 = (int)(SWIG_As_int(obj1));
42116 if (SWIG_arg_fail(2)) SWIG_fail;
42117 }
42118 {
42119 arg3 = &temp3;
42120 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42121 }
42122 {
42123 arg4 = &temp4;
42124 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42125 }
42126 {
42127 arg5 = (int)(SWIG_As_int(obj4));
42128 if (SWIG_arg_fail(5)) SWIG_fail;
42129 }
42130 {
42131 arg6 = (int)(SWIG_As_int(obj5));
42132 if (SWIG_arg_fail(6)) SWIG_fail;
42133 }
42134 if (obj6) {
42135 arg7 = obj6;
42136 }
42137 {
42138 PyThreadState* __tstate = wxPyBeginAllowThreads();
42139 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42140
42141 wxPyEndAllowThreads(__tstate);
42142 if (PyErr_Occurred()) SWIG_fail;
42143 }
42144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42145 return resultobj;
42146 fail:
42147 return NULL;
42148 }
42149
42150
42151 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42152 PyObject *resultobj;
42153 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42154 wxGBPosition result;
42155 PyObject * obj0 = 0 ;
42156 char *kwnames[] = {
42157 (char *) "self", NULL
42158 };
42159
42160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42162 if (SWIG_arg_fail(1)) SWIG_fail;
42163 {
42164 PyThreadState* __tstate = wxPyBeginAllowThreads();
42165 result = ((wxGBSizerItem const *)arg1)->GetPos();
42166
42167 wxPyEndAllowThreads(__tstate);
42168 if (PyErr_Occurred()) SWIG_fail;
42169 }
42170 {
42171 wxGBPosition * resultptr;
42172 resultptr = new wxGBPosition((wxGBPosition &)(result));
42173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42174 }
42175 return resultobj;
42176 fail:
42177 return NULL;
42178 }
42179
42180
42181 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42182 PyObject *resultobj;
42183 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42184 wxGBSpan result;
42185 PyObject * obj0 = 0 ;
42186 char *kwnames[] = {
42187 (char *) "self", NULL
42188 };
42189
42190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42192 if (SWIG_arg_fail(1)) SWIG_fail;
42193 {
42194 PyThreadState* __tstate = wxPyBeginAllowThreads();
42195 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42196
42197 wxPyEndAllowThreads(__tstate);
42198 if (PyErr_Occurred()) SWIG_fail;
42199 }
42200 {
42201 wxGBSpan * resultptr;
42202 resultptr = new wxGBSpan((wxGBSpan &)(result));
42203 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42204 }
42205 return resultobj;
42206 fail:
42207 return NULL;
42208 }
42209
42210
42211 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42212 PyObject *resultobj;
42213 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42214 wxGBPosition *arg2 = 0 ;
42215 bool result;
42216 wxGBPosition temp2 ;
42217 PyObject * obj0 = 0 ;
42218 PyObject * obj1 = 0 ;
42219 char *kwnames[] = {
42220 (char *) "self",(char *) "pos", NULL
42221 };
42222
42223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42225 if (SWIG_arg_fail(1)) SWIG_fail;
42226 {
42227 arg2 = &temp2;
42228 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42229 }
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42233
42234 wxPyEndAllowThreads(__tstate);
42235 if (PyErr_Occurred()) SWIG_fail;
42236 }
42237 {
42238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42239 }
42240 return resultobj;
42241 fail:
42242 return NULL;
42243 }
42244
42245
42246 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42247 PyObject *resultobj;
42248 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42249 wxGBSpan *arg2 = 0 ;
42250 bool result;
42251 wxGBSpan temp2 ;
42252 PyObject * obj0 = 0 ;
42253 PyObject * obj1 = 0 ;
42254 char *kwnames[] = {
42255 (char *) "self",(char *) "span", NULL
42256 };
42257
42258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42260 if (SWIG_arg_fail(1)) SWIG_fail;
42261 {
42262 arg2 = &temp2;
42263 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42264 }
42265 {
42266 PyThreadState* __tstate = wxPyBeginAllowThreads();
42267 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42268
42269 wxPyEndAllowThreads(__tstate);
42270 if (PyErr_Occurred()) SWIG_fail;
42271 }
42272 {
42273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42274 }
42275 return resultobj;
42276 fail:
42277 return NULL;
42278 }
42279
42280
42281 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42282 PyObject *resultobj;
42283 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42284 wxGBSizerItem *arg2 = 0 ;
42285 bool result;
42286 PyObject * obj0 = 0 ;
42287 PyObject * obj1 = 0 ;
42288 char *kwnames[] = {
42289 (char *) "self",(char *) "other", NULL
42290 };
42291
42292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42294 if (SWIG_arg_fail(1)) SWIG_fail;
42295 {
42296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42297 if (SWIG_arg_fail(2)) SWIG_fail;
42298 if (arg2 == NULL) {
42299 SWIG_null_ref("wxGBSizerItem");
42300 }
42301 if (SWIG_arg_fail(2)) SWIG_fail;
42302 }
42303 {
42304 PyThreadState* __tstate = wxPyBeginAllowThreads();
42305 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42306
42307 wxPyEndAllowThreads(__tstate);
42308 if (PyErr_Occurred()) SWIG_fail;
42309 }
42310 {
42311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42312 }
42313 return resultobj;
42314 fail:
42315 return NULL;
42316 }
42317
42318
42319 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42320 PyObject *resultobj;
42321 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42322 wxGBPosition *arg2 = 0 ;
42323 wxGBSpan *arg3 = 0 ;
42324 bool result;
42325 wxGBPosition temp2 ;
42326 wxGBSpan temp3 ;
42327 PyObject * obj0 = 0 ;
42328 PyObject * obj1 = 0 ;
42329 PyObject * obj2 = 0 ;
42330 char *kwnames[] = {
42331 (char *) "self",(char *) "pos",(char *) "span", NULL
42332 };
42333
42334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42336 if (SWIG_arg_fail(1)) SWIG_fail;
42337 {
42338 arg2 = &temp2;
42339 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42340 }
42341 {
42342 arg3 = &temp3;
42343 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42344 }
42345 {
42346 PyThreadState* __tstate = wxPyBeginAllowThreads();
42347 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42348
42349 wxPyEndAllowThreads(__tstate);
42350 if (PyErr_Occurred()) SWIG_fail;
42351 }
42352 {
42353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42354 }
42355 return resultobj;
42356 fail:
42357 return NULL;
42358 }
42359
42360
42361 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42362 PyObject *resultobj;
42363 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42364 wxGBPosition result;
42365 PyObject * obj0 = 0 ;
42366 char *kwnames[] = {
42367 (char *) "self", NULL
42368 };
42369
42370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42372 if (SWIG_arg_fail(1)) SWIG_fail;
42373 {
42374 PyThreadState* __tstate = wxPyBeginAllowThreads();
42375 result = wxGBSizerItem_GetEndPos(arg1);
42376
42377 wxPyEndAllowThreads(__tstate);
42378 if (PyErr_Occurred()) SWIG_fail;
42379 }
42380 {
42381 wxGBPosition * resultptr;
42382 resultptr = new wxGBPosition((wxGBPosition &)(result));
42383 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42384 }
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42392 PyObject *resultobj;
42393 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42394 wxGridBagSizer *result;
42395 PyObject * obj0 = 0 ;
42396 char *kwnames[] = {
42397 (char *) "self", NULL
42398 };
42399
42400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42402 if (SWIG_arg_fail(1)) SWIG_fail;
42403 {
42404 PyThreadState* __tstate = wxPyBeginAllowThreads();
42405 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42406
42407 wxPyEndAllowThreads(__tstate);
42408 if (PyErr_Occurred()) SWIG_fail;
42409 }
42410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42411 return resultobj;
42412 fail:
42413 return NULL;
42414 }
42415
42416
42417 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42418 PyObject *resultobj;
42419 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42420 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42421 PyObject * obj0 = 0 ;
42422 PyObject * obj1 = 0 ;
42423 char *kwnames[] = {
42424 (char *) "self",(char *) "sizer", NULL
42425 };
42426
42427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42429 if (SWIG_arg_fail(1)) SWIG_fail;
42430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42431 if (SWIG_arg_fail(2)) SWIG_fail;
42432 {
42433 PyThreadState* __tstate = wxPyBeginAllowThreads();
42434 (arg1)->SetGBSizer(arg2);
42435
42436 wxPyEndAllowThreads(__tstate);
42437 if (PyErr_Occurred()) SWIG_fail;
42438 }
42439 Py_INCREF(Py_None); resultobj = Py_None;
42440 return resultobj;
42441 fail:
42442 return NULL;
42443 }
42444
42445
42446 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42447 PyObject *obj;
42448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42449 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42450 Py_INCREF(obj);
42451 return Py_BuildValue((char *)"");
42452 }
42453 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42454 PyObject *resultobj;
42455 int arg1 = (int) 0 ;
42456 int arg2 = (int) 0 ;
42457 wxGridBagSizer *result;
42458 PyObject * obj0 = 0 ;
42459 PyObject * obj1 = 0 ;
42460 char *kwnames[] = {
42461 (char *) "vgap",(char *) "hgap", NULL
42462 };
42463
42464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42465 if (obj0) {
42466 {
42467 arg1 = (int)(SWIG_As_int(obj0));
42468 if (SWIG_arg_fail(1)) SWIG_fail;
42469 }
42470 }
42471 if (obj1) {
42472 {
42473 arg2 = (int)(SWIG_As_int(obj1));
42474 if (SWIG_arg_fail(2)) SWIG_fail;
42475 }
42476 }
42477 {
42478 PyThreadState* __tstate = wxPyBeginAllowThreads();
42479 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42480
42481 wxPyEndAllowThreads(__tstate);
42482 if (PyErr_Occurred()) SWIG_fail;
42483 }
42484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42485 return resultobj;
42486 fail:
42487 return NULL;
42488 }
42489
42490
42491 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42492 PyObject *resultobj;
42493 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42494 PyObject *arg2 = (PyObject *) 0 ;
42495 wxGBPosition *arg3 = 0 ;
42496 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42497 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42498 int arg5 = (int) 0 ;
42499 int arg6 = (int) 0 ;
42500 PyObject *arg7 = (PyObject *) NULL ;
42501 wxGBSizerItem *result;
42502 wxGBPosition temp3 ;
42503 wxGBSpan temp4 ;
42504 PyObject * obj0 = 0 ;
42505 PyObject * obj1 = 0 ;
42506 PyObject * obj2 = 0 ;
42507 PyObject * obj3 = 0 ;
42508 PyObject * obj4 = 0 ;
42509 PyObject * obj5 = 0 ;
42510 PyObject * obj6 = 0 ;
42511 char *kwnames[] = {
42512 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42513 };
42514
42515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42517 if (SWIG_arg_fail(1)) SWIG_fail;
42518 arg2 = obj1;
42519 {
42520 arg3 = &temp3;
42521 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42522 }
42523 if (obj3) {
42524 {
42525 arg4 = &temp4;
42526 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42527 }
42528 }
42529 if (obj4) {
42530 {
42531 arg5 = (int)(SWIG_As_int(obj4));
42532 if (SWIG_arg_fail(5)) SWIG_fail;
42533 }
42534 }
42535 if (obj5) {
42536 {
42537 arg6 = (int)(SWIG_As_int(obj5));
42538 if (SWIG_arg_fail(6)) SWIG_fail;
42539 }
42540 }
42541 if (obj6) {
42542 arg7 = obj6;
42543 }
42544 {
42545 PyThreadState* __tstate = wxPyBeginAllowThreads();
42546 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42547
42548 wxPyEndAllowThreads(__tstate);
42549 if (PyErr_Occurred()) SWIG_fail;
42550 }
42551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42552 return resultobj;
42553 fail:
42554 return NULL;
42555 }
42556
42557
42558 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42559 PyObject *resultobj;
42560 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42561 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42562 wxGBSizerItem *result;
42563 PyObject * obj0 = 0 ;
42564 PyObject * obj1 = 0 ;
42565 char *kwnames[] = {
42566 (char *) "self",(char *) "item", NULL
42567 };
42568
42569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42571 if (SWIG_arg_fail(1)) SWIG_fail;
42572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42573 if (SWIG_arg_fail(2)) SWIG_fail;
42574 {
42575 PyThreadState* __tstate = wxPyBeginAllowThreads();
42576 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42577
42578 wxPyEndAllowThreads(__tstate);
42579 if (PyErr_Occurred()) SWIG_fail;
42580 }
42581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42582 return resultobj;
42583 fail:
42584 return NULL;
42585 }
42586
42587
42588 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42589 PyObject *resultobj;
42590 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42591 int arg2 ;
42592 int arg3 ;
42593 wxSize result;
42594 PyObject * obj0 = 0 ;
42595 PyObject * obj1 = 0 ;
42596 PyObject * obj2 = 0 ;
42597 char *kwnames[] = {
42598 (char *) "self",(char *) "row",(char *) "col", NULL
42599 };
42600
42601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42603 if (SWIG_arg_fail(1)) SWIG_fail;
42604 {
42605 arg2 = (int)(SWIG_As_int(obj1));
42606 if (SWIG_arg_fail(2)) SWIG_fail;
42607 }
42608 {
42609 arg3 = (int)(SWIG_As_int(obj2));
42610 if (SWIG_arg_fail(3)) SWIG_fail;
42611 }
42612 {
42613 PyThreadState* __tstate = wxPyBeginAllowThreads();
42614 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42615
42616 wxPyEndAllowThreads(__tstate);
42617 if (PyErr_Occurred()) SWIG_fail;
42618 }
42619 {
42620 wxSize * resultptr;
42621 resultptr = new wxSize((wxSize &)(result));
42622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42623 }
42624 return resultobj;
42625 fail:
42626 return NULL;
42627 }
42628
42629
42630 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42631 PyObject *resultobj;
42632 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42633 wxSize result;
42634 PyObject * obj0 = 0 ;
42635 char *kwnames[] = {
42636 (char *) "self", NULL
42637 };
42638
42639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42641 if (SWIG_arg_fail(1)) SWIG_fail;
42642 {
42643 PyThreadState* __tstate = wxPyBeginAllowThreads();
42644 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42645
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 {
42650 wxSize * resultptr;
42651 resultptr = new wxSize((wxSize &)(result));
42652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42653 }
42654 return resultobj;
42655 fail:
42656 return NULL;
42657 }
42658
42659
42660 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42661 PyObject *resultobj;
42662 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42663 wxSize *arg2 = 0 ;
42664 wxSize temp2 ;
42665 PyObject * obj0 = 0 ;
42666 PyObject * obj1 = 0 ;
42667 char *kwnames[] = {
42668 (char *) "self",(char *) "sz", NULL
42669 };
42670
42671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42673 if (SWIG_arg_fail(1)) SWIG_fail;
42674 {
42675 arg2 = &temp2;
42676 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42677 }
42678 {
42679 PyThreadState* __tstate = wxPyBeginAllowThreads();
42680 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42681
42682 wxPyEndAllowThreads(__tstate);
42683 if (PyErr_Occurred()) SWIG_fail;
42684 }
42685 Py_INCREF(Py_None); resultobj = Py_None;
42686 return resultobj;
42687 fail:
42688 return NULL;
42689 }
42690
42691
42692 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42693 PyObject *resultobj;
42694 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42695 wxWindow *arg2 = (wxWindow *) 0 ;
42696 wxGBPosition result;
42697 PyObject * obj0 = 0 ;
42698 PyObject * obj1 = 0 ;
42699
42700 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42702 if (SWIG_arg_fail(1)) SWIG_fail;
42703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42704 if (SWIG_arg_fail(2)) SWIG_fail;
42705 {
42706 PyThreadState* __tstate = wxPyBeginAllowThreads();
42707 result = (arg1)->GetItemPosition(arg2);
42708
42709 wxPyEndAllowThreads(__tstate);
42710 if (PyErr_Occurred()) SWIG_fail;
42711 }
42712 {
42713 wxGBPosition * resultptr;
42714 resultptr = new wxGBPosition((wxGBPosition &)(result));
42715 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42716 }
42717 return resultobj;
42718 fail:
42719 return NULL;
42720 }
42721
42722
42723 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42724 PyObject *resultobj;
42725 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42726 wxSizer *arg2 = (wxSizer *) 0 ;
42727 wxGBPosition result;
42728 PyObject * obj0 = 0 ;
42729 PyObject * obj1 = 0 ;
42730
42731 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42733 if (SWIG_arg_fail(1)) SWIG_fail;
42734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42735 if (SWIG_arg_fail(2)) SWIG_fail;
42736 {
42737 PyThreadState* __tstate = wxPyBeginAllowThreads();
42738 result = (arg1)->GetItemPosition(arg2);
42739
42740 wxPyEndAllowThreads(__tstate);
42741 if (PyErr_Occurred()) SWIG_fail;
42742 }
42743 {
42744 wxGBPosition * resultptr;
42745 resultptr = new wxGBPosition((wxGBPosition &)(result));
42746 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42747 }
42748 return resultobj;
42749 fail:
42750 return NULL;
42751 }
42752
42753
42754 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42755 PyObject *resultobj;
42756 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42757 size_t arg2 ;
42758 wxGBPosition result;
42759 PyObject * obj0 = 0 ;
42760 PyObject * obj1 = 0 ;
42761
42762 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42764 if (SWIG_arg_fail(1)) SWIG_fail;
42765 {
42766 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42767 if (SWIG_arg_fail(2)) SWIG_fail;
42768 }
42769 {
42770 PyThreadState* __tstate = wxPyBeginAllowThreads();
42771 result = (arg1)->GetItemPosition(arg2);
42772
42773 wxPyEndAllowThreads(__tstate);
42774 if (PyErr_Occurred()) SWIG_fail;
42775 }
42776 {
42777 wxGBPosition * resultptr;
42778 resultptr = new wxGBPosition((wxGBPosition &)(result));
42779 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42780 }
42781 return resultobj;
42782 fail:
42783 return NULL;
42784 }
42785
42786
42787 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42788 int argc;
42789 PyObject *argv[3];
42790 int ii;
42791
42792 argc = PyObject_Length(args);
42793 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42794 argv[ii] = PyTuple_GetItem(args,ii);
42795 }
42796 if (argc == 2) {
42797 int _v;
42798 {
42799 void *ptr;
42800 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42801 _v = 0;
42802 PyErr_Clear();
42803 } else {
42804 _v = 1;
42805 }
42806 }
42807 if (_v) {
42808 {
42809 void *ptr;
42810 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42811 _v = 0;
42812 PyErr_Clear();
42813 } else {
42814 _v = 1;
42815 }
42816 }
42817 if (_v) {
42818 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42819 }
42820 }
42821 }
42822 if (argc == 2) {
42823 int _v;
42824 {
42825 void *ptr;
42826 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42827 _v = 0;
42828 PyErr_Clear();
42829 } else {
42830 _v = 1;
42831 }
42832 }
42833 if (_v) {
42834 {
42835 void *ptr;
42836 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42837 _v = 0;
42838 PyErr_Clear();
42839 } else {
42840 _v = 1;
42841 }
42842 }
42843 if (_v) {
42844 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42845 }
42846 }
42847 }
42848 if (argc == 2) {
42849 int _v;
42850 {
42851 void *ptr;
42852 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42853 _v = 0;
42854 PyErr_Clear();
42855 } else {
42856 _v = 1;
42857 }
42858 }
42859 if (_v) {
42860 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42861 if (_v) {
42862 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42863 }
42864 }
42865 }
42866
42867 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42868 return NULL;
42869 }
42870
42871
42872 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42873 PyObject *resultobj;
42874 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42875 wxWindow *arg2 = (wxWindow *) 0 ;
42876 wxGBPosition *arg3 = 0 ;
42877 bool result;
42878 wxGBPosition temp3 ;
42879 PyObject * obj0 = 0 ;
42880 PyObject * obj1 = 0 ;
42881 PyObject * obj2 = 0 ;
42882
42883 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42885 if (SWIG_arg_fail(1)) SWIG_fail;
42886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42887 if (SWIG_arg_fail(2)) SWIG_fail;
42888 {
42889 arg3 = &temp3;
42890 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42891 }
42892 {
42893 PyThreadState* __tstate = wxPyBeginAllowThreads();
42894 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42895
42896 wxPyEndAllowThreads(__tstate);
42897 if (PyErr_Occurred()) SWIG_fail;
42898 }
42899 {
42900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42901 }
42902 return resultobj;
42903 fail:
42904 return NULL;
42905 }
42906
42907
42908 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42909 PyObject *resultobj;
42910 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42911 wxSizer *arg2 = (wxSizer *) 0 ;
42912 wxGBPosition *arg3 = 0 ;
42913 bool result;
42914 wxGBPosition temp3 ;
42915 PyObject * obj0 = 0 ;
42916 PyObject * obj1 = 0 ;
42917 PyObject * obj2 = 0 ;
42918
42919 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42921 if (SWIG_arg_fail(1)) SWIG_fail;
42922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42923 if (SWIG_arg_fail(2)) SWIG_fail;
42924 {
42925 arg3 = &temp3;
42926 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42927 }
42928 {
42929 PyThreadState* __tstate = wxPyBeginAllowThreads();
42930 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42931
42932 wxPyEndAllowThreads(__tstate);
42933 if (PyErr_Occurred()) SWIG_fail;
42934 }
42935 {
42936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42937 }
42938 return resultobj;
42939 fail:
42940 return NULL;
42941 }
42942
42943
42944 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42945 PyObject *resultobj;
42946 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42947 size_t arg2 ;
42948 wxGBPosition *arg3 = 0 ;
42949 bool result;
42950 wxGBPosition temp3 ;
42951 PyObject * obj0 = 0 ;
42952 PyObject * obj1 = 0 ;
42953 PyObject * obj2 = 0 ;
42954
42955 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42957 if (SWIG_arg_fail(1)) SWIG_fail;
42958 {
42959 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42960 if (SWIG_arg_fail(2)) SWIG_fail;
42961 }
42962 {
42963 arg3 = &temp3;
42964 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42965 }
42966 {
42967 PyThreadState* __tstate = wxPyBeginAllowThreads();
42968 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42969
42970 wxPyEndAllowThreads(__tstate);
42971 if (PyErr_Occurred()) SWIG_fail;
42972 }
42973 {
42974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42975 }
42976 return resultobj;
42977 fail:
42978 return NULL;
42979 }
42980
42981
42982 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42983 int argc;
42984 PyObject *argv[4];
42985 int ii;
42986
42987 argc = PyObject_Length(args);
42988 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42989 argv[ii] = PyTuple_GetItem(args,ii);
42990 }
42991 if (argc == 3) {
42992 int _v;
42993 {
42994 void *ptr;
42995 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42996 _v = 0;
42997 PyErr_Clear();
42998 } else {
42999 _v = 1;
43000 }
43001 }
43002 if (_v) {
43003 {
43004 void *ptr;
43005 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43006 _v = 0;
43007 PyErr_Clear();
43008 } else {
43009 _v = 1;
43010 }
43011 }
43012 if (_v) {
43013 {
43014 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43015 }
43016 if (_v) {
43017 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43018 }
43019 }
43020 }
43021 }
43022 if (argc == 3) {
43023 int _v;
43024 {
43025 void *ptr;
43026 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43027 _v = 0;
43028 PyErr_Clear();
43029 } else {
43030 _v = 1;
43031 }
43032 }
43033 if (_v) {
43034 {
43035 void *ptr;
43036 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43037 _v = 0;
43038 PyErr_Clear();
43039 } else {
43040 _v = 1;
43041 }
43042 }
43043 if (_v) {
43044 {
43045 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43046 }
43047 if (_v) {
43048 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43049 }
43050 }
43051 }
43052 }
43053 if (argc == 3) {
43054 int _v;
43055 {
43056 void *ptr;
43057 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43058 _v = 0;
43059 PyErr_Clear();
43060 } else {
43061 _v = 1;
43062 }
43063 }
43064 if (_v) {
43065 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43066 if (_v) {
43067 {
43068 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43069 }
43070 if (_v) {
43071 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43072 }
43073 }
43074 }
43075 }
43076
43077 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43078 return NULL;
43079 }
43080
43081
43082 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43083 PyObject *resultobj;
43084 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43085 wxWindow *arg2 = (wxWindow *) 0 ;
43086 wxGBSpan result;
43087 PyObject * obj0 = 0 ;
43088 PyObject * obj1 = 0 ;
43089
43090 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43092 if (SWIG_arg_fail(1)) SWIG_fail;
43093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43094 if (SWIG_arg_fail(2)) SWIG_fail;
43095 {
43096 PyThreadState* __tstate = wxPyBeginAllowThreads();
43097 result = (arg1)->GetItemSpan(arg2);
43098
43099 wxPyEndAllowThreads(__tstate);
43100 if (PyErr_Occurred()) SWIG_fail;
43101 }
43102 {
43103 wxGBSpan * resultptr;
43104 resultptr = new wxGBSpan((wxGBSpan &)(result));
43105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43106 }
43107 return resultobj;
43108 fail:
43109 return NULL;
43110 }
43111
43112
43113 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43114 PyObject *resultobj;
43115 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43116 wxSizer *arg2 = (wxSizer *) 0 ;
43117 wxGBSpan result;
43118 PyObject * obj0 = 0 ;
43119 PyObject * obj1 = 0 ;
43120
43121 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43123 if (SWIG_arg_fail(1)) SWIG_fail;
43124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43125 if (SWIG_arg_fail(2)) SWIG_fail;
43126 {
43127 PyThreadState* __tstate = wxPyBeginAllowThreads();
43128 result = (arg1)->GetItemSpan(arg2);
43129
43130 wxPyEndAllowThreads(__tstate);
43131 if (PyErr_Occurred()) SWIG_fail;
43132 }
43133 {
43134 wxGBSpan * resultptr;
43135 resultptr = new wxGBSpan((wxGBSpan &)(result));
43136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43137 }
43138 return resultobj;
43139 fail:
43140 return NULL;
43141 }
43142
43143
43144 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43145 PyObject *resultobj;
43146 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43147 size_t arg2 ;
43148 wxGBSpan result;
43149 PyObject * obj0 = 0 ;
43150 PyObject * obj1 = 0 ;
43151
43152 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43154 if (SWIG_arg_fail(1)) SWIG_fail;
43155 {
43156 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43157 if (SWIG_arg_fail(2)) SWIG_fail;
43158 }
43159 {
43160 PyThreadState* __tstate = wxPyBeginAllowThreads();
43161 result = (arg1)->GetItemSpan(arg2);
43162
43163 wxPyEndAllowThreads(__tstate);
43164 if (PyErr_Occurred()) SWIG_fail;
43165 }
43166 {
43167 wxGBSpan * resultptr;
43168 resultptr = new wxGBSpan((wxGBSpan &)(result));
43169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43170 }
43171 return resultobj;
43172 fail:
43173 return NULL;
43174 }
43175
43176
43177 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43178 int argc;
43179 PyObject *argv[3];
43180 int ii;
43181
43182 argc = PyObject_Length(args);
43183 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43184 argv[ii] = PyTuple_GetItem(args,ii);
43185 }
43186 if (argc == 2) {
43187 int _v;
43188 {
43189 void *ptr;
43190 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43191 _v = 0;
43192 PyErr_Clear();
43193 } else {
43194 _v = 1;
43195 }
43196 }
43197 if (_v) {
43198 {
43199 void *ptr;
43200 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43201 _v = 0;
43202 PyErr_Clear();
43203 } else {
43204 _v = 1;
43205 }
43206 }
43207 if (_v) {
43208 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43209 }
43210 }
43211 }
43212 if (argc == 2) {
43213 int _v;
43214 {
43215 void *ptr;
43216 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43217 _v = 0;
43218 PyErr_Clear();
43219 } else {
43220 _v = 1;
43221 }
43222 }
43223 if (_v) {
43224 {
43225 void *ptr;
43226 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43227 _v = 0;
43228 PyErr_Clear();
43229 } else {
43230 _v = 1;
43231 }
43232 }
43233 if (_v) {
43234 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43235 }
43236 }
43237 }
43238 if (argc == 2) {
43239 int _v;
43240 {
43241 void *ptr;
43242 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43243 _v = 0;
43244 PyErr_Clear();
43245 } else {
43246 _v = 1;
43247 }
43248 }
43249 if (_v) {
43250 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43251 if (_v) {
43252 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43253 }
43254 }
43255 }
43256
43257 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43258 return NULL;
43259 }
43260
43261
43262 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43263 PyObject *resultobj;
43264 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43265 wxWindow *arg2 = (wxWindow *) 0 ;
43266 wxGBSpan *arg3 = 0 ;
43267 bool result;
43268 wxGBSpan temp3 ;
43269 PyObject * obj0 = 0 ;
43270 PyObject * obj1 = 0 ;
43271 PyObject * obj2 = 0 ;
43272
43273 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43275 if (SWIG_arg_fail(1)) SWIG_fail;
43276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43277 if (SWIG_arg_fail(2)) SWIG_fail;
43278 {
43279 arg3 = &temp3;
43280 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43281 }
43282 {
43283 PyThreadState* __tstate = wxPyBeginAllowThreads();
43284 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43285
43286 wxPyEndAllowThreads(__tstate);
43287 if (PyErr_Occurred()) SWIG_fail;
43288 }
43289 {
43290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43291 }
43292 return resultobj;
43293 fail:
43294 return NULL;
43295 }
43296
43297
43298 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43299 PyObject *resultobj;
43300 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43301 wxSizer *arg2 = (wxSizer *) 0 ;
43302 wxGBSpan *arg3 = 0 ;
43303 bool result;
43304 wxGBSpan temp3 ;
43305 PyObject * obj0 = 0 ;
43306 PyObject * obj1 = 0 ;
43307 PyObject * obj2 = 0 ;
43308
43309 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43311 if (SWIG_arg_fail(1)) SWIG_fail;
43312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43313 if (SWIG_arg_fail(2)) SWIG_fail;
43314 {
43315 arg3 = &temp3;
43316 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43317 }
43318 {
43319 PyThreadState* __tstate = wxPyBeginAllowThreads();
43320 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43321
43322 wxPyEndAllowThreads(__tstate);
43323 if (PyErr_Occurred()) SWIG_fail;
43324 }
43325 {
43326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43327 }
43328 return resultobj;
43329 fail:
43330 return NULL;
43331 }
43332
43333
43334 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43335 PyObject *resultobj;
43336 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43337 size_t arg2 ;
43338 wxGBSpan *arg3 = 0 ;
43339 bool result;
43340 wxGBSpan temp3 ;
43341 PyObject * obj0 = 0 ;
43342 PyObject * obj1 = 0 ;
43343 PyObject * obj2 = 0 ;
43344
43345 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43347 if (SWIG_arg_fail(1)) SWIG_fail;
43348 {
43349 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43350 if (SWIG_arg_fail(2)) SWIG_fail;
43351 }
43352 {
43353 arg3 = &temp3;
43354 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43355 }
43356 {
43357 PyThreadState* __tstate = wxPyBeginAllowThreads();
43358 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43359
43360 wxPyEndAllowThreads(__tstate);
43361 if (PyErr_Occurred()) SWIG_fail;
43362 }
43363 {
43364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43365 }
43366 return resultobj;
43367 fail:
43368 return NULL;
43369 }
43370
43371
43372 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43373 int argc;
43374 PyObject *argv[4];
43375 int ii;
43376
43377 argc = PyObject_Length(args);
43378 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43379 argv[ii] = PyTuple_GetItem(args,ii);
43380 }
43381 if (argc == 3) {
43382 int _v;
43383 {
43384 void *ptr;
43385 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43386 _v = 0;
43387 PyErr_Clear();
43388 } else {
43389 _v = 1;
43390 }
43391 }
43392 if (_v) {
43393 {
43394 void *ptr;
43395 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43396 _v = 0;
43397 PyErr_Clear();
43398 } else {
43399 _v = 1;
43400 }
43401 }
43402 if (_v) {
43403 {
43404 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43405 }
43406 if (_v) {
43407 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43408 }
43409 }
43410 }
43411 }
43412 if (argc == 3) {
43413 int _v;
43414 {
43415 void *ptr;
43416 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43417 _v = 0;
43418 PyErr_Clear();
43419 } else {
43420 _v = 1;
43421 }
43422 }
43423 if (_v) {
43424 {
43425 void *ptr;
43426 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43427 _v = 0;
43428 PyErr_Clear();
43429 } else {
43430 _v = 1;
43431 }
43432 }
43433 if (_v) {
43434 {
43435 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43436 }
43437 if (_v) {
43438 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43439 }
43440 }
43441 }
43442 }
43443 if (argc == 3) {
43444 int _v;
43445 {
43446 void *ptr;
43447 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43448 _v = 0;
43449 PyErr_Clear();
43450 } else {
43451 _v = 1;
43452 }
43453 }
43454 if (_v) {
43455 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43456 if (_v) {
43457 {
43458 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43459 }
43460 if (_v) {
43461 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43462 }
43463 }
43464 }
43465 }
43466
43467 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43468 return NULL;
43469 }
43470
43471
43472 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43473 PyObject *resultobj;
43474 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43475 wxWindow *arg2 = (wxWindow *) 0 ;
43476 wxGBSizerItem *result;
43477 PyObject * obj0 = 0 ;
43478 PyObject * obj1 = 0 ;
43479
43480 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43482 if (SWIG_arg_fail(1)) SWIG_fail;
43483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43484 if (SWIG_arg_fail(2)) SWIG_fail;
43485 {
43486 PyThreadState* __tstate = wxPyBeginAllowThreads();
43487 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43488
43489 wxPyEndAllowThreads(__tstate);
43490 if (PyErr_Occurred()) SWIG_fail;
43491 }
43492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43493 return resultobj;
43494 fail:
43495 return NULL;
43496 }
43497
43498
43499 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43500 PyObject *resultobj;
43501 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43502 wxSizer *arg2 = (wxSizer *) 0 ;
43503 wxGBSizerItem *result;
43504 PyObject * obj0 = 0 ;
43505 PyObject * obj1 = 0 ;
43506
43507 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43509 if (SWIG_arg_fail(1)) SWIG_fail;
43510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43511 if (SWIG_arg_fail(2)) SWIG_fail;
43512 {
43513 PyThreadState* __tstate = wxPyBeginAllowThreads();
43514 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43515
43516 wxPyEndAllowThreads(__tstate);
43517 if (PyErr_Occurred()) SWIG_fail;
43518 }
43519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43520 return resultobj;
43521 fail:
43522 return NULL;
43523 }
43524
43525
43526 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43527 int argc;
43528 PyObject *argv[3];
43529 int ii;
43530
43531 argc = PyObject_Length(args);
43532 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43533 argv[ii] = PyTuple_GetItem(args,ii);
43534 }
43535 if (argc == 2) {
43536 int _v;
43537 {
43538 void *ptr;
43539 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43540 _v = 0;
43541 PyErr_Clear();
43542 } else {
43543 _v = 1;
43544 }
43545 }
43546 if (_v) {
43547 {
43548 void *ptr;
43549 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43550 _v = 0;
43551 PyErr_Clear();
43552 } else {
43553 _v = 1;
43554 }
43555 }
43556 if (_v) {
43557 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43558 }
43559 }
43560 }
43561 if (argc == 2) {
43562 int _v;
43563 {
43564 void *ptr;
43565 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43566 _v = 0;
43567 PyErr_Clear();
43568 } else {
43569 _v = 1;
43570 }
43571 }
43572 if (_v) {
43573 {
43574 void *ptr;
43575 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43576 _v = 0;
43577 PyErr_Clear();
43578 } else {
43579 _v = 1;
43580 }
43581 }
43582 if (_v) {
43583 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43584 }
43585 }
43586 }
43587
43588 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43589 return NULL;
43590 }
43591
43592
43593 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43594 PyObject *resultobj;
43595 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43596 wxGBPosition *arg2 = 0 ;
43597 wxGBSizerItem *result;
43598 wxGBPosition temp2 ;
43599 PyObject * obj0 = 0 ;
43600 PyObject * obj1 = 0 ;
43601 char *kwnames[] = {
43602 (char *) "self",(char *) "pos", NULL
43603 };
43604
43605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43607 if (SWIG_arg_fail(1)) SWIG_fail;
43608 {
43609 arg2 = &temp2;
43610 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43611 }
43612 {
43613 PyThreadState* __tstate = wxPyBeginAllowThreads();
43614 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43615
43616 wxPyEndAllowThreads(__tstate);
43617 if (PyErr_Occurred()) SWIG_fail;
43618 }
43619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43620 return resultobj;
43621 fail:
43622 return NULL;
43623 }
43624
43625
43626 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43627 PyObject *resultobj;
43628 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43629 wxPoint *arg2 = 0 ;
43630 wxGBSizerItem *result;
43631 wxPoint temp2 ;
43632 PyObject * obj0 = 0 ;
43633 PyObject * obj1 = 0 ;
43634 char *kwnames[] = {
43635 (char *) "self",(char *) "pt", NULL
43636 };
43637
43638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43640 if (SWIG_arg_fail(1)) SWIG_fail;
43641 {
43642 arg2 = &temp2;
43643 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43644 }
43645 {
43646 PyThreadState* __tstate = wxPyBeginAllowThreads();
43647 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43648
43649 wxPyEndAllowThreads(__tstate);
43650 if (PyErr_Occurred()) SWIG_fail;
43651 }
43652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43653 return resultobj;
43654 fail:
43655 return NULL;
43656 }
43657
43658
43659 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43660 PyObject *resultobj;
43661 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43662 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43663 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43664 bool result;
43665 PyObject * obj0 = 0 ;
43666 PyObject * obj1 = 0 ;
43667 PyObject * obj2 = 0 ;
43668 char *kwnames[] = {
43669 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43670 };
43671
43672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43674 if (SWIG_arg_fail(1)) SWIG_fail;
43675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43676 if (SWIG_arg_fail(2)) SWIG_fail;
43677 if (obj2) {
43678 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43679 if (SWIG_arg_fail(3)) SWIG_fail;
43680 }
43681 {
43682 PyThreadState* __tstate = wxPyBeginAllowThreads();
43683 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43684
43685 wxPyEndAllowThreads(__tstate);
43686 if (PyErr_Occurred()) SWIG_fail;
43687 }
43688 {
43689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43690 }
43691 return resultobj;
43692 fail:
43693 return NULL;
43694 }
43695
43696
43697 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43698 PyObject *resultobj;
43699 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43700 wxGBPosition *arg2 = 0 ;
43701 wxGBSpan *arg3 = 0 ;
43702 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43703 bool result;
43704 wxGBPosition temp2 ;
43705 wxGBSpan temp3 ;
43706 PyObject * obj0 = 0 ;
43707 PyObject * obj1 = 0 ;
43708 PyObject * obj2 = 0 ;
43709 PyObject * obj3 = 0 ;
43710 char *kwnames[] = {
43711 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43712 };
43713
43714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43716 if (SWIG_arg_fail(1)) SWIG_fail;
43717 {
43718 arg2 = &temp2;
43719 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43720 }
43721 {
43722 arg3 = &temp3;
43723 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43724 }
43725 if (obj3) {
43726 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43727 if (SWIG_arg_fail(4)) SWIG_fail;
43728 }
43729 {
43730 PyThreadState* __tstate = wxPyBeginAllowThreads();
43731 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43732
43733 wxPyEndAllowThreads(__tstate);
43734 if (PyErr_Occurred()) SWIG_fail;
43735 }
43736 {
43737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43738 }
43739 return resultobj;
43740 fail:
43741 return NULL;
43742 }
43743
43744
43745 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43746 PyObject *obj;
43747 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43748 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43749 Py_INCREF(obj);
43750 return Py_BuildValue((char *)"");
43751 }
43752 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43753 PyObject *resultobj;
43754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43755 wxRelationship arg2 ;
43756 wxWindow *arg3 = (wxWindow *) 0 ;
43757 wxEdge arg4 ;
43758 int arg5 = (int) 0 ;
43759 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43760 PyObject * obj0 = 0 ;
43761 PyObject * obj1 = 0 ;
43762 PyObject * obj2 = 0 ;
43763 PyObject * obj3 = 0 ;
43764 PyObject * obj4 = 0 ;
43765 PyObject * obj5 = 0 ;
43766 char *kwnames[] = {
43767 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43768 };
43769
43770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43772 if (SWIG_arg_fail(1)) SWIG_fail;
43773 {
43774 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43775 if (SWIG_arg_fail(2)) SWIG_fail;
43776 }
43777 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43778 if (SWIG_arg_fail(3)) SWIG_fail;
43779 {
43780 arg4 = (wxEdge)(SWIG_As_int(obj3));
43781 if (SWIG_arg_fail(4)) SWIG_fail;
43782 }
43783 if (obj4) {
43784 {
43785 arg5 = (int)(SWIG_As_int(obj4));
43786 if (SWIG_arg_fail(5)) SWIG_fail;
43787 }
43788 }
43789 if (obj5) {
43790 {
43791 arg6 = (int)(SWIG_As_int(obj5));
43792 if (SWIG_arg_fail(6)) SWIG_fail;
43793 }
43794 }
43795 {
43796 PyThreadState* __tstate = wxPyBeginAllowThreads();
43797 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43798
43799 wxPyEndAllowThreads(__tstate);
43800 if (PyErr_Occurred()) SWIG_fail;
43801 }
43802 Py_INCREF(Py_None); resultobj = Py_None;
43803 return resultobj;
43804 fail:
43805 return NULL;
43806 }
43807
43808
43809 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43810 PyObject *resultobj;
43811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43812 wxWindow *arg2 = (wxWindow *) 0 ;
43813 int arg3 = (int) 0 ;
43814 PyObject * obj0 = 0 ;
43815 PyObject * obj1 = 0 ;
43816 PyObject * obj2 = 0 ;
43817 char *kwnames[] = {
43818 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43819 };
43820
43821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43823 if (SWIG_arg_fail(1)) SWIG_fail;
43824 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43825 if (SWIG_arg_fail(2)) SWIG_fail;
43826 if (obj2) {
43827 {
43828 arg3 = (int)(SWIG_As_int(obj2));
43829 if (SWIG_arg_fail(3)) SWIG_fail;
43830 }
43831 }
43832 {
43833 PyThreadState* __tstate = wxPyBeginAllowThreads();
43834 (arg1)->LeftOf(arg2,arg3);
43835
43836 wxPyEndAllowThreads(__tstate);
43837 if (PyErr_Occurred()) SWIG_fail;
43838 }
43839 Py_INCREF(Py_None); resultobj = Py_None;
43840 return resultobj;
43841 fail:
43842 return NULL;
43843 }
43844
43845
43846 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43847 PyObject *resultobj;
43848 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43849 wxWindow *arg2 = (wxWindow *) 0 ;
43850 int arg3 = (int) 0 ;
43851 PyObject * obj0 = 0 ;
43852 PyObject * obj1 = 0 ;
43853 PyObject * obj2 = 0 ;
43854 char *kwnames[] = {
43855 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43856 };
43857
43858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43860 if (SWIG_arg_fail(1)) SWIG_fail;
43861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43862 if (SWIG_arg_fail(2)) SWIG_fail;
43863 if (obj2) {
43864 {
43865 arg3 = (int)(SWIG_As_int(obj2));
43866 if (SWIG_arg_fail(3)) SWIG_fail;
43867 }
43868 }
43869 {
43870 PyThreadState* __tstate = wxPyBeginAllowThreads();
43871 (arg1)->RightOf(arg2,arg3);
43872
43873 wxPyEndAllowThreads(__tstate);
43874 if (PyErr_Occurred()) SWIG_fail;
43875 }
43876 Py_INCREF(Py_None); resultobj = Py_None;
43877 return resultobj;
43878 fail:
43879 return NULL;
43880 }
43881
43882
43883 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43884 PyObject *resultobj;
43885 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43886 wxWindow *arg2 = (wxWindow *) 0 ;
43887 int arg3 = (int) 0 ;
43888 PyObject * obj0 = 0 ;
43889 PyObject * obj1 = 0 ;
43890 PyObject * obj2 = 0 ;
43891 char *kwnames[] = {
43892 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43893 };
43894
43895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43897 if (SWIG_arg_fail(1)) SWIG_fail;
43898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43899 if (SWIG_arg_fail(2)) SWIG_fail;
43900 if (obj2) {
43901 {
43902 arg3 = (int)(SWIG_As_int(obj2));
43903 if (SWIG_arg_fail(3)) SWIG_fail;
43904 }
43905 }
43906 {
43907 PyThreadState* __tstate = wxPyBeginAllowThreads();
43908 (arg1)->Above(arg2,arg3);
43909
43910 wxPyEndAllowThreads(__tstate);
43911 if (PyErr_Occurred()) SWIG_fail;
43912 }
43913 Py_INCREF(Py_None); resultobj = Py_None;
43914 return resultobj;
43915 fail:
43916 return NULL;
43917 }
43918
43919
43920 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43921 PyObject *resultobj;
43922 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43923 wxWindow *arg2 = (wxWindow *) 0 ;
43924 int arg3 = (int) 0 ;
43925 PyObject * obj0 = 0 ;
43926 PyObject * obj1 = 0 ;
43927 PyObject * obj2 = 0 ;
43928 char *kwnames[] = {
43929 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43930 };
43931
43932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43934 if (SWIG_arg_fail(1)) SWIG_fail;
43935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43936 if (SWIG_arg_fail(2)) SWIG_fail;
43937 if (obj2) {
43938 {
43939 arg3 = (int)(SWIG_As_int(obj2));
43940 if (SWIG_arg_fail(3)) SWIG_fail;
43941 }
43942 }
43943 {
43944 PyThreadState* __tstate = wxPyBeginAllowThreads();
43945 (arg1)->Below(arg2,arg3);
43946
43947 wxPyEndAllowThreads(__tstate);
43948 if (PyErr_Occurred()) SWIG_fail;
43949 }
43950 Py_INCREF(Py_None); resultobj = Py_None;
43951 return resultobj;
43952 fail:
43953 return NULL;
43954 }
43955
43956
43957 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43958 PyObject *resultobj;
43959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43960 wxWindow *arg2 = (wxWindow *) 0 ;
43961 wxEdge arg3 ;
43962 int arg4 = (int) 0 ;
43963 PyObject * obj0 = 0 ;
43964 PyObject * obj1 = 0 ;
43965 PyObject * obj2 = 0 ;
43966 PyObject * obj3 = 0 ;
43967 char *kwnames[] = {
43968 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43969 };
43970
43971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43973 if (SWIG_arg_fail(1)) SWIG_fail;
43974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43975 if (SWIG_arg_fail(2)) SWIG_fail;
43976 {
43977 arg3 = (wxEdge)(SWIG_As_int(obj2));
43978 if (SWIG_arg_fail(3)) SWIG_fail;
43979 }
43980 if (obj3) {
43981 {
43982 arg4 = (int)(SWIG_As_int(obj3));
43983 if (SWIG_arg_fail(4)) SWIG_fail;
43984 }
43985 }
43986 {
43987 PyThreadState* __tstate = wxPyBeginAllowThreads();
43988 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43989
43990 wxPyEndAllowThreads(__tstate);
43991 if (PyErr_Occurred()) SWIG_fail;
43992 }
43993 Py_INCREF(Py_None); resultobj = Py_None;
43994 return resultobj;
43995 fail:
43996 return NULL;
43997 }
43998
43999
44000 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44001 PyObject *resultobj;
44002 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44003 wxWindow *arg2 = (wxWindow *) 0 ;
44004 wxEdge arg3 ;
44005 int arg4 ;
44006 PyObject * obj0 = 0 ;
44007 PyObject * obj1 = 0 ;
44008 PyObject * obj2 = 0 ;
44009 PyObject * obj3 = 0 ;
44010 char *kwnames[] = {
44011 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44012 };
44013
44014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44016 if (SWIG_arg_fail(1)) SWIG_fail;
44017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44018 if (SWIG_arg_fail(2)) SWIG_fail;
44019 {
44020 arg3 = (wxEdge)(SWIG_As_int(obj2));
44021 if (SWIG_arg_fail(3)) SWIG_fail;
44022 }
44023 {
44024 arg4 = (int)(SWIG_As_int(obj3));
44025 if (SWIG_arg_fail(4)) SWIG_fail;
44026 }
44027 {
44028 PyThreadState* __tstate = wxPyBeginAllowThreads();
44029 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44030
44031 wxPyEndAllowThreads(__tstate);
44032 if (PyErr_Occurred()) SWIG_fail;
44033 }
44034 Py_INCREF(Py_None); resultobj = Py_None;
44035 return resultobj;
44036 fail:
44037 return NULL;
44038 }
44039
44040
44041 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44042 PyObject *resultobj;
44043 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44044 int arg2 ;
44045 PyObject * obj0 = 0 ;
44046 PyObject * obj1 = 0 ;
44047 char *kwnames[] = {
44048 (char *) "self",(char *) "val", NULL
44049 };
44050
44051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44053 if (SWIG_arg_fail(1)) SWIG_fail;
44054 {
44055 arg2 = (int)(SWIG_As_int(obj1));
44056 if (SWIG_arg_fail(2)) SWIG_fail;
44057 }
44058 {
44059 PyThreadState* __tstate = wxPyBeginAllowThreads();
44060 (arg1)->Absolute(arg2);
44061
44062 wxPyEndAllowThreads(__tstate);
44063 if (PyErr_Occurred()) SWIG_fail;
44064 }
44065 Py_INCREF(Py_None); resultobj = Py_None;
44066 return resultobj;
44067 fail:
44068 return NULL;
44069 }
44070
44071
44072 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44073 PyObject *resultobj;
44074 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44075 PyObject * obj0 = 0 ;
44076 char *kwnames[] = {
44077 (char *) "self", NULL
44078 };
44079
44080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44082 if (SWIG_arg_fail(1)) SWIG_fail;
44083 {
44084 PyThreadState* __tstate = wxPyBeginAllowThreads();
44085 (arg1)->Unconstrained();
44086
44087 wxPyEndAllowThreads(__tstate);
44088 if (PyErr_Occurred()) SWIG_fail;
44089 }
44090 Py_INCREF(Py_None); resultobj = Py_None;
44091 return resultobj;
44092 fail:
44093 return NULL;
44094 }
44095
44096
44097 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44098 PyObject *resultobj;
44099 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44100 PyObject * obj0 = 0 ;
44101 char *kwnames[] = {
44102 (char *) "self", NULL
44103 };
44104
44105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44107 if (SWIG_arg_fail(1)) SWIG_fail;
44108 {
44109 PyThreadState* __tstate = wxPyBeginAllowThreads();
44110 (arg1)->AsIs();
44111
44112 wxPyEndAllowThreads(__tstate);
44113 if (PyErr_Occurred()) SWIG_fail;
44114 }
44115 Py_INCREF(Py_None); resultobj = Py_None;
44116 return resultobj;
44117 fail:
44118 return NULL;
44119 }
44120
44121
44122 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44123 PyObject *resultobj;
44124 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44125 wxWindow *result;
44126 PyObject * obj0 = 0 ;
44127 char *kwnames[] = {
44128 (char *) "self", NULL
44129 };
44130
44131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44133 if (SWIG_arg_fail(1)) SWIG_fail;
44134 {
44135 PyThreadState* __tstate = wxPyBeginAllowThreads();
44136 result = (wxWindow *)(arg1)->GetOtherWindow();
44137
44138 wxPyEndAllowThreads(__tstate);
44139 if (PyErr_Occurred()) SWIG_fail;
44140 }
44141 {
44142 resultobj = wxPyMake_wxObject(result, 0);
44143 }
44144 return resultobj;
44145 fail:
44146 return NULL;
44147 }
44148
44149
44150 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44151 PyObject *resultobj;
44152 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44153 wxEdge result;
44154 PyObject * obj0 = 0 ;
44155 char *kwnames[] = {
44156 (char *) "self", NULL
44157 };
44158
44159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44161 if (SWIG_arg_fail(1)) SWIG_fail;
44162 {
44163 PyThreadState* __tstate = wxPyBeginAllowThreads();
44164 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44165
44166 wxPyEndAllowThreads(__tstate);
44167 if (PyErr_Occurred()) SWIG_fail;
44168 }
44169 resultobj = SWIG_From_int((result));
44170 return resultobj;
44171 fail:
44172 return NULL;
44173 }
44174
44175
44176 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44177 PyObject *resultobj;
44178 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44179 wxEdge arg2 ;
44180 PyObject * obj0 = 0 ;
44181 PyObject * obj1 = 0 ;
44182 char *kwnames[] = {
44183 (char *) "self",(char *) "which", NULL
44184 };
44185
44186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44188 if (SWIG_arg_fail(1)) SWIG_fail;
44189 {
44190 arg2 = (wxEdge)(SWIG_As_int(obj1));
44191 if (SWIG_arg_fail(2)) SWIG_fail;
44192 }
44193 {
44194 PyThreadState* __tstate = wxPyBeginAllowThreads();
44195 (arg1)->SetEdge((wxEdge )arg2);
44196
44197 wxPyEndAllowThreads(__tstate);
44198 if (PyErr_Occurred()) SWIG_fail;
44199 }
44200 Py_INCREF(Py_None); resultobj = Py_None;
44201 return resultobj;
44202 fail:
44203 return NULL;
44204 }
44205
44206
44207 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44208 PyObject *resultobj;
44209 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44210 int arg2 ;
44211 PyObject * obj0 = 0 ;
44212 PyObject * obj1 = 0 ;
44213 char *kwnames[] = {
44214 (char *) "self",(char *) "v", NULL
44215 };
44216
44217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44219 if (SWIG_arg_fail(1)) SWIG_fail;
44220 {
44221 arg2 = (int)(SWIG_As_int(obj1));
44222 if (SWIG_arg_fail(2)) SWIG_fail;
44223 }
44224 {
44225 PyThreadState* __tstate = wxPyBeginAllowThreads();
44226 (arg1)->SetValue(arg2);
44227
44228 wxPyEndAllowThreads(__tstate);
44229 if (PyErr_Occurred()) SWIG_fail;
44230 }
44231 Py_INCREF(Py_None); resultobj = Py_None;
44232 return resultobj;
44233 fail:
44234 return NULL;
44235 }
44236
44237
44238 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44239 PyObject *resultobj;
44240 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44241 int result;
44242 PyObject * obj0 = 0 ;
44243 char *kwnames[] = {
44244 (char *) "self", NULL
44245 };
44246
44247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44249 if (SWIG_arg_fail(1)) SWIG_fail;
44250 {
44251 PyThreadState* __tstate = wxPyBeginAllowThreads();
44252 result = (int)(arg1)->GetMargin();
44253
44254 wxPyEndAllowThreads(__tstate);
44255 if (PyErr_Occurred()) SWIG_fail;
44256 }
44257 {
44258 resultobj = SWIG_From_int((int)(result));
44259 }
44260 return resultobj;
44261 fail:
44262 return NULL;
44263 }
44264
44265
44266 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44267 PyObject *resultobj;
44268 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44269 int arg2 ;
44270 PyObject * obj0 = 0 ;
44271 PyObject * obj1 = 0 ;
44272 char *kwnames[] = {
44273 (char *) "self",(char *) "m", NULL
44274 };
44275
44276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44278 if (SWIG_arg_fail(1)) SWIG_fail;
44279 {
44280 arg2 = (int)(SWIG_As_int(obj1));
44281 if (SWIG_arg_fail(2)) SWIG_fail;
44282 }
44283 {
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 (arg1)->SetMargin(arg2);
44286
44287 wxPyEndAllowThreads(__tstate);
44288 if (PyErr_Occurred()) SWIG_fail;
44289 }
44290 Py_INCREF(Py_None); resultobj = Py_None;
44291 return resultobj;
44292 fail:
44293 return NULL;
44294 }
44295
44296
44297 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44298 PyObject *resultobj;
44299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44300 int result;
44301 PyObject * obj0 = 0 ;
44302 char *kwnames[] = {
44303 (char *) "self", NULL
44304 };
44305
44306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44308 if (SWIG_arg_fail(1)) SWIG_fail;
44309 {
44310 PyThreadState* __tstate = wxPyBeginAllowThreads();
44311 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44312
44313 wxPyEndAllowThreads(__tstate);
44314 if (PyErr_Occurred()) SWIG_fail;
44315 }
44316 {
44317 resultobj = SWIG_From_int((int)(result));
44318 }
44319 return resultobj;
44320 fail:
44321 return NULL;
44322 }
44323
44324
44325 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44326 PyObject *resultobj;
44327 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44328 int result;
44329 PyObject * obj0 = 0 ;
44330 char *kwnames[] = {
44331 (char *) "self", NULL
44332 };
44333
44334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44336 if (SWIG_arg_fail(1)) SWIG_fail;
44337 {
44338 PyThreadState* __tstate = wxPyBeginAllowThreads();
44339 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44340
44341 wxPyEndAllowThreads(__tstate);
44342 if (PyErr_Occurred()) SWIG_fail;
44343 }
44344 {
44345 resultobj = SWIG_From_int((int)(result));
44346 }
44347 return resultobj;
44348 fail:
44349 return NULL;
44350 }
44351
44352
44353 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44354 PyObject *resultobj;
44355 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44356 int result;
44357 PyObject * obj0 = 0 ;
44358 char *kwnames[] = {
44359 (char *) "self", NULL
44360 };
44361
44362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44364 if (SWIG_arg_fail(1)) SWIG_fail;
44365 {
44366 PyThreadState* __tstate = wxPyBeginAllowThreads();
44367 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44368
44369 wxPyEndAllowThreads(__tstate);
44370 if (PyErr_Occurred()) SWIG_fail;
44371 }
44372 {
44373 resultobj = SWIG_From_int((int)(result));
44374 }
44375 return resultobj;
44376 fail:
44377 return NULL;
44378 }
44379
44380
44381 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44382 PyObject *resultobj;
44383 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44384 bool result;
44385 PyObject * obj0 = 0 ;
44386 char *kwnames[] = {
44387 (char *) "self", NULL
44388 };
44389
44390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44392 if (SWIG_arg_fail(1)) SWIG_fail;
44393 {
44394 PyThreadState* __tstate = wxPyBeginAllowThreads();
44395 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44396
44397 wxPyEndAllowThreads(__tstate);
44398 if (PyErr_Occurred()) SWIG_fail;
44399 }
44400 {
44401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44402 }
44403 return resultobj;
44404 fail:
44405 return NULL;
44406 }
44407
44408
44409 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44410 PyObject *resultobj;
44411 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44412 bool arg2 ;
44413 PyObject * obj0 = 0 ;
44414 PyObject * obj1 = 0 ;
44415 char *kwnames[] = {
44416 (char *) "self",(char *) "d", NULL
44417 };
44418
44419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44421 if (SWIG_arg_fail(1)) SWIG_fail;
44422 {
44423 arg2 = (bool)(SWIG_As_bool(obj1));
44424 if (SWIG_arg_fail(2)) SWIG_fail;
44425 }
44426 {
44427 PyThreadState* __tstate = wxPyBeginAllowThreads();
44428 (arg1)->SetDone(arg2);
44429
44430 wxPyEndAllowThreads(__tstate);
44431 if (PyErr_Occurred()) SWIG_fail;
44432 }
44433 Py_INCREF(Py_None); resultobj = Py_None;
44434 return resultobj;
44435 fail:
44436 return NULL;
44437 }
44438
44439
44440 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44441 PyObject *resultobj;
44442 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44443 wxRelationship result;
44444 PyObject * obj0 = 0 ;
44445 char *kwnames[] = {
44446 (char *) "self", NULL
44447 };
44448
44449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44451 if (SWIG_arg_fail(1)) SWIG_fail;
44452 {
44453 PyThreadState* __tstate = wxPyBeginAllowThreads();
44454 result = (wxRelationship)(arg1)->GetRelationship();
44455
44456 wxPyEndAllowThreads(__tstate);
44457 if (PyErr_Occurred()) SWIG_fail;
44458 }
44459 resultobj = SWIG_From_int((result));
44460 return resultobj;
44461 fail:
44462 return NULL;
44463 }
44464
44465
44466 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44467 PyObject *resultobj;
44468 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44469 wxRelationship arg2 ;
44470 PyObject * obj0 = 0 ;
44471 PyObject * obj1 = 0 ;
44472 char *kwnames[] = {
44473 (char *) "self",(char *) "r", NULL
44474 };
44475
44476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44478 if (SWIG_arg_fail(1)) SWIG_fail;
44479 {
44480 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44481 if (SWIG_arg_fail(2)) SWIG_fail;
44482 }
44483 {
44484 PyThreadState* __tstate = wxPyBeginAllowThreads();
44485 (arg1)->SetRelationship((wxRelationship )arg2);
44486
44487 wxPyEndAllowThreads(__tstate);
44488 if (PyErr_Occurred()) SWIG_fail;
44489 }
44490 Py_INCREF(Py_None); resultobj = Py_None;
44491 return resultobj;
44492 fail:
44493 return NULL;
44494 }
44495
44496
44497 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44498 PyObject *resultobj;
44499 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44500 wxWindow *arg2 = (wxWindow *) 0 ;
44501 bool result;
44502 PyObject * obj0 = 0 ;
44503 PyObject * obj1 = 0 ;
44504 char *kwnames[] = {
44505 (char *) "self",(char *) "otherW", NULL
44506 };
44507
44508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44510 if (SWIG_arg_fail(1)) SWIG_fail;
44511 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44512 if (SWIG_arg_fail(2)) SWIG_fail;
44513 {
44514 PyThreadState* __tstate = wxPyBeginAllowThreads();
44515 result = (bool)(arg1)->ResetIfWin(arg2);
44516
44517 wxPyEndAllowThreads(__tstate);
44518 if (PyErr_Occurred()) SWIG_fail;
44519 }
44520 {
44521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44522 }
44523 return resultobj;
44524 fail:
44525 return NULL;
44526 }
44527
44528
44529 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44530 PyObject *resultobj;
44531 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44532 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44533 wxWindow *arg3 = (wxWindow *) 0 ;
44534 bool result;
44535 PyObject * obj0 = 0 ;
44536 PyObject * obj1 = 0 ;
44537 PyObject * obj2 = 0 ;
44538 char *kwnames[] = {
44539 (char *) "self",(char *) "constraints",(char *) "win", NULL
44540 };
44541
44542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44544 if (SWIG_arg_fail(1)) SWIG_fail;
44545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44546 if (SWIG_arg_fail(2)) SWIG_fail;
44547 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44548 if (SWIG_arg_fail(3)) SWIG_fail;
44549 {
44550 PyThreadState* __tstate = wxPyBeginAllowThreads();
44551 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44552
44553 wxPyEndAllowThreads(__tstate);
44554 if (PyErr_Occurred()) SWIG_fail;
44555 }
44556 {
44557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44558 }
44559 return resultobj;
44560 fail:
44561 return NULL;
44562 }
44563
44564
44565 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44566 PyObject *resultobj;
44567 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44568 wxEdge arg2 ;
44569 wxWindow *arg3 = (wxWindow *) 0 ;
44570 wxWindow *arg4 = (wxWindow *) 0 ;
44571 int result;
44572 PyObject * obj0 = 0 ;
44573 PyObject * obj1 = 0 ;
44574 PyObject * obj2 = 0 ;
44575 PyObject * obj3 = 0 ;
44576 char *kwnames[] = {
44577 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44578 };
44579
44580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44582 if (SWIG_arg_fail(1)) SWIG_fail;
44583 {
44584 arg2 = (wxEdge)(SWIG_As_int(obj1));
44585 if (SWIG_arg_fail(2)) SWIG_fail;
44586 }
44587 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44588 if (SWIG_arg_fail(3)) SWIG_fail;
44589 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44590 if (SWIG_arg_fail(4)) SWIG_fail;
44591 {
44592 PyThreadState* __tstate = wxPyBeginAllowThreads();
44593 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44594
44595 wxPyEndAllowThreads(__tstate);
44596 if (PyErr_Occurred()) SWIG_fail;
44597 }
44598 {
44599 resultobj = SWIG_From_int((int)(result));
44600 }
44601 return resultobj;
44602 fail:
44603 return NULL;
44604 }
44605
44606
44607 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44608 PyObject *obj;
44609 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44610 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44611 Py_INCREF(obj);
44612 return Py_BuildValue((char *)"");
44613 }
44614 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44615 PyObject *resultobj;
44616 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44617 wxIndividualLayoutConstraint *result;
44618 PyObject * obj0 = 0 ;
44619 char *kwnames[] = {
44620 (char *) "self", NULL
44621 };
44622
44623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44625 if (SWIG_arg_fail(1)) SWIG_fail;
44626 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44627
44628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44629 return resultobj;
44630 fail:
44631 return NULL;
44632 }
44633
44634
44635 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44636 PyObject *resultobj;
44637 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44638 wxIndividualLayoutConstraint *result;
44639 PyObject * obj0 = 0 ;
44640 char *kwnames[] = {
44641 (char *) "self", NULL
44642 };
44643
44644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44646 if (SWIG_arg_fail(1)) SWIG_fail;
44647 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44648
44649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44650 return resultobj;
44651 fail:
44652 return NULL;
44653 }
44654
44655
44656 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44657 PyObject *resultobj;
44658 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44659 wxIndividualLayoutConstraint *result;
44660 PyObject * obj0 = 0 ;
44661 char *kwnames[] = {
44662 (char *) "self", NULL
44663 };
44664
44665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44667 if (SWIG_arg_fail(1)) SWIG_fail;
44668 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44669
44670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44671 return resultobj;
44672 fail:
44673 return NULL;
44674 }
44675
44676
44677 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44678 PyObject *resultobj;
44679 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44680 wxIndividualLayoutConstraint *result;
44681 PyObject * obj0 = 0 ;
44682 char *kwnames[] = {
44683 (char *) "self", NULL
44684 };
44685
44686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44688 if (SWIG_arg_fail(1)) SWIG_fail;
44689 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44690
44691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44692 return resultobj;
44693 fail:
44694 return NULL;
44695 }
44696
44697
44698 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44699 PyObject *resultobj;
44700 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44701 wxIndividualLayoutConstraint *result;
44702 PyObject * obj0 = 0 ;
44703 char *kwnames[] = {
44704 (char *) "self", NULL
44705 };
44706
44707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44709 if (SWIG_arg_fail(1)) SWIG_fail;
44710 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44711
44712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44713 return resultobj;
44714 fail:
44715 return NULL;
44716 }
44717
44718
44719 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44720 PyObject *resultobj;
44721 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44722 wxIndividualLayoutConstraint *result;
44723 PyObject * obj0 = 0 ;
44724 char *kwnames[] = {
44725 (char *) "self", NULL
44726 };
44727
44728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44730 if (SWIG_arg_fail(1)) SWIG_fail;
44731 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44732
44733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44734 return resultobj;
44735 fail:
44736 return NULL;
44737 }
44738
44739
44740 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44741 PyObject *resultobj;
44742 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44743 wxIndividualLayoutConstraint *result;
44744 PyObject * obj0 = 0 ;
44745 char *kwnames[] = {
44746 (char *) "self", NULL
44747 };
44748
44749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44751 if (SWIG_arg_fail(1)) SWIG_fail;
44752 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44753
44754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44755 return resultobj;
44756 fail:
44757 return NULL;
44758 }
44759
44760
44761 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44762 PyObject *resultobj;
44763 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44764 wxIndividualLayoutConstraint *result;
44765 PyObject * obj0 = 0 ;
44766 char *kwnames[] = {
44767 (char *) "self", NULL
44768 };
44769
44770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44772 if (SWIG_arg_fail(1)) SWIG_fail;
44773 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44774
44775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44776 return resultobj;
44777 fail:
44778 return NULL;
44779 }
44780
44781
44782 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44783 PyObject *resultobj;
44784 wxLayoutConstraints *result;
44785 char *kwnames[] = {
44786 NULL
44787 };
44788
44789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44790 {
44791 PyThreadState* __tstate = wxPyBeginAllowThreads();
44792 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44793
44794 wxPyEndAllowThreads(__tstate);
44795 if (PyErr_Occurred()) SWIG_fail;
44796 }
44797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44798 return resultobj;
44799 fail:
44800 return NULL;
44801 }
44802
44803
44804 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44805 PyObject *resultobj;
44806 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44807 wxWindow *arg2 = (wxWindow *) 0 ;
44808 int *arg3 = (int *) 0 ;
44809 bool result;
44810 int temp3 ;
44811 int res3 = 0 ;
44812 PyObject * obj0 = 0 ;
44813 PyObject * obj1 = 0 ;
44814 char *kwnames[] = {
44815 (char *) "self",(char *) "win", NULL
44816 };
44817
44818 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44821 if (SWIG_arg_fail(1)) SWIG_fail;
44822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44823 if (SWIG_arg_fail(2)) SWIG_fail;
44824 {
44825 PyThreadState* __tstate = wxPyBeginAllowThreads();
44826 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44827
44828 wxPyEndAllowThreads(__tstate);
44829 if (PyErr_Occurred()) SWIG_fail;
44830 }
44831 {
44832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44833 }
44834 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44835 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44836 return resultobj;
44837 fail:
44838 return NULL;
44839 }
44840
44841
44842 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44843 PyObject *resultobj;
44844 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44845 bool result;
44846 PyObject * obj0 = 0 ;
44847 char *kwnames[] = {
44848 (char *) "self", NULL
44849 };
44850
44851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44853 if (SWIG_arg_fail(1)) SWIG_fail;
44854 {
44855 PyThreadState* __tstate = wxPyBeginAllowThreads();
44856 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44857
44858 wxPyEndAllowThreads(__tstate);
44859 if (PyErr_Occurred()) SWIG_fail;
44860 }
44861 {
44862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44863 }
44864 return resultobj;
44865 fail:
44866 return NULL;
44867 }
44868
44869
44870 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44871 PyObject *obj;
44872 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44873 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44874 Py_INCREF(obj);
44875 return Py_BuildValue((char *)"");
44876 }
44877 static PyMethodDef SwigMethods[] = {
44878 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44879 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44880 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44883 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44904 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44917 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44932 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44985 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45013 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45032 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45034 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45042 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45043 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45055 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45067 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45071 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45077 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45087 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45097 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45101 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45176 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45178 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45180 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45182 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45184 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45186 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45188 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45190 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45192 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45194 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45196 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45198 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45200 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45214 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45232 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45235 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45238 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45250 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45255 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45261 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45267 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45330 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45337 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45373 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45383 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45389 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45391 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45393 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45396 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45400 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45403 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45406 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45408 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45413 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45421 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45425 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45428 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45430 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45434 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45451 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45453 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45456 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45458 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45462 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45466 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45477 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45480 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45483 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45487 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45494 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45499 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45504 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45508 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45553 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45573 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45580 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45584 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45594 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45766 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45808 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45822 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45825 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45880 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45907 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45951 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45959 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45978 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45979 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46016 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46046 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46049 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46053 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46056 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46066 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46078 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46090 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46100 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46110 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46124 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46131 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46132 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46133 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46134 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46135 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46140 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46167 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46179 { NULL, NULL, 0, NULL }
46180 };
46181
46182
46183 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46184
46185 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46186 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46187 }
46188 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46189 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46190 }
46191 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46192 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46193 }
46194 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46195 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46196 }
46197 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46198 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46199 }
46200 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46201 return (void *)((wxSizer *) ((wxGridSizer *) x));
46202 }
46203 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46204 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46205 }
46206 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46207 return (void *)((wxSizer *) ((wxPySizer *) x));
46208 }
46209 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46210 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46211 }
46212 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46213 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46214 }
46215 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46216 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46217 }
46218 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46219 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46220 }
46221 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46222 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46223 }
46224 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46225 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46226 }
46227 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46228 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46229 }
46230 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46231 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46232 }
46233 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46234 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46235 }
46236 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46237 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46238 }
46239 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46240 return (void *)((wxEvent *) ((wxPyEvent *) x));
46241 }
46242 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46243 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46244 }
46245 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46246 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46247 }
46248 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46249 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46250 }
46251 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46252 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46253 }
46254 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46255 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46256 }
46257 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46258 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46259 }
46260 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46261 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46262 }
46263 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46264 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46265 }
46266 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46267 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46268 }
46269 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46270 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46271 }
46272 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46273 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46274 }
46275 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46276 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46277 }
46278 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46279 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46280 }
46281 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46282 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46283 }
46284 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46285 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46286 }
46287 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46288 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46289 }
46290 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46291 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46292 }
46293 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46294 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46295 }
46296 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46297 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46298 }
46299 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46300 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46301 }
46302 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46303 return (void *)((wxEvent *) ((wxShowEvent *) x));
46304 }
46305 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46306 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46307 }
46308 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46309 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46310 }
46311 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46312 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46313 }
46314 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46315 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46316 }
46317 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46318 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46319 }
46320 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46321 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46322 }
46323 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46324 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46325 }
46326 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46327 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46328 }
46329 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46330 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46331 }
46332 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46333 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46334 }
46335 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46336 return (void *)((wxControl *) ((wxControlWithItems *) x));
46337 }
46338 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46339 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46340 }
46341 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46342 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46343 }
46344 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46345 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46346 }
46347 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46348 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46349 }
46350 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46351 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46352 }
46353 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46354 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46355 }
46356 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46357 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46358 }
46359 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46360 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46361 }
46362 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46363 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46364 }
46365 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46366 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46367 }
46368 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46369 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46370 }
46371 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46372 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46373 }
46374 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46375 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46376 }
46377 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46378 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46379 }
46380 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46381 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46382 }
46383 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46384 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46385 }
46386 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46387 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46388 }
46389 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46390 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46391 }
46392 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46393 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46394 }
46395 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46396 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46397 }
46398 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46399 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46400 }
46401 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46402 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46403 }
46404 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46405 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46406 }
46407 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46408 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46409 }
46410 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46411 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46412 }
46413 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46414 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46415 }
46416 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46417 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46418 }
46419 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46420 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46421 }
46422 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46423 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46424 }
46425 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46426 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46427 }
46428 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46429 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46430 }
46431 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46432 return (void *)((wxObject *) ((wxSizerItem *) x));
46433 }
46434 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46435 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46436 }
46437 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46438 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46439 }
46440 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46441 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46442 }
46443 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46444 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46445 }
46446 static void *_p_wxSizerTo_p_wxObject(void *x) {
46447 return (void *)((wxObject *) ((wxSizer *) x));
46448 }
46449 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46450 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46451 }
46452 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46453 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46454 }
46455 static void *_p_wxEventTo_p_wxObject(void *x) {
46456 return (void *)((wxObject *) ((wxEvent *) x));
46457 }
46458 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46459 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46460 }
46461 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46462 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46463 }
46464 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46465 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46466 }
46467 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46468 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46469 }
46470 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46471 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46472 }
46473 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46474 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46475 }
46476 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46477 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46478 }
46479 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46480 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46481 }
46482 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46483 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46484 }
46485 static void *_p_wxControlTo_p_wxObject(void *x) {
46486 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46487 }
46488 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46489 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46490 }
46491 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46492 return (void *)((wxObject *) ((wxFSFile *) x));
46493 }
46494 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46495 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46496 }
46497 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46498 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46499 }
46500 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46501 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46502 }
46503 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46504 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46505 }
46506 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46507 return (void *)((wxObject *) ((wxMenuItem *) x));
46508 }
46509 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46510 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46511 }
46512 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46513 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46514 }
46515 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46516 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46517 }
46518 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46519 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46520 }
46521 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46522 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46523 }
46524 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46525 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46526 }
46527 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46528 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46529 }
46530 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46531 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46532 }
46533 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46534 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46535 }
46536 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46537 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46538 }
46539 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46540 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46541 }
46542 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46543 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46544 }
46545 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46546 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46547 }
46548 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46549 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46550 }
46551 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46552 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46553 }
46554 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46555 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46556 }
46557 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46558 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46559 }
46560 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46561 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46562 }
46563 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46564 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46565 }
46566 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46567 return (void *)((wxObject *) ((wxImageHandler *) x));
46568 }
46569 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46570 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46571 }
46572 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46573 return (void *)((wxObject *) ((wxEvtHandler *) x));
46574 }
46575 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46576 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46577 }
46578 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46579 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46580 }
46581 static void *_p_wxImageTo_p_wxObject(void *x) {
46582 return (void *)((wxObject *) ((wxImage *) x));
46583 }
46584 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46585 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46586 }
46587 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46588 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46589 }
46590 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46591 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46592 }
46593 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46594 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46595 }
46596 static void *_p_wxWindowTo_p_wxObject(void *x) {
46597 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46598 }
46599 static void *_p_wxMenuTo_p_wxObject(void *x) {
46600 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46601 }
46602 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46603 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46604 }
46605 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46606 return (void *)((wxObject *) ((wxFileSystem *) x));
46607 }
46608 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46609 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46610 }
46611 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46612 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46613 }
46614 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46615 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46616 }
46617 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46618 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46619 }
46620 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46621 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46622 }
46623 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46624 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46625 }
46626 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46627 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46628 }
46629 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46630 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46631 }
46632 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46633 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46634 }
46635 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46636 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46637 }
46638 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46639 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46640 }
46641 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46642 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46643 }
46644 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46645 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46646 }
46647 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46648 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46649 }
46650 static void *_p_wxControlTo_p_wxWindow(void *x) {
46651 return (void *)((wxWindow *) ((wxControl *) x));
46652 }
46653 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46654 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46655 }
46656 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46657 return (void *)((wxWindow *) ((wxMenuBar *) x));
46658 }
46659 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46660 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46661 }
46662 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46663 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46664 }
46665 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46666 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46667 }
46668 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46669 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46670 }
46671 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46672 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46673 }
46674 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46675 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46676 }
46677 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46678 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46679 }
46680 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46681 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46682 }
46683 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46684 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46685 }
46686 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46687 return (void *)((wxValidator *) ((wxPyValidator *) x));
46688 }
46689 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}};
46690 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}};
46691 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}};
46692 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}};
46693 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}};
46694 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}};
46695 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}};
46696 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}};
46697 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}};
46698 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}};
46699 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}};
46700 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}};
46701 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}};
46702 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}};
46703 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}};
46704 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}};
46705 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}};
46706 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}};
46707 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}};
46708 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}};
46709 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}};
46710 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}};
46711 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}};
46712 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}};
46713 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}};
46714 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}};
46715 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}};
46716 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}};
46717 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}};
46718 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}};
46719 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}};
46720 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}};
46721 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}};
46722 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}};
46723 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}};
46724 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}};
46725 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}};
46726 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}};
46727 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}};
46728 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}};
46729 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}};
46730 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}};
46731 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}};
46732 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}};
46733 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}};
46734 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}};
46735 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}};
46736 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}};
46737 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}};
46738 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}};
46739 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}};
46740 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}};
46741 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}};
46742 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}};
46743 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}};
46744 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}};
46745 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}};
46746 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}};
46747 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}};
46748 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}};
46749 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}};
46750 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}};
46751 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}};
46752 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}};
46753 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}};
46754 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}};
46755 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}};
46756 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}};
46757 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}};
46758 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}};
46759 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}};
46760 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}};
46761 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}};
46762 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}};
46763 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}};
46764 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}};
46765 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}};
46766 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}};
46767 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}};
46768 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}};
46769 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}};
46770 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}};
46771 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}};
46772 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}};
46773 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}};
46774 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}};
46775 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}};
46776 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}};
46777 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}};
46778 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}};
46779 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}};
46780 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}};
46781 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}};
46782 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}};
46783 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}};
46784 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}};
46785 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}};
46786 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}};
46787 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}};
46788 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}};
46789 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}};
46790 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}};
46791 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}};
46792 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}};
46793 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}};
46794 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}};
46795 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}};
46796 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}};
46797 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}};
46798 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}};
46799 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}};
46800 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}};
46801 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}};
46802 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}};
46803 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}};
46804 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}};
46805 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}};
46806 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}};
46807 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}};
46808 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}};
46809 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}};
46810 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}};
46811 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}};
46812 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}};
46813 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}};
46814 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}};
46815 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}};
46816
46817 static swig_type_info *swig_types_initial[] = {
46818 _swigt__p_wxLayoutConstraints,
46819 _swigt__p_wxRealPoint,
46820 _swigt__p_wxSizerItem,
46821 _swigt__p_wxGBSizerItem,
46822 _swigt__p_wxScrollEvent,
46823 _swigt__p_wxEventLoop,
46824 _swigt__p_wxIndividualLayoutConstraint,
46825 _swigt__p_wxSizer,
46826 _swigt__p_wxBoxSizer,
46827 _swigt__p_wxStaticBoxSizer,
46828 _swigt__p_wxGridBagSizer,
46829 _swigt__p_wxAcceleratorEntry,
46830 _swigt__p_wxUpdateUIEvent,
46831 _swigt__p_wxEvent,
46832 _swigt__p_wxMenu,
46833 _swigt__p_wxGridSizer,
46834 _swigt__p_wxFlexGridSizer,
46835 _swigt__p_wxInitDialogEvent,
46836 _swigt__p_wxItemContainer,
46837 _swigt__p_wxNcPaintEvent,
46838 _swigt__p_wxPaintEvent,
46839 _swigt__p_wxSysColourChangedEvent,
46840 _swigt__p_wxMouseCaptureChangedEvent,
46841 _swigt__p_wxDisplayChangedEvent,
46842 _swigt__p_wxPaletteChangedEvent,
46843 _swigt__p_wxControl,
46844 _swigt__p_wxFont,
46845 _swigt__p_wxMenuBarBase,
46846 _swigt__p_wxSetCursorEvent,
46847 _swigt__p_wxFSFile,
46848 _swigt__p_wxCaret,
46849 _swigt__ptrdiff_t,
46850 _swigt__std__ptrdiff_t,
46851 _swigt__p_wxRegion,
46852 _swigt__p_wxPoint2D,
46853 _swigt__p_int,
46854 _swigt__p_wxSize,
46855 _swigt__p_wxDC,
46856 _swigt__p_wxPySizer,
46857 _swigt__p_wxVisualAttributes,
46858 _swigt__p_wxNotifyEvent,
46859 _swigt__p_wxPyEvent,
46860 _swigt__p_wxPropagationDisabler,
46861 _swigt__p_form_ops_t,
46862 _swigt__p_wxAppTraits,
46863 _swigt__p_wxArrayString,
46864 _swigt__p_wxShowEvent,
46865 _swigt__p_wxToolTip,
46866 _swigt__p_wxMoveEvent,
46867 _swigt__p_wxSizeEvent,
46868 _swigt__p_wxActivateEvent,
46869 _swigt__p_wxIconizeEvent,
46870 _swigt__p_wxMaximizeEvent,
46871 _swigt__p_wxQueryNewPaletteEvent,
46872 _swigt__p_wxWindowCreateEvent,
46873 _swigt__p_wxIdleEvent,
46874 _swigt__p_wxDateEvent,
46875 _swigt__p_wxMenuItem,
46876 _swigt__p_wxStaticBox,
46877 _swigt__p_long,
46878 _swigt__p_wxDuplexMode,
46879 _swigt__p_wxTIFFHandler,
46880 _swigt__p_wxXPMHandler,
46881 _swigt__p_wxPNMHandler,
46882 _swigt__p_wxJPEGHandler,
46883 _swigt__p_wxPCXHandler,
46884 _swigt__p_wxGIFHandler,
46885 _swigt__p_wxPNGHandler,
46886 _swigt__p_wxANIHandler,
46887 _swigt__p_wxMemoryFSHandler,
46888 _swigt__p_wxZipFSHandler,
46889 _swigt__p_wxInternetFSHandler,
46890 _swigt__p_wxPyFileSystemHandler,
46891 _swigt__p_wxEvtHandler,
46892 _swigt__p_wxCURHandler,
46893 _swigt__p_wxICOHandler,
46894 _swigt__p_wxBMPHandler,
46895 _swigt__p_wxImageHandler,
46896 _swigt__p_wxFileSystemHandler,
46897 _swigt__p_wxRect,
46898 _swigt__p_wxButton,
46899 _swigt__p_wxGBSpan,
46900 _swigt__p_wxPropagateOnce,
46901 _swigt__p_wxAcceleratorTable,
46902 _swigt__p_wxStdDialogButtonSizer,
46903 _swigt__p_char,
46904 _swigt__p_wxGBPosition,
46905 _swigt__p_wxImage,
46906 _swigt__p_wxFrame,
46907 _swigt__p_wxScrollWinEvent,
46908 _swigt__p_wxPaperSize,
46909 _swigt__p_wxImageHistogram,
46910 _swigt__p_wxPoint,
46911 _swigt__p_wxCursor,
46912 _swigt__p_wxObject,
46913 _swigt__p_wxInputStream,
46914 _swigt__p_wxOutputStream,
46915 _swigt__p_wxPyInputStream,
46916 _swigt__p_wxDateTime,
46917 _swigt__p_wxKeyEvent,
46918 _swigt__p_wxNavigationKeyEvent,
46919 _swigt__p_wxWindowDestroyEvent,
46920 _swigt__p_unsigned_long,
46921 _swigt__p_wxWindow,
46922 _swigt__p_wxMenuBar,
46923 _swigt__p_wxFileSystem,
46924 _swigt__p_wxBitmap,
46925 _swigt__unsigned_int,
46926 _swigt__p_unsigned_int,
46927 _swigt__p_wxMenuEvent,
46928 _swigt__p_wxContextMenuEvent,
46929 _swigt__p_unsigned_char,
46930 _swigt__p_wxEraseEvent,
46931 _swigt__p_wxMouseEvent,
46932 _swigt__p_wxCloseEvent,
46933 _swigt__p_wxPyApp,
46934 _swigt__p_wxCommandEvent,
46935 _swigt__p_wxPyCommandEvent,
46936 _swigt__p_wxPyDropTarget,
46937 _swigt__p_wxQuantize,
46938 _swigt__p_wxChildFocusEvent,
46939 _swigt__p_wxFocusEvent,
46940 _swigt__p_wxDropFilesEvent,
46941 _swigt__p_wxControlWithItems,
46942 _swigt__p_wxColour,
46943 _swigt__p_wxValidator,
46944 _swigt__p_wxPyValidator,
46945 0
46946 };
46947
46948
46949 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46950
46951 static swig_const_info swig_const_table[] = {
46952 {0, 0, 0, 0.0, 0, 0}};
46953
46954 #ifdef __cplusplus
46955 }
46956 #endif
46957
46958
46959 #ifdef __cplusplus
46960 extern "C" {
46961 #endif
46962
46963 /* Python-specific SWIG API */
46964 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46965 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46966 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46967
46968 /* -----------------------------------------------------------------------------
46969 * global variable support code.
46970 * ----------------------------------------------------------------------------- */
46971
46972 typedef struct swig_globalvar {
46973 char *name; /* Name of global variable */
46974 PyObject *(*get_attr)(); /* Return the current value */
46975 int (*set_attr)(PyObject *); /* Set the value */
46976 struct swig_globalvar *next;
46977 } swig_globalvar;
46978
46979 typedef struct swig_varlinkobject {
46980 PyObject_HEAD
46981 swig_globalvar *vars;
46982 } swig_varlinkobject;
46983
46984 static PyObject *
46985 swig_varlink_repr(swig_varlinkobject *v) {
46986 v = v;
46987 return PyString_FromString("<Swig global variables>");
46988 }
46989
46990 static int
46991 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46992 swig_globalvar *var;
46993 flags = flags;
46994 fprintf(fp,"Swig global variables { ");
46995 for (var = v->vars; var; var=var->next) {
46996 fprintf(fp,"%s", var->name);
46997 if (var->next) fprintf(fp,", ");
46998 }
46999 fprintf(fp," }\n");
47000 return 0;
47001 }
47002
47003 static PyObject *
47004 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47005 swig_globalvar *var = v->vars;
47006 while (var) {
47007 if (strcmp(var->name,n) == 0) {
47008 return (*var->get_attr)();
47009 }
47010 var = var->next;
47011 }
47012 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47013 return NULL;
47014 }
47015
47016 static int
47017 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47018 swig_globalvar *var = v->vars;
47019 while (var) {
47020 if (strcmp(var->name,n) == 0) {
47021 return (*var->set_attr)(p);
47022 }
47023 var = var->next;
47024 }
47025 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47026 return 1;
47027 }
47028
47029 static PyTypeObject varlinktype = {
47030 PyObject_HEAD_INIT(0)
47031 0, /* Number of items in variable part (ob_size) */
47032 (char *)"swigvarlink", /* Type name (tp_name) */
47033 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47034 0, /* Itemsize (tp_itemsize) */
47035 0, /* Deallocator (tp_dealloc) */
47036 (printfunc) swig_varlink_print, /* Print (tp_print) */
47037 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47038 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47039 0, /* tp_compare */
47040 (reprfunc) swig_varlink_repr, /* tp_repr */
47041 0, /* tp_as_number */
47042 0, /* tp_as_sequence */
47043 0, /* tp_as_mapping */
47044 0, /* tp_hash */
47045 0, /* tp_call */
47046 0, /* tp_str */
47047 0, /* tp_getattro */
47048 0, /* tp_setattro */
47049 0, /* tp_as_buffer */
47050 0, /* tp_flags */
47051 0, /* tp_doc */
47052 #if PY_VERSION_HEX >= 0x02000000
47053 0, /* tp_traverse */
47054 0, /* tp_clear */
47055 #endif
47056 #if PY_VERSION_HEX >= 0x02010000
47057 0, /* tp_richcompare */
47058 0, /* tp_weaklistoffset */
47059 #endif
47060 #if PY_VERSION_HEX >= 0x02020000
47061 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47062 #endif
47063 #if PY_VERSION_HEX >= 0x02030000
47064 0, /* tp_del */
47065 #endif
47066 #ifdef COUNT_ALLOCS
47067 0,0,0,0 /* tp_alloc -> tp_next */
47068 #endif
47069 };
47070
47071 /* Create a variable linking object for use later */
47072 static PyObject *
47073 SWIG_Python_newvarlink(void) {
47074 swig_varlinkobject *result = 0;
47075 result = PyMem_NEW(swig_varlinkobject,1);
47076 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47077 result->ob_type = &varlinktype;
47078 result->vars = 0;
47079 result->ob_refcnt = 0;
47080 Py_XINCREF((PyObject *) result);
47081 return ((PyObject*) result);
47082 }
47083
47084 static void
47085 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47086 swig_varlinkobject *v;
47087 swig_globalvar *gv;
47088 v= (swig_varlinkobject *) p;
47089 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47090 gv->name = (char *) malloc(strlen(name)+1);
47091 strcpy(gv->name,name);
47092 gv->get_attr = get_attr;
47093 gv->set_attr = set_attr;
47094 gv->next = v->vars;
47095 v->vars = gv;
47096 }
47097
47098 /* -----------------------------------------------------------------------------
47099 * constants/methods manipulation
47100 * ----------------------------------------------------------------------------- */
47101
47102 /* Install Constants */
47103 static void
47104 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47105 PyObject *obj = 0;
47106 size_t i;
47107 for (i = 0; constants[i].type; i++) {
47108 switch(constants[i].type) {
47109 case SWIG_PY_INT:
47110 obj = PyInt_FromLong(constants[i].lvalue);
47111 break;
47112 case SWIG_PY_FLOAT:
47113 obj = PyFloat_FromDouble(constants[i].dvalue);
47114 break;
47115 case SWIG_PY_STRING:
47116 if (constants[i].pvalue) {
47117 obj = PyString_FromString((char *) constants[i].pvalue);
47118 } else {
47119 Py_INCREF(Py_None);
47120 obj = Py_None;
47121 }
47122 break;
47123 case SWIG_PY_POINTER:
47124 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47125 break;
47126 case SWIG_PY_BINARY:
47127 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47128 break;
47129 default:
47130 obj = 0;
47131 break;
47132 }
47133 if (obj) {
47134 PyDict_SetItemString(d,constants[i].name,obj);
47135 Py_DECREF(obj);
47136 }
47137 }
47138 }
47139
47140 /* -----------------------------------------------------------------------------*/
47141 /* Fix SwigMethods to carry the callback ptrs when needed */
47142 /* -----------------------------------------------------------------------------*/
47143
47144 static void
47145 SWIG_Python_FixMethods(PyMethodDef *methods,
47146 swig_const_info *const_table,
47147 swig_type_info **types,
47148 swig_type_info **types_initial) {
47149 size_t i;
47150 for (i = 0; methods[i].ml_name; ++i) {
47151 char *c = methods[i].ml_doc;
47152 if (c && (c = strstr(c, "swig_ptr: "))) {
47153 int j;
47154 swig_const_info *ci = 0;
47155 char *name = c + 10;
47156 for (j = 0; const_table[j].type; j++) {
47157 if (strncmp(const_table[j].name, name,
47158 strlen(const_table[j].name)) == 0) {
47159 ci = &(const_table[j]);
47160 break;
47161 }
47162 }
47163 if (ci) {
47164 size_t shift = (ci->ptype) - types;
47165 swig_type_info *ty = types_initial[shift];
47166 size_t ldoc = (c - methods[i].ml_doc);
47167 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47168 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47169 char *buff = ndoc;
47170 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47171 strncpy(buff, methods[i].ml_doc, ldoc);
47172 buff += ldoc;
47173 strncpy(buff, "swig_ptr: ", 10);
47174 buff += 10;
47175 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47176 methods[i].ml_doc = ndoc;
47177 }
47178 }
47179 }
47180 }
47181
47182 /* -----------------------------------------------------------------------------*
47183 * Initialize type list
47184 * -----------------------------------------------------------------------------*/
47185
47186 #if PY_MAJOR_VERSION < 2
47187 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47188 is copied out of Python/modsupport.c in python version 2.3.4 */
47189 static int
47190 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47191 {
47192 PyObject *dict;
47193 if (!PyModule_Check(m)) {
47194 PyErr_SetString(PyExc_TypeError,
47195 "PyModule_AddObject() needs module as first arg");
47196 return -1;
47197 }
47198 if (!o) {
47199 PyErr_SetString(PyExc_TypeError,
47200 "PyModule_AddObject() needs non-NULL value");
47201 return -1;
47202 }
47203
47204 dict = PyModule_GetDict(m);
47205 if (dict == NULL) {
47206 /* Internal error -- modules must have a dict! */
47207 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47208 PyModule_GetName(m));
47209 return -1;
47210 }
47211 if (PyDict_SetItemString(dict, name, o))
47212 return -1;
47213 Py_DECREF(o);
47214 return 0;
47215 }
47216 #endif
47217
47218 static swig_type_info **
47219 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47220 static PyMethodDef swig_empty_runtime_method_table[] = {
47221 {
47222 NULL, NULL, 0, NULL
47223 }
47224 };/* Sentinel */
47225
47226 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47227 swig_empty_runtime_method_table);
47228 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47229 if (pointer && module) {
47230 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47231 }
47232 return type_list_handle;
47233 }
47234
47235 static swig_type_info **
47236 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47237 swig_type_info **type_pointer;
47238
47239 /* first check if module already created */
47240 type_pointer = SWIG_Python_GetTypeListHandle();
47241 if (type_pointer) {
47242 return type_pointer;
47243 } else {
47244 /* create a new module and variable */
47245 return SWIG_Python_SetTypeListHandle(type_list_handle);
47246 }
47247 }
47248
47249 #ifdef __cplusplus
47250 }
47251 #endif
47252
47253 /* -----------------------------------------------------------------------------*
47254 * Partial Init method
47255 * -----------------------------------------------------------------------------*/
47256
47257 #ifdef SWIG_LINK_RUNTIME
47258 #ifdef __cplusplus
47259 extern "C"
47260 #endif
47261 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47262 #endif
47263
47264 #ifdef __cplusplus
47265 extern "C"
47266 #endif
47267 SWIGEXPORT(void) SWIG_init(void) {
47268 static PyObject *SWIG_globals = 0;
47269 static int typeinit = 0;
47270 PyObject *m, *d;
47271 int i;
47272 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47273
47274 /* Fix SwigMethods to carry the callback ptrs when needed */
47275 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47276
47277 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47278 d = PyModule_GetDict(m);
47279
47280 if (!typeinit) {
47281 #ifdef SWIG_LINK_RUNTIME
47282 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47283 #else
47284 # ifndef SWIG_STATIC_RUNTIME
47285 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47286 # endif
47287 #endif
47288 for (i = 0; swig_types_initial[i]; i++) {
47289 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47290 }
47291 typeinit = 1;
47292 }
47293 SWIG_InstallConstants(d,swig_const_table);
47294
47295
47296 #ifndef wxPyUSE_EXPORT
47297 // Make our API structure a CObject so other modules can import it
47298 // from this module.
47299 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47300 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47301 Py_XDECREF(cobj);
47302 #endif
47303
47304 {
47305 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47306 }
47307 {
47308 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47309 }
47310 {
47311 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47312 }
47313 {
47314 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47315 }
47316 {
47317 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47318 }
47319 {
47320 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47321 }
47322 {
47323 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47324 }
47325 {
47326 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47327 }
47328 {
47329 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47330 }
47331 {
47332 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47333 }
47334 {
47335 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47336 }
47337 {
47338 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47339 }
47340 {
47341 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47342 }
47343 {
47344 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47345 }
47346 {
47347 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47348 }
47349 {
47350 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47351 }
47352 {
47353 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47354 }
47355 {
47356 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47357 }
47358 {
47359 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47360 }
47361 {
47362 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47363 }
47364 {
47365 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47366 }
47367 {
47368 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47369 }
47370 {
47371 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47372 }
47373 {
47374 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47375 }
47376 {
47377 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47378 }
47379 {
47380 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47381 }
47382 {
47383 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47384 }
47385 {
47386 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47387 }
47388 {
47389 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47390 }
47391 {
47392 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47393 }
47394 {
47395 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47396 }
47397 {
47398 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47399 }
47400 {
47401 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47402 }
47403 {
47404 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47405 }
47406 {
47407 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47408 }
47409 {
47410 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47411 }
47412 {
47413 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47414 }
47415 {
47416 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47417 }
47418 {
47419 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47420 }
47421 {
47422 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47423 }
47424 {
47425 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47426 }
47427 {
47428 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47429 }
47430 {
47431 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47432 }
47433 {
47434 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47435 }
47436 {
47437 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47438 }
47439 {
47440 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47441 }
47442 {
47443 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47444 }
47445 {
47446 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47447 }
47448 {
47449 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47450 }
47451 {
47452 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47453 }
47454 {
47455 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47456 }
47457 {
47458 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47459 }
47460 {
47461 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47462 }
47463 {
47464 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47465 }
47466 {
47467 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47468 }
47469 {
47470 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47471 }
47472 {
47473 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47474 }
47475 {
47476 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47477 }
47478 {
47479 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47480 }
47481 {
47482 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47483 }
47484 {
47485 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47486 }
47487 {
47488 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47489 }
47490 {
47491 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47492 }
47493 {
47494 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47495 }
47496 {
47497 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47498 }
47499 {
47500 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47501 }
47502 {
47503 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47504 }
47505 {
47506 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47507 }
47508 {
47509 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47510 }
47511 {
47512 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47513 }
47514 {
47515 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47516 }
47517 {
47518 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47519 }
47520 {
47521 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47522 }
47523 {
47524 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47525 }
47526 {
47527 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47528 }
47529 {
47530 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47531 }
47532 {
47533 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47534 }
47535 {
47536 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47537 }
47538 {
47539 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47540 }
47541 {
47542 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47543 }
47544 {
47545 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47546 }
47547 {
47548 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47549 }
47550 {
47551 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47552 }
47553 {
47554 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47555 }
47556 {
47557 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47558 }
47559 {
47560 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47561 }
47562 {
47563 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47564 }
47565 {
47566 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47567 }
47568 {
47569 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47570 }
47571 {
47572 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47573 }
47574 {
47575 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47576 }
47577 {
47578 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47579 }
47580 {
47581 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47582 }
47583 {
47584 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47585 }
47586 {
47587 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47588 }
47589 {
47590 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47591 }
47592 {
47593 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47594 }
47595 {
47596 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47597 }
47598 {
47599 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47600 }
47601 {
47602 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47603 }
47604 {
47605 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47606 }
47607 {
47608 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47609 }
47610 {
47611 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47612 }
47613 {
47614 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47615 }
47616 {
47617 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47618 }
47619 {
47620 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47621 }
47622 {
47623 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47624 }
47625 {
47626 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47627 }
47628 {
47629 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47630 }
47631 {
47632 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47633 }
47634 {
47635 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47636 }
47637 {
47638 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47639 }
47640 {
47641 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47642 }
47643 {
47644 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47645 }
47646 {
47647 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47648 }
47649 {
47650 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47651 }
47652 {
47653 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47654 }
47655 {
47656 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47657 }
47658 {
47659 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47660 }
47661 {
47662 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47663 }
47664 {
47665 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47666 }
47667 {
47668 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47669 }
47670 {
47671 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47672 }
47673 {
47674 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47675 }
47676 {
47677 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47678 }
47679 {
47680 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47681 }
47682 {
47683 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47684 }
47685 {
47686 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47687 }
47688 {
47689 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47690 }
47691 {
47692 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47693 }
47694 {
47695 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47696 }
47697 {
47698 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47699 }
47700 {
47701 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47702 }
47703 {
47704 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47705 }
47706 {
47707 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47708 }
47709 {
47710 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47711 }
47712 {
47713 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47714 }
47715 {
47716 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47717 }
47718 {
47719 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47720 }
47721 {
47722 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47723 }
47724 {
47725 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47726 }
47727 {
47728 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47729 }
47730 {
47731 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47732 }
47733 {
47734 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47735 }
47736 {
47737 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47738 }
47739 {
47740 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47741 }
47742 {
47743 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47744 }
47745 {
47746 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47747 }
47748 {
47749 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47750 }
47751 {
47752 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47753 }
47754 {
47755 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47756 }
47757 {
47758 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47759 }
47760 {
47761 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47762 }
47763 {
47764 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47765 }
47766 {
47767 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47768 }
47769 {
47770 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47771 }
47772 {
47773 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47774 }
47775 {
47776 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47777 }
47778 {
47779 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47780 }
47781 {
47782 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47783 }
47784 {
47785 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47786 }
47787 {
47788 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47789 }
47790 {
47791 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47792 }
47793 {
47794 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47795 }
47796 {
47797 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47798 }
47799 {
47800 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47804 }
47805 {
47806 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47807 }
47808 {
47809 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47810 }
47811 {
47812 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47813 }
47814 {
47815 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47816 }
47817 {
47818 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47819 }
47820 {
47821 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47936 }
47937 {
47938 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47939 }
47940 {
47941 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47942 }
47943 {
47944 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47945 }
47946 {
47947 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47948 }
47949 {
47950 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47951 }
47952 {
47953 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47954 }
47955 {
47956 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47957 }
47958 {
47959 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47972 }
47973 {
47974 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47975 }
47976 {
47977 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47978 }
47979 {
47980 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47981 }
47982 {
47983 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47984 }
47985 {
47986 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47987 }
47988 {
47989 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47990 }
47991 {
47992 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47993 }
47994 {
47995 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47996 }
47997 {
47998 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48041 }
48042 {
48043 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48044 }
48045 {
48046 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48047 }
48048 {
48049 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48050 }
48051 {
48052 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48053 }
48054 {
48055 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48056 }
48057 {
48058 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48059 }
48060 {
48061 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48062 }
48063 {
48064 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48065 }
48066 {
48067 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48068 }
48069 {
48070 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48071 }
48072 {
48073 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48074 }
48075 {
48076 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48077 }
48078 {
48079 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48080 }
48081 {
48082 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48083 }
48084 {
48085 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48086 }
48087 {
48088 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48089 }
48090 {
48091 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48092 }
48093 {
48094 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48095 }
48096 {
48097 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48326 }
48327 {
48328 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48329 }
48330 {
48331 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48344 }
48345 {
48346 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48347 }
48348 {
48349 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48350 }
48351 {
48352 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48353 }
48354 {
48355 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48356 }
48357 {
48358 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48416 }
48417 {
48418 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48419 }
48420 {
48421 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48422 }
48423 {
48424 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48425 }
48426 {
48427 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48428 }
48429 {
48430 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48431 }
48432 {
48433 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48434 }
48435 {
48436 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48437 }
48438 {
48439 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48440 }
48441 {
48442 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48443 }
48444 {
48445 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48446 }
48447 {
48448 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48449 }
48450 {
48451 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48908 }
48909 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48910 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48911 {
48912 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48913 }
48914 {
48915 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48922 }
48923 {
48924 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48925 }
48926 {
48927 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48928 }
48929 {
48930 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48931 }
48932 {
48933 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48934 }
48935 {
48936 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48937 }
48938 {
48939 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48940 }
48941 {
48942 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48943 }
48944 {
48945 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48946 }
48947 {
48948 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48949 }
48950 {
48951 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48952 }
48953 {
48954 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48955 }
48956 {
48957 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48964 }
48965 {
48966 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48967 }
48968 {
48969 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48970 }
48971 {
48972 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48973 }
48974 {
48975 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48976 }
48977 {
48978 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48979 }
48980 {
48981 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48982 }
48983 {
48984 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48985 }
48986 {
48987 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48988 }
48989 {
48990 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48991 }
48992 {
48993 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48994 }
48995 {
48996 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48997 }
48998 {
48999 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49000 }
49001 {
49002 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49003 }
49004 {
49005 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49006 }
49007 {
49008 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49009 }
49010 {
49011 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49012 }
49013 {
49014 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49015 }
49016 {
49017 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49018 }
49019 {
49020 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49024 }
49025 {
49026 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49027 }
49028 {
49029 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49030 }
49031 {
49032 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49039 }
49040 {
49041 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49042 }
49043 {
49044 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49045 }
49046 {
49047 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49054 }
49055 {
49056 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49057 }
49058 {
49059 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49060 }
49061 {
49062 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49063 }
49064 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49065 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49066 {
49067 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49074 }
49075
49076 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49077
49078
49079 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49080
49081 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49082 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49083 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49084 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49085 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49086 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49087 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49088 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49089 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49090 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49091 {
49092 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49096 }
49097 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49098 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49099 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49100 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49101 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49102 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49103 {
49104 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49150 }
49151 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49152 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49153 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49154 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49155 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49156 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49157 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49158 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49159 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49160 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49161 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49162 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49163 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49164 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49165 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49166 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49167 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49168 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49169 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49170 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49171 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49172 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49173 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49174 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49175 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49176 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49177 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49178 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49179 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49180 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49181 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49182 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49183 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49184 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49185 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49186 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49187 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49188 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49189 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49190 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49191 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49192 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49193 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49194 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49195 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49196 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49197 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49198 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49199 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49200 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49201 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49202 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49203 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49204 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49205 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49206 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49207 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49208 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49209 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49210 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49211 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49212 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49213 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49214 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49215 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49216 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49217 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49218 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49219 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49220 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49221 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49222 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49223 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49224 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49225 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49226 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49227 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49228 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49229 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49230 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49231 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49232 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49233 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49234 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49235 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49236 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49237 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49238 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49239 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49240 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49241 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49242 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49243 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49244 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49245 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49246 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49247 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49248 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49249 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49250 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49251 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49252 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49253 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49254 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49255 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49256 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49257 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49258 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49259 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49260 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49261 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49262 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49263 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49264 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49265 {
49266 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49303 }
49304 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49305 {
49306 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49307 }
49308 {
49309 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49310 }
49311 {
49312 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49313 }
49314 {
49315 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49316 }
49317 {
49318 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49319 }
49320 {
49321 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49322 }
49323 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49324 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49325 {
49326 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49339 }
49340 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49341 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49342 {
49343 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49350 }
49351 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49352 {
49353 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49408 }
49409
49410 // Initialize threading, some globals and such
49411 __wxPyPreStart(d);
49412
49413
49414 // Although these are defined in __version__ they need to be here too so
49415 // that an assert can be done to ensure that the wxPython and the wxWindows
49416 // versions match.
49417 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49418 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49419 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49420
49421 }
49422
wxWidgets (Impactor)