]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Assert correction.
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_int swig_types[36]
1379 #define SWIGTYPE_p_wxSize swig_types[37]
1380 #define SWIGTYPE_p_wxDC swig_types[38]
1381 #define SWIGTYPE_p_wxPySizer swig_types[39]
1382 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1383 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1384 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1385 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1388 #define SWIGTYPE_p_wxArrayString swig_types[46]
1389 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1390 #define SWIGTYPE_p_wxToolTip swig_types[48]
1391 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1392 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1393 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1394 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1396 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1397 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1398 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1399 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1401 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1402 #define SWIGTYPE_p_long swig_types[60]
1403 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1404 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1405 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1406 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1407 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1409 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1411 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1412 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1413 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1414 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1415 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1416 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1417 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1418 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1419 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1420 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1421 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1422 #define SWIGTYPE_p_wxRect swig_types[80]
1423 #define SWIGTYPE_p_wxButton swig_types[81]
1424 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1425 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1426 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1427 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1428 #define SWIGTYPE_p_char swig_types[86]
1429 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1430 #define SWIGTYPE_p_wxImage swig_types[88]
1431 #define SWIGTYPE_p_wxFrame swig_types[89]
1432 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1434 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1435 #define SWIGTYPE_p_wxPoint swig_types[93]
1436 #define SWIGTYPE_p_wxCursor swig_types[94]
1437 #define SWIGTYPE_p_wxObject swig_types[95]
1438 #define SWIGTYPE_p_wxInputStream swig_types[96]
1439 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1440 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1441 #define SWIGTYPE_p_wxDateTime swig_types[99]
1442 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1443 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1444 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1445 #define SWIGTYPE_p_unsigned_long swig_types[103]
1446 #define SWIGTYPE_p_wxWindow swig_types[104]
1447 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1448 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1449 #define SWIGTYPE_p_wxBitmap swig_types[107]
1450 #define SWIGTYPE_unsigned_int swig_types[108]
1451 #define SWIGTYPE_p_unsigned_int swig_types[109]
1452 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1453 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1454 #define SWIGTYPE_p_unsigned_char swig_types[112]
1455 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1456 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1457 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1458 #define SWIGTYPE_p_wxPyApp swig_types[116]
1459 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1460 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1462 #define SWIGTYPE_p_wxQuantize swig_types[120]
1463 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1464 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1465 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1466 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1467 #define SWIGTYPE_p_wxColour swig_types[125]
1468 #define SWIGTYPE_p_wxValidator swig_types[126]
1469 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1470 static swig_type_info *swig_types[129];
1471
1472 /* -------- TYPES TABLE (END) -------- */
1473
1474
1475 /*-----------------------------------------------
1476 @(target):= _core_.so
1477 ------------------------------------------------*/
1478 #define SWIG_init init_core_
1479
1480 #define SWIG_name "_core_"
1481
1482 #include "wx/wxPython/wxPython_int.h"
1483 #include "wx/wxPython/pyclasses.h"
1484
1485
1486 #ifndef wxPyUSE_EXPORT
1487 // Helper functions for dealing with SWIG objects and such. These are
1488 // located here so they know about the SWIG types and functions declared
1489 // in the wrapper code.
1490
1491 #include <wx/hashmap.h>
1492 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1493
1494
1495 // Maintains a hashmap of className to swig_type_info pointers. Given the
1496 // name of a class either looks up the type info in the cache, or scans the
1497 // SWIG tables for it.
1498 extern PyObject* wxPyPtrTypeMap;
1499 static
1500 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1501
1502 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1503
1504 if (typeInfoCache == NULL)
1505 typeInfoCache = new wxPyTypeInfoHashMap;
1506
1507 wxString name(className);
1508 swig_type_info* swigType = (*typeInfoCache)[name];
1509
1510 if (! swigType) {
1511 // it wasn't in the cache, so look it up from SWIG
1512 name.Append(wxT(" *"));
1513 swigType = SWIG_TypeQuery(name.mb_str());
1514
1515 // if it still wasn't found, try looking for a mapped name
1516 if (!swigType) {
1517 PyObject* item;
1518 name = className;
1519
1520 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1521 (char*)(const char*)name.mbc_str())) != NULL) {
1522 name = wxString(PyString_AsString(item), *wxConvCurrent);
1523 name.Append(wxT(" *"));
1524 swigType = SWIG_TypeQuery(name.mb_str());
1525 }
1526 }
1527 if (swigType) {
1528 // and add it to the map if found
1529 (*typeInfoCache)[className] = swigType;
1530 }
1531 }
1532 return swigType;
1533 }
1534
1535
1536 // Check if a class name is a type known to SWIG
1537 bool wxPyCheckSwigType(const wxChar* className) {
1538
1539 swig_type_info* swigType = wxPyFindSwigType(className);
1540 return swigType != NULL;
1541 }
1542
1543
1544 // Given a pointer to a C++ object and a class name, construct a Python proxy
1545 // object for it.
1546 PyObject* wxPyConstructObject(void* ptr,
1547 const wxChar* className,
1548 int setThisOwn) {
1549
1550 swig_type_info* swigType = wxPyFindSwigType(className);
1551 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1552
1553 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1554 }
1555
1556
1557 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1558 // Ensures that the proxy object is of the specified (or derived) type. If
1559 // not able to perform the conversion then a Python exception is set and the
1560 // error should be handled properly in the caller. Returns True on success.
1561 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1562 const wxChar* className) {
1563
1564 swig_type_info* swigType = wxPyFindSwigType(className);
1565 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1566
1567 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1568 }
1569
1570
1571 // Make a SWIGified pointer object suitable for a .this attribute
1572 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1573
1574 PyObject* robj = NULL;
1575
1576 swig_type_info* swigType = wxPyFindSwigType(className);
1577 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1578
1579 #ifdef SWIG_COBJECT_TYPES
1580 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1581 #else
1582 {
1583 char result[1024];
1584 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1585 PyString_FromString(result) : 0;
1586 }
1587 #endif
1588
1589 return robj;
1590 }
1591
1592
1593
1594
1595 // Export a C API in a struct. Other modules will be able to load this from
1596 // the wx._core_ module and will then have safe access to these functions,
1597 // even if they are located in another shared library.
1598 static wxPyCoreAPI API = {
1599
1600 wxPyCheckSwigType,
1601 wxPyConstructObject,
1602 wxPyConvertSwigPtr,
1603 wxPyMakeSwigPtr,
1604
1605 wxPyBeginAllowThreads,
1606 wxPyEndAllowThreads,
1607 wxPyBeginBlockThreads,
1608 wxPyEndBlockThreads,
1609
1610 wxPy_ConvertList,
1611
1612 wxString_in_helper,
1613 Py2wxString,
1614 wx2PyString,
1615
1616 byte_LIST_helper,
1617 int_LIST_helper,
1618 long_LIST_helper,
1619 string_LIST_helper,
1620 wxPoint_LIST_helper,
1621 wxBitmap_LIST_helper,
1622 wxString_LIST_helper,
1623 wxAcceleratorEntry_LIST_helper,
1624
1625 wxSize_helper,
1626 wxPoint_helper,
1627 wxRealPoint_helper,
1628 wxRect_helper,
1629 wxColour_helper,
1630 wxPoint2D_helper,
1631
1632 wxPySimple_typecheck,
1633 wxColour_typecheck,
1634
1635 wxPyCBH_setCallbackInfo,
1636 wxPyCBH_findCallback,
1637 wxPyCBH_callCallback,
1638 wxPyCBH_callCallbackObj,
1639 wxPyCBH_delete,
1640
1641 wxPyMake_wxObject,
1642 wxPyMake_wxSizer,
1643 wxPyPtrTypeMap_Add,
1644 wxPy2int_seq_helper,
1645 wxPy4int_seq_helper,
1646 wxArrayString2PyList_helper,
1647 wxArrayInt2PyList_helper,
1648
1649 wxPyClientData_dtor,
1650 wxPyUserData_dtor,
1651 wxPyOORClientData_dtor,
1652
1653 wxPyCBInputStream_create,
1654 wxPyCBInputStream_copy,
1655
1656 wxPyInstance_Check,
1657 wxPySwigInstance_Check,
1658
1659 wxPyCheckForApp
1660
1661 };
1662
1663 #endif
1664
1665
1666 #if !WXWIN_COMPATIBILITY_2_4
1667 #define wxHIDE_READONLY 0
1668 #endif
1669
1670
1671 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1672 #define SWIG_From_int PyInt_FromLong
1673 /*@@*/
1674
1675
1676 #if ! wxUSE_HOTKEY
1677 enum wxHotkeyModifier
1678 {
1679 wxMOD_NONE = 0,
1680 wxMOD_ALT = 1,
1681 wxMOD_CONTROL = 2,
1682 wxMOD_SHIFT = 4,
1683 wxMOD_WIN = 8
1684 };
1685 #define wxEVT_HOTKEY 9999
1686 #endif
1687
1688 static const wxString wxPyEmptyString(wxEmptyString);
1689 static wxString wxObject_GetClassName(wxObject *self){
1690 return self->GetClassInfo()->GetClassName();
1691 }
1692 static void wxObject_Destroy(wxObject *self){
1693 delete self;
1694 }
1695
1696 #ifndef __WXMAC__
1697 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1698 #endif
1699
1700
1701 #include <limits.h>
1702
1703
1704 SWIGINTERN int
1705 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1706 const char *errmsg)
1707 {
1708 if (value < min_value) {
1709 if (errmsg) {
1710 PyErr_Format(PyExc_OverflowError,
1711 "value %ld is less than '%s' minimum %ld",
1712 value, errmsg, min_value);
1713 }
1714 return 0;
1715 } else if (value > max_value) {
1716 if (errmsg) {
1717 PyErr_Format(PyExc_OverflowError,
1718 "value %ld is greater than '%s' maximum %ld",
1719 value, errmsg, max_value);
1720 }
1721 return 0;
1722 }
1723 return 1;
1724 }
1725
1726
1727 SWIGINTERN int
1728 SWIG_AsVal_long(PyObject* obj, long* val)
1729 {
1730 if (PyNumber_Check(obj)) {
1731 if (val) *val = PyInt_AsLong(obj);
1732 return 1;
1733 }
1734 else {
1735 SWIG_type_error("number", obj);
1736 }
1737 return 0;
1738 }
1739
1740
1741 #if INT_MAX != LONG_MAX
1742 SWIGINTERN int
1743 SWIG_AsVal_int(PyObject *obj, int *val)
1744 {
1745 const char* errmsg = val ? "int" : (char*)0;
1746 long v;
1747 if (SWIG_AsVal_long(obj, &v)) {
1748 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1749 if (val) *val = (int)(v);
1750 return 1;
1751 } else {
1752 return 0;
1753 }
1754 } else {
1755 PyErr_Clear();
1756 }
1757 if (val) {
1758 SWIG_type_error(errmsg, obj);
1759 }
1760 return 0;
1761 }
1762 #else
1763 SWIGINTERNSHORT int
1764 SWIG_AsVal_int(PyObject *obj, int *val)
1765 {
1766 return SWIG_AsVal_long(obj,(long*)val);
1767 }
1768 #endif
1769
1770
1771 SWIGINTERNSHORT int
1772 SWIG_As_int(PyObject* obj)
1773 {
1774 int v;
1775 if (!SWIG_AsVal_int(obj, &v)) {
1776 /*
1777 this is needed to make valgrind/purify happier.
1778 */
1779 memset((void*)&v, 0, sizeof(int));
1780 }
1781 return v;
1782 }
1783
1784
1785 SWIGINTERNSHORT int
1786 SWIG_Check_int(PyObject* obj)
1787 {
1788 return SWIG_AsVal_int(obj, (int*)0);
1789 }
1790
1791 static PyObject *wxSize_Get(wxSize *self){
1792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1793 PyObject* tup = PyTuple_New(2);
1794 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1795 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1796 wxPyEndBlockThreads(blocked);
1797 return tup;
1798 }
1799
1800 SWIGINTERN int
1801 SWIG_AsVal_double(PyObject *obj, double* val)
1802 {
1803 if (PyNumber_Check(obj)) {
1804 if (val) *val = PyFloat_AsDouble(obj);
1805 return 1;
1806 }
1807 else {
1808 SWIG_type_error("number", obj);
1809 }
1810 return 0;
1811 }
1812
1813
1814 SWIGINTERNSHORT double
1815 SWIG_As_double(PyObject* obj)
1816 {
1817 double v;
1818 if (!SWIG_AsVal_double(obj, &v)) {
1819 /*
1820 this is needed to make valgrind/purify happier.
1821 */
1822 memset((void*)&v, 0, sizeof(double));
1823 }
1824 return v;
1825 }
1826
1827
1828 SWIGINTERNSHORT int
1829 SWIG_Check_double(PyObject* obj)
1830 {
1831 return SWIG_AsVal_double(obj, (double*)0);
1832 }
1833
1834
1835 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1836 #define SWIG_From_double PyFloat_FromDouble
1837 /*@@*/
1838
1839 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1840 self->x = x;
1841 self->y = y;
1842 }
1843 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 PyObject* tup = PyTuple_New(2);
1846 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1847 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1848 wxPyEndBlockThreads(blocked);
1849 return tup;
1850 }
1851
1852 SWIGINTERNSHORT long
1853 SWIG_As_long(PyObject* obj)
1854 {
1855 long v;
1856 if (!SWIG_AsVal_long(obj, &v)) {
1857 /*
1858 this is needed to make valgrind/purify happier.
1859 */
1860 memset((void*)&v, 0, sizeof(long));
1861 }
1862 return v;
1863 }
1864
1865
1866 SWIGINTERNSHORT int
1867 SWIG_Check_long(PyObject* obj)
1868 {
1869 return SWIG_AsVal_long(obj, (long*)0);
1870 }
1871
1872 static void wxPoint_Set(wxPoint *self,long x,long y){
1873 self->x = x;
1874 self->y = y;
1875 }
1876 static PyObject *wxPoint_Get(wxPoint *self){
1877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1878 PyObject* tup = PyTuple_New(2);
1879 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1880 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1881 wxPyEndBlockThreads(blocked);
1882 return tup;
1883 }
1884 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1885 self->x = x;
1886 self->y = y;
1887 self->width = width;
1888 self->height = height;
1889 }
1890 static PyObject *wxRect_Get(wxRect *self){
1891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1892 PyObject* tup = PyTuple_New(4);
1893 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1894 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1895 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1896 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1897 wxPyEndBlockThreads(blocked);
1898 return tup;
1899 }
1900
1901 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1902 wxRegion reg1(*r1);
1903 wxRegion reg2(*r2);
1904 wxRect dest(0,0,0,0);
1905 PyObject* obj;
1906
1907 reg1.Intersect(reg2);
1908 dest = reg1.GetBox();
1909
1910 if (dest != wxRect(0,0,0,0)) {
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1912 wxRect* newRect = new wxRect(dest);
1913 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1914 wxPyEndBlockThreads(blocked);
1915 return obj;
1916 }
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920
1921
1922 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1923 PyObject* o2;
1924 PyObject* o3;
1925
1926 if (!target) {
1927 target = o;
1928 } else if (target == Py_None) {
1929 Py_DECREF(Py_None);
1930 target = o;
1931 } else {
1932 if (!PyTuple_Check(target)) {
1933 o2 = target;
1934 target = PyTuple_New(1);
1935 PyTuple_SetItem(target, 0, o2);
1936 }
1937 o3 = PyTuple_New(1);
1938 PyTuple_SetItem(o3, 0, o);
1939
1940 o2 = target;
1941 target = PySequence_Concat(o2, o3);
1942 Py_DECREF(o2);
1943 Py_DECREF(o3);
1944 }
1945 return target;
1946 }
1947
1948
1949 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1950 self->m_x = x;
1951 self->m_y = y;
1952 }
1953 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1954 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1955 PyObject* tup = PyTuple_New(2);
1956 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1957 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1958 wxPyEndBlockThreads(blocked);
1959 return tup;
1960 }
1961
1962 #include "wx/wxPython/pyistream.h"
1963
1964 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1965 wxInputStream* wxis = wxPyCBInputStream::create(p);
1966 if (wxis)
1967 return new wxPyInputStream(wxis);
1968 else
1969 return NULL;
1970 }
1971
1972 SWIGINTERNSHORT PyObject*
1973 SWIG_From_char(char c)
1974 {
1975 return PyString_FromStringAndSize(&c,1);
1976 }
1977
1978
1979 SWIGINTERNSHORT PyObject*
1980 SWIG_From_unsigned_SS_long(unsigned long value)
1981 {
1982 return (value > LONG_MAX) ?
1983 PyLong_FromUnsignedLong(value)
1984 : PyInt_FromLong((long)(value));
1985 }
1986
1987
1988 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1989 SWIGINTERN int
1990 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1991 {
1992 static swig_type_info* pchar_info = 0;
1993 char* vptr = 0;
1994 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1995 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1996 if (cptr) *cptr = vptr;
1997 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1998 return SWIG_OLDOBJ;
1999 } else {
2000 PyErr_Clear();
2001 if (PyString_Check(obj)) {
2002 if (cptr) {
2003 *cptr = PyString_AS_STRING(obj);
2004 if (psize) {
2005 *psize = PyString_GET_SIZE(obj) + 1;
2006 }
2007 }
2008 return SWIG_PYSTR;
2009 }
2010 }
2011 if (cptr) {
2012 SWIG_type_error("char *", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERN int
2019 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2020 {
2021 char* cptr; size_t csize;
2022 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2023 /* in C you can do:
2024
2025 char x[5] = "hello";
2026
2027 ie, assing the array using an extra '0' char.
2028 */
2029 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2030 if (csize <= size) {
2031 if (val) {
2032 if (csize) memcpy(val, cptr, csize);
2033 if (csize < size) memset(val + csize, 0, size - csize);
2034 }
2035 return 1;
2036 }
2037 }
2038 if (val) {
2039 PyErr_Format(PyExc_TypeError,
2040 "a char array of maximum size %lu is expected",
2041 (unsigned long) size);
2042 }
2043 return 0;
2044 }
2045
2046
2047 SWIGINTERN int
2048 SWIG_AsVal_char(PyObject *obj, char *val)
2049 {
2050 const char* errmsg = val ? "char" : (char*)0;
2051 long v;
2052 if (SWIG_AsVal_long(obj, &v)) {
2053 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2054 if (val) *val = (char)(v);
2055 return 1;
2056 } else {
2057 return 0;
2058 }
2059 } else {
2060 PyErr_Clear();
2061 return SWIG_AsCharArray(obj, val, 1);
2062 }
2063 }
2064
2065
2066 SWIGINTERNSHORT char
2067 SWIG_As_char(PyObject* obj)
2068 {
2069 char v;
2070 if (!SWIG_AsVal_char(obj, &v)) {
2071 /*
2072 this is needed to make valgrind/purify happier.
2073 */
2074 memset((void*)&v, 0, sizeof(char));
2075 }
2076 return v;
2077 }
2078
2079
2080 SWIGINTERNSHORT int
2081 SWIG_Check_char(PyObject* obj)
2082 {
2083 return SWIG_AsVal_char(obj, (char*)0);
2084 }
2085
2086
2087 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2088 #define SWIG_From_long PyInt_FromLong
2089 /*@@*/
2090
2091 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2092 // We use only strings for the streams, not unicode
2093 PyObject* str = PyObject_Str(obj);
2094 if (! str) {
2095 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2096 return;
2097 }
2098 self->Write(PyString_AS_STRING(str),
2099 PyString_GET_SIZE(str));
2100 Py_DECREF(str);
2101 }
2102
2103 #include "wx/wxPython/pyistream.h"
2104
2105
2106 class wxPyFileSystemHandler : public wxFileSystemHandler
2107 {
2108 public:
2109 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2110
2111 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2112 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2113 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2114 DEC_PYCALLBACK_STRING__pure(FindNext);
2115
2116 wxString GetProtocol(const wxString& location) {
2117 return wxFileSystemHandler::GetProtocol(location);
2118 }
2119
2120 wxString GetLeftLocation(const wxString& location) {
2121 return wxFileSystemHandler::GetLeftLocation(location);
2122 }
2123
2124 wxString GetAnchor(const wxString& location) {
2125 return wxFileSystemHandler::GetAnchor(location);
2126 }
2127
2128 wxString GetRightLocation(const wxString& location) {
2129 return wxFileSystemHandler::GetRightLocation(location);
2130 }
2131
2132 wxString GetMimeTypeFromExt(const wxString& location) {
2133 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2134 }
2135
2136 PYPRIVATE;
2137 };
2138
2139
2140 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2141 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2142 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2143 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2144
2145
2146 SWIGINTERN int
2147 SWIG_AsVal_bool(PyObject *obj, bool *val)
2148 {
2149 if (obj == Py_True) {
2150 if (val) *val = true;
2151 return 1;
2152 }
2153 if (obj == Py_False) {
2154 if (val) *val = false;
2155 return 1;
2156 }
2157 int res = 0;
2158 if (SWIG_AsVal_int(obj, &res)) {
2159 if (val) *val = res ? true : false;
2160 return 1;
2161 } else {
2162 PyErr_Clear();
2163 }
2164 if (val) {
2165 SWIG_type_error("bool", obj);
2166 }
2167 return 0;
2168 }
2169
2170
2171 SWIGINTERNSHORT bool
2172 SWIG_As_bool(PyObject* obj)
2173 {
2174 bool v;
2175 if (!SWIG_AsVal_bool(obj, &v)) {
2176 /*
2177 this is needed to make valgrind/purify happier.
2178 */
2179 memset((void*)&v, 0, sizeof(bool));
2180 }
2181 return v;
2182 }
2183
2184
2185 SWIGINTERNSHORT int
2186 SWIG_Check_bool(PyObject* obj)
2187 {
2188 return SWIG_AsVal_bool(obj, (bool*)0);
2189 }
2190
2191 static wxString FileSystem_URLToFileName(wxString const &url){
2192 wxFileName fname = wxFileSystem::URLToFileName(url);
2193 return fname.GetFullPath();
2194 }
2195
2196 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2197 wxImage& image,
2198 long type) {
2199 wxMemoryFSHandler::AddFile(filename, image, type);
2200 }
2201
2202 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2203 const wxBitmap& bitmap,
2204 long type) {
2205 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2206 }
2207
2208 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2209 PyObject* data) {
2210 if (! PyString_Check(data)) {
2211 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2212 "Expected string object"));
2213 return;
2214 }
2215
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 void* ptr = (void*)PyString_AsString(data);
2218 size_t size = PyString_Size(data);
2219 wxPyEndBlockThreads(blocked);
2220
2221 wxMemoryFSHandler::AddFile(filename, ptr, size);
2222 }
2223
2224
2225 #include "wx/wxPython/pyistream.h"
2226
2227
2228 SWIGINTERN int
2229 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2230 {
2231 long v = 0;
2232 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2233 SWIG_type_error("unsigned number", obj);
2234 }
2235 else if (val)
2236 *val = (unsigned long)v;
2237 return 1;
2238 }
2239
2240
2241 SWIGINTERNSHORT int
2242 SWIG_CheckUnsignedLongInRange(unsigned long value,
2243 unsigned long max_value,
2244 const char *errmsg)
2245 {
2246 if (value > max_value) {
2247 if (errmsg) {
2248 PyErr_Format(PyExc_OverflowError,
2249 "value %lu is greater than '%s' minimum %lu",
2250 value, errmsg, max_value);
2251 }
2252 return 0;
2253 }
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERN int
2259 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2260 {
2261 const char* errmsg = val ? "unsigned char" : (char*)0;
2262 unsigned long v;
2263 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2264 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2265 if (val) *val = (unsigned char)(v);
2266 return 1;
2267 } else {
2268 return 0;
2269 }
2270 } else {
2271 PyErr_Clear();
2272 }
2273 if (val) {
2274 SWIG_type_error(errmsg, obj);
2275 }
2276 return 0;
2277 }
2278
2279
2280 SWIGINTERNSHORT unsigned char
2281 SWIG_As_unsigned_SS_char(PyObject* obj)
2282 {
2283 unsigned char v;
2284 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2285 /*
2286 this is needed to make valgrind/purify happier.
2287 */
2288 memset((void*)&v, 0, sizeof(unsigned char));
2289 }
2290 return v;
2291 }
2292
2293
2294 SWIGINTERNSHORT int
2295 SWIG_Check_unsigned_SS_char(PyObject* obj)
2296 {
2297 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2298 }
2299
2300
2301 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2302 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2303 /*@@*/
2304
2305
2306
2307 SWIGINTERNSHORT unsigned long
2308 SWIG_As_unsigned_SS_long(PyObject* obj)
2309 {
2310 unsigned long v;
2311 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2312 /*
2313 this is needed to make valgrind/purify happier.
2314 */
2315 memset((void*)&v, 0, sizeof(unsigned long));
2316 }
2317 return v;
2318 }
2319
2320
2321 SWIGINTERNSHORT int
2322 SWIG_Check_unsigned_SS_long(PyObject* obj)
2323 {
2324 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2325 }
2326
2327 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2328 wxImageHistogramEntry e = (*self)[key];
2329 return e.value;
2330 }
2331 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2332 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2333 wxImageHistogramEntry e = (*self)[key];
2334 return e.value;
2335 }
2336 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2337 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2338 colour.Green(),
2339 colour.Blue());
2340 wxImageHistogramEntry e = (*self)[key];
2341 return e.value;
2342 }
2343
2344 typedef unsigned char* buffer;
2345
2346 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2347 if (width > 0 && height > 0)
2348 return new wxImage(width, height, clear);
2349 else
2350 return new wxImage;
2351 }
2352 static wxImage *new_wxImage(wxBitmap const &bitmap){
2353 return new wxImage(bitmap.ConvertToImage());
2354 }
2355 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2356 if (DATASIZE != width*height*3) {
2357 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2358 return NULL;
2359 }
2360
2361 // Copy the source data so the wxImage can clean it up later
2362 buffer copy = (buffer)malloc(DATASIZE);
2363 if (copy == NULL) {
2364 wxPyBLOCK_THREADS(PyErr_NoMemory());
2365 return NULL;
2366 }
2367 memcpy(copy, data, DATASIZE);
2368 return new wxImage(width, height, copy, false);
2369 }
2370 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2371 if (DATASIZE != width*height*3) {
2372 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2373 return NULL;
2374 }
2375 if (ALPHASIZE != width*height) {
2376 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2377 return NULL;
2378 }
2379
2380 // Copy the source data so the wxImage can clean it up later
2381 buffer dcopy = (buffer)malloc(DATASIZE);
2382 if (dcopy == NULL) {
2383 wxPyBLOCK_THREADS(PyErr_NoMemory());
2384 return NULL;
2385 }
2386 memcpy(dcopy, data, DATASIZE);
2387
2388 buffer acopy = (buffer)malloc(ALPHASIZE);
2389 if (acopy == NULL) {
2390 wxPyBLOCK_THREADS(PyErr_NoMemory());
2391 return NULL;
2392 }
2393 memcpy(acopy, alpha, ALPHASIZE);
2394
2395 return new wxImage(width, height, dcopy, acopy, false);
2396 }
2397 static wxSize wxImage_GetSize(wxImage *self){
2398 wxSize size(self->GetWidth(), self->GetHeight());
2399 return size;
2400 }
2401 static PyObject *wxImage_GetData(wxImage *self){
2402 buffer data = self->GetData();
2403 int len = self->GetWidth() * self->GetHeight() * 3;
2404 PyObject* rv;
2405 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2406 return rv;
2407 }
2408 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2409 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2410 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2411 return;
2412 }
2413 buffer copy = (buffer)malloc(DATASIZE);
2414 if (copy == NULL) {
2415 wxPyBLOCK_THREADS(PyErr_NoMemory());
2416 return;
2417 }
2418 memcpy(copy, data, DATASIZE);
2419 self->SetData(copy, false);
2420 // wxImage takes ownership of copy...
2421 }
2422 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2423 buffer data = self->GetData();
2424 int len = self->GetWidth() * self->GetHeight() * 3;
2425 PyObject* rv;
2426 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2427 return rv;
2428 }
2429 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2430 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2431 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2432 return;
2433 }
2434 self->SetData(data, true);
2435 }
2436 static PyObject *wxImage_GetAlphaData(wxImage *self){
2437 buffer data = self->GetAlpha();
2438 if (! data) {
2439 RETURN_NONE();
2440 } else {
2441 int len = self->GetWidth() * self->GetHeight();
2442 PyObject* rv;
2443 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2444 return rv;
2445 }
2446 }
2447 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2448 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2449 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2450 return;
2451 }
2452 buffer acopy = (buffer)malloc(ALPHASIZE);
2453 if (acopy == NULL) {
2454 wxPyBLOCK_THREADS(PyErr_NoMemory());
2455 return;
2456 }
2457 memcpy(acopy, alpha, ALPHASIZE);
2458 self->SetAlpha(acopy, false);
2459 // wxImage takes ownership of acopy...
2460 }
2461 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2462 buffer data = self->GetAlpha();
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2466 return rv;
2467 }
2468 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2469 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2470 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2471 return;
2472 }
2473 self->SetAlpha(alpha, true);
2474 }
2475 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2476 wxBitmap bitmap(*self, depth);
2477 return bitmap;
2478 }
2479 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2480 wxImage mono = self->ConvertToMono( red, green, blue );
2481 wxBitmap bitmap( mono, 1 );
2482 return bitmap;
2483 }
2484 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2485 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2487 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2491 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2492 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2493 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2494 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2495 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2496 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2497 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2498 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2499
2500 #include <wx/quantize.h>
2501
2502 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2503 return wxQuantize::Quantize(src, dest,
2504 //NULL, // palette
2505 desiredNoColours,
2506 NULL, // eightBitData
2507 flags);
2508 }
2509 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2510 if (PyCallable_Check(func)) {
2511 self->Connect(id, lastId, eventType,
2512 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2513 new wxPyCallback(func));
2514 }
2515 else if (func == Py_None) {
2516 self->Disconnect(id, lastId, eventType,
2517 (wxObjectEventFunction)
2518 &wxPyCallback::EventThunker);
2519 }
2520 else {
2521 wxPyBLOCK_THREADS(
2522 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2523 }
2524 }
2525 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2526 return self->Disconnect(id, lastId, eventType,
2527 (wxObjectEventFunction)
2528 &wxPyCallback::EventThunker);
2529 }
2530 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2531 if (_self && _self != Py_None) {
2532 self->SetClientObject(new wxPyOORClientData(_self, incref));
2533 }
2534 else {
2535 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2536 if (data) {
2537 self->SetClientObject(NULL); // This will delete it too
2538 }
2539 }
2540 }
2541
2542 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2543 #if wxUSE_UNICODE
2544 return self->GetUnicodeKey();
2545 #else
2546 return 0;
2547 #endif
2548 }
2549
2550 #if UINT_MAX < LONG_MAX
2551 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2552 #define SWIG_From_unsigned_SS_int SWIG_From_long
2553 /*@@*/
2554 #else
2555 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2556 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2557 /*@@*/
2558 #endif
2559
2560
2561 #if UINT_MAX != ULONG_MAX
2562 SWIGINTERN int
2563 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2564 {
2565 const char* errmsg = val ? "unsigned int" : (char*)0;
2566 unsigned long v;
2567 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2568 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2569 if (val) *val = (unsigned int)(v);
2570 return 1;
2571 }
2572 } else {
2573 PyErr_Clear();
2574 }
2575 if (val) {
2576 SWIG_type_error(errmsg, obj);
2577 }
2578 return 0;
2579 }
2580 #else
2581 SWIGINTERNSHORT unsigned int
2582 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2583 {
2584 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2585 }
2586 #endif
2587
2588
2589 SWIGINTERNSHORT unsigned int
2590 SWIG_As_unsigned_SS_int(PyObject* obj)
2591 {
2592 unsigned int v;
2593 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2594 /*
2595 this is needed to make valgrind/purify happier.
2596 */
2597 memset((void*)&v, 0, sizeof(unsigned int));
2598 }
2599 return v;
2600 }
2601
2602
2603 SWIGINTERNSHORT int
2604 SWIG_Check_unsigned_SS_int(PyObject* obj)
2605 {
2606 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2607 }
2608
2609 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2610 self->m_size = size;
2611 }
2612 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2613 int count = self->GetNumberOfFiles();
2614 wxString* files = self->GetFiles();
2615 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2616 PyObject* list = PyList_New(count);
2617
2618 if (!list) {
2619 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2620 wxPyEndBlockThreads(blocked);
2621 return NULL;
2622 }
2623
2624 for (int i=0; i<count; i++) {
2625 PyList_SetItem(list, i, wx2PyString(files[i]));
2626 }
2627 wxPyEndBlockThreads(blocked);
2628 return list;
2629 }
2630
2631
2632 static wxPyApp *new_wxPyApp(){
2633 wxPythonApp = new wxPyApp();
2634 return wxPythonApp;
2635 }
2636 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2637
2638 void wxApp_CleanUp() {
2639 __wxPyCleanup();
2640 }
2641
2642
2643 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2644
2645
2646 SWIGINTERNSHORT int
2647 SWIG_AsCharPtr(PyObject *obj, char **val)
2648 {
2649 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2650 return 1;
2651 }
2652 if (val) {
2653 PyErr_Clear();
2654 SWIG_type_error("char *", obj);
2655 }
2656 return 0;
2657 }
2658
2659
2660 SWIGINTERN PyObject *
2661 SWIG_FromCharPtr(const char* cptr)
2662 {
2663 if (cptr) {
2664 size_t size = strlen(cptr);
2665 if (size > INT_MAX) {
2666 return SWIG_NewPointerObj((char*)(cptr),
2667 SWIG_TypeQuery("char *"), 0);
2668 } else {
2669 if (size != 0) {
2670 return PyString_FromStringAndSize(cptr, size);
2671 } else {
2672 return PyString_FromString(cptr);
2673 }
2674 }
2675 }
2676 Py_INCREF(Py_None);
2677 return Py_None;
2678 }
2679
2680
2681 #ifdef __WXMAC__
2682
2683 // A dummy class that raises an exception if used...
2684 class wxEventLoop
2685 {
2686 public:
2687 wxEventLoop() { wxPyRaiseNotImplemented(); }
2688 int Run() { return 0; }
2689 void Exit(int rc = 0) {}
2690 bool Pending() const { return false; }
2691 bool Dispatch() { return false; }
2692 bool IsRunning() const { return false; }
2693 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2694 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2695 };
2696
2697 #else
2698
2699 #include <wx/evtloop.h>
2700
2701 #endif
2702
2703
2704
2705 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2706 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2707 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2708 static PyObject *wxWindow_GetChildren(wxWindow *self){
2709 wxWindowList& list = self->GetChildren();
2710 return wxPy_ConvertList(&list);
2711 }
2712 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2713 #if wxUSE_HOTKEY
2714 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2715 #else
2716 return false;
2717 #endif
2718 }
2719 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2720
2721
2722
2723 return false;
2724
2725 }
2726 static long wxWindow_GetHandle(wxWindow *self){
2727 return wxPyGetWinHandle(self);
2728 }
2729 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2730 self->AssociateHandle((WXWidget)handle);
2731 }
2732 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2733
2734 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowById(id, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByName( const wxString& name,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByName(name, parent);
2741 }
2742
2743 wxWindow* wxFindWindowByLabel( const wxString& label,
2744 const wxWindow *parent = NULL ) {
2745 return wxWindow::FindWindowByLabel(label, parent);
2746 }
2747
2748
2749 #ifdef __WXMSW__
2750 #include <wx/msw/private.h> // to get wxGetWindowId
2751 #endif
2752
2753
2754 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2755 #ifdef __WXMSW__
2756 WXHWND hWnd = (WXHWND)_hWnd;
2757 long id = wxGetWindowId(hWnd);
2758 wxWindow* win = new wxWindow;
2759 parent->AddChild(win);
2760 win->SetEventHandler(win);
2761 win->SetHWND(hWnd);
2762 win->SetId(id);
2763 win->SubclassWin(hWnd);
2764 win->AdoptAttributesFromHWND();
2765 win->SetupColours();
2766 return win;
2767 #else
2768 wxPyRaiseNotImplemented();
2769 return NULL;
2770 #endif
2771 }
2772
2773
2774 PyObject* GetTopLevelWindows() {
2775 return wxPy_ConvertList(&wxTopLevelWindows);
2776 }
2777
2778
2779 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2780 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2781 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2782
2783 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2784
2785 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2786 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2787 wxMenuItemList& list = self->GetMenuItems();
2788 return wxPy_ConvertList(&list);
2789 }
2790 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2791 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2792 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2793 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2794 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2795 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2796 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2797 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2798 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2799 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2800 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2801 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2802 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2803 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2804 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2805 static const wxString wxPyControlNameStr(wxControlNameStr);
2806 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2807 if (clientData) {
2808 wxPyClientData* data = new wxPyClientData(clientData);
2809 return self->Append(item, data);
2810 } else
2811 return self->Append(item);
2812 }
2813 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2814 if (clientData) {
2815 wxPyClientData* data = new wxPyClientData(clientData);
2816 return self->Insert(item, pos, data);
2817 } else
2818 return self->Insert(item, pos);
2819 }
2820 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2821 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2822 if (data) {
2823 Py_INCREF(data->m_obj);
2824 return data->m_obj;
2825 } else {
2826 Py_INCREF(Py_None);
2827 return Py_None;
2828 }
2829 }
2830 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2831 wxPyClientData* data = new wxPyClientData(clientData);
2832 self->SetClientObject(n, data);
2833 }
2834
2835
2836 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2837 wxPyUserData* data = NULL;
2838 if ( userData ) {
2839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2840 data = new wxPyUserData(userData);
2841 wxPyEndBlockThreads(blocked);
2842 }
2843 return new wxSizerItem(window, proportion, flag, border, data);
2844 }
2845 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2846 wxPyUserData* data = NULL;
2847 if ( userData ) {
2848 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2849 data = new wxPyUserData(userData);
2850 wxPyEndBlockThreads(blocked);
2851 }
2852 return new wxSizerItem(width, height, proportion, flag, border, data);
2853 }
2854 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2855 wxPyUserData* data = NULL;
2856 if ( userData ) {
2857 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2858 data = new wxPyUserData(userData);
2859 wxPyEndBlockThreads(blocked);
2860 }
2861 return new wxSizerItem(sizer, proportion, flag, border, data);
2862 }
2863
2864 #include <float.h>
2865 SWIGINTERN int
2866 SWIG_CheckDoubleInRange(double value, double min_value,
2867 double max_value, const char* errmsg)
2868 {
2869 if (value < min_value) {
2870 if (errmsg) {
2871 PyErr_Format(PyExc_OverflowError,
2872 "value %g is less than %s minimum %g",
2873 value, errmsg, min_value);
2874 }
2875 return 0;
2876 } else if (value > max_value) {
2877 if (errmsg) {
2878 PyErr_Format(PyExc_OverflowError,
2879 "value %g is greater than %s maximum %g",
2880 value, errmsg, max_value);
2881 }
2882 return 0;
2883 }
2884 return 1;
2885 }
2886
2887
2888 SWIGINTERN int
2889 SWIG_AsVal_float(PyObject *obj, float *val)
2890 {
2891 const char* errmsg = val ? "float" : (char*)0;
2892 double v;
2893 if (SWIG_AsVal_double(obj, &v)) {
2894 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2895 if (val) *val = (float)(v);
2896 return 1;
2897 } else {
2898 return 0;
2899 }
2900 } else {
2901 PyErr_Clear();
2902 }
2903 if (val) {
2904 SWIG_type_error(errmsg, obj);
2905 }
2906 return 0;
2907 }
2908
2909
2910 SWIGINTERNSHORT float
2911 SWIG_As_float(PyObject* obj)
2912 {
2913 float v;
2914 if (!SWIG_AsVal_float(obj, &v)) {
2915 /*
2916 this is needed to make valgrind/purify happier.
2917 */
2918 memset((void*)&v, 0, sizeof(float));
2919 }
2920 return v;
2921 }
2922
2923
2924 SWIGINTERNSHORT int
2925 SWIG_Check_float(PyObject* obj)
2926 {
2927 return SWIG_AsVal_float(obj, (float*)0);
2928 }
2929
2930
2931 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2932 #define SWIG_From_float PyFloat_FromDouble
2933 /*@@*/
2934
2935 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2936 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2937 if (data) {
2938 Py_INCREF(data->m_obj);
2939 return data->m_obj;
2940 } else {
2941 Py_INCREF(Py_None);
2942 return Py_None;
2943 }
2944 }
2945
2946 // Figure out the type of the sizer item
2947
2948 struct wxPySizerItemInfo {
2949 wxPySizerItemInfo()
2950 : window(NULL), sizer(NULL), gotSize(false),
2951 size(wxDefaultSize), gotPos(false), pos(-1)
2952 {}
2953
2954 wxWindow* window;
2955 wxSizer* sizer;
2956 bool gotSize;
2957 wxSize size;
2958 bool gotPos;
2959 int pos;
2960 };
2961
2962 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2963
2964 wxPySizerItemInfo info;
2965 wxSize size;
2966 wxSize* sizePtr = &size;
2967
2968 // Find out what the type of the item is
2969 // try wxWindow
2970 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2971 PyErr_Clear();
2972 info.window = NULL;
2973
2974 // try wxSizer
2975 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2976 PyErr_Clear();
2977 info.sizer = NULL;
2978
2979 // try wxSize or (w,h)
2980 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2981 info.size = *sizePtr;
2982 info.gotSize = true;
2983 }
2984
2985 // or a single int
2986 if (checkIdx && PyInt_Check(item)) {
2987 info.pos = PyInt_AsLong(item);
2988 info.gotPos = true;
2989 }
2990 }
2991 }
2992
2993 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2994 // no expected type, figure out what kind of error message to generate
2995 if ( !checkSize && !checkIdx )
2996 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2997 else if ( checkSize && !checkIdx )
2998 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2999 else if ( !checkSize && checkIdx)
3000 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
3001 else
3002 // can this one happen?
3003 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
3004 }
3005
3006 return info;
3007 }
3008
3009 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3010 if (!self->GetClientObject())
3011 self->SetClientObject(new wxPyOORClientData(_self));
3012 }
3013 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3014
3015 wxPyUserData* data = NULL;
3016 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3017 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3018 if ( userData && (info.window || info.sizer || info.gotSize) )
3019 data = new wxPyUserData(userData);
3020 wxPyEndBlockThreads(blocked);
3021
3022 // Now call the real Add method if a valid item type was found
3023 if ( info.window )
3024 return self->Add(info.window, proportion, flag, border, data);
3025 else if ( info.sizer )
3026 return self->Add(info.sizer, proportion, flag, border, data);
3027 else if (info.gotSize)
3028 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3029 proportion, flag, border, data);
3030 else
3031 return NULL;
3032 }
3033 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3034
3035 wxPyUserData* data = NULL;
3036 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3037 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3038 if ( userData && (info.window || info.sizer || info.gotSize) )
3039 data = new wxPyUserData(userData);
3040 wxPyEndBlockThreads(blocked);
3041
3042 // Now call the real Insert method if a valid item type was found
3043 if ( info.window )
3044 return self->Insert(before, info.window, proportion, flag, border, data);
3045 else if ( info.sizer )
3046 return self->Insert(before, info.sizer, proportion, flag, border, data);
3047 else if (info.gotSize)
3048 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3049 proportion, flag, border, data);
3050 else
3051 return NULL;
3052 }
3053 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3054
3055 wxPyUserData* data = NULL;
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3057 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3058 if ( userData && (info.window || info.sizer || info.gotSize) )
3059 data = new wxPyUserData(userData);
3060 wxPyEndBlockThreads(blocked);
3061
3062 // Now call the real Prepend method if a valid item type was found
3063 if ( info.window )
3064 return self->Prepend(info.window, proportion, flag, border, data);
3065 else if ( info.sizer )
3066 return self->Prepend(info.sizer, proportion, flag, border, data);
3067 else if (info.gotSize)
3068 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3069 proportion, flag, border, data);
3070 else
3071 return NULL;
3072 }
3073 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3074 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3076 wxPyEndBlockThreads(blocked);
3077 if ( info.window )
3078 return self->Remove(info.window);
3079 else if ( info.sizer )
3080 return self->Remove(info.sizer);
3081 else if ( info.gotPos )
3082 return self->Remove(info.pos);
3083 else
3084 return false;
3085 }
3086 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3087 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3089 wxPyEndBlockThreads(blocked);
3090 if ( info.window )
3091 return self->Detach(info.window);
3092 else if ( info.sizer )
3093 return self->Detach(info.sizer);
3094 else if ( info.gotPos )
3095 return self->Detach(info.pos);
3096 else
3097 return false;
3098 }
3099 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3100 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3101 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3102 wxPyEndBlockThreads(blocked);
3103 if ( info.window )
3104 return self->GetItem(info.window);
3105 else if ( info.sizer )
3106 return self->GetItem(info.sizer);
3107 else if ( info.gotPos )
3108 return self->GetItem(info.pos);
3109 else
3110 return NULL;
3111 }
3112 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3114 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3115 wxPyEndBlockThreads(blocked);
3116 if ( info.window )
3117 self->SetItemMinSize(info.window, size);
3118 else if ( info.sizer )
3119 self->SetItemMinSize(info.sizer, size);
3120 else if ( info.gotPos )
3121 self->SetItemMinSize(info.pos, size);
3122 }
3123 static PyObject *wxSizer_GetChildren(wxSizer *self){
3124 wxSizerItemList& list = self->GetChildren();
3125 return wxPy_ConvertList(&list);
3126 }
3127 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3130 wxPyEndBlockThreads(blocked);
3131 if ( info.window )
3132 return self->Show(info.window, show, recursive);
3133 else if ( info.sizer )
3134 return self->Show(info.sizer, show, recursive);
3135 else if ( info.gotPos )
3136 return self->Show(info.pos, show);
3137 else
3138 return false;
3139 }
3140 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3143 wxPyEndBlockThreads(blocked);
3144 if ( info.window )
3145 return self->IsShown(info.window);
3146 else if ( info.sizer )
3147 return self->IsShown(info.sizer);
3148 else if ( info.gotPos )
3149 return self->IsShown(info.pos);
3150 else
3151 return false;
3152 }
3153
3154 // See pyclasses.h
3155 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3156 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3157 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3158
3159
3160
3161
3162 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3163 {
3164 if (source == Py_None) {
3165 **obj = wxGBPosition(-1,-1);
3166 return true;
3167 }
3168 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3169 }
3170
3171 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3172 {
3173 if (source == Py_None) {
3174 **obj = wxGBSpan(-1,-1);
3175 return true;
3176 }
3177 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3178 }
3179
3180
3181 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3182 self->SetRow(row);
3183 self->SetCol(col);
3184 }
3185 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 PyObject* tup = PyTuple_New(2);
3188 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3189 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3190 wxPyEndBlockThreads(blocked);
3191 return tup;
3192 }
3193 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3194 self->SetRowspan(rowspan);
3195 self->SetColspan(colspan);
3196 }
3197 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 PyObject* tup = PyTuple_New(2);
3200 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3201 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3202 wxPyEndBlockThreads(blocked);
3203 return tup;
3204 }
3205 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3206 wxPyUserData* data = NULL;
3207 if ( userData ) {
3208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3209 data = new wxPyUserData(userData);
3210 wxPyEndBlockThreads(blocked);
3211 }
3212 return new wxGBSizerItem(window, pos, span, flag, border, data);
3213 }
3214 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3215 wxPyUserData* data = NULL;
3216 if ( userData ) {
3217 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3218 data = new wxPyUserData(userData);
3219 wxPyEndBlockThreads(blocked);
3220 }
3221 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3222 }
3223 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3224 wxPyUserData* data = NULL;
3225 if ( userData ) {
3226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3227 data = new wxPyUserData(userData);
3228 wxPyEndBlockThreads(blocked);
3229 }
3230 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3231 }
3232 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3233 int row, col;
3234 self->GetEndPos(row, col);
3235 return wxGBPosition(row, col);
3236 }
3237 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3238
3239 wxPyUserData* data = NULL;
3240 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3241 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3242 if ( userData && (info.window || info.sizer || info.gotSize) )
3243 data = new wxPyUserData(userData);
3244 wxPyEndBlockThreads(blocked);
3245
3246 // Now call the real Add method if a valid item type was found
3247 if ( info.window )
3248 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3249 else if ( info.sizer )
3250 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3251 else if (info.gotSize)
3252 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3253 pos, span, flag, border, data);
3254 return NULL;
3255 }
3256
3257
3258 #ifdef __cplusplus
3259 extern "C" {
3260 #endif
3261 static int _wrap_EmptyString_set(PyObject *) {
3262 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3263 return 1;
3264 }
3265
3266
3267 static PyObject *_wrap_EmptyString_get(void) {
3268 PyObject *pyobj;
3269
3270 {
3271 #if wxUSE_UNICODE
3272 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3273 #else
3274 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3275 #endif
3276 }
3277 return pyobj;
3278 }
3279
3280
3281 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3282 PyObject *resultobj;
3283 wxObject *arg1 = (wxObject *) 0 ;
3284 wxString result;
3285 PyObject * obj0 = 0 ;
3286 char *kwnames[] = {
3287 (char *) "self", NULL
3288 };
3289
3290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3292 if (SWIG_arg_fail(1)) SWIG_fail;
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 result = wxObject_GetClassName(arg1);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 {
3301 #if wxUSE_UNICODE
3302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3303 #else
3304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3305 #endif
3306 }
3307 return resultobj;
3308 fail:
3309 return NULL;
3310 }
3311
3312
3313 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3314 PyObject *resultobj;
3315 wxObject *arg1 = (wxObject *) 0 ;
3316 PyObject * obj0 = 0 ;
3317 char *kwnames[] = {
3318 (char *) "self", NULL
3319 };
3320
3321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3323 if (SWIG_arg_fail(1)) SWIG_fail;
3324 {
3325 PyThreadState* __tstate = wxPyBeginAllowThreads();
3326 wxObject_Destroy(arg1);
3327
3328 wxPyEndAllowThreads(__tstate);
3329 if (PyErr_Occurred()) SWIG_fail;
3330 }
3331 Py_INCREF(Py_None); resultobj = Py_None;
3332 return resultobj;
3333 fail:
3334 return NULL;
3335 }
3336
3337
3338 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3339 PyObject *obj;
3340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3341 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3342 Py_INCREF(obj);
3343 return Py_BuildValue((char *)"");
3344 }
3345 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3346 PyObject *resultobj;
3347 wxSize *arg1 = (wxSize *) 0 ;
3348 int arg2 ;
3349 PyObject * obj0 = 0 ;
3350 PyObject * obj1 = 0 ;
3351 char *kwnames[] = {
3352 (char *) "self",(char *) "x", NULL
3353 };
3354
3355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3357 if (SWIG_arg_fail(1)) SWIG_fail;
3358 {
3359 arg2 = (int)(SWIG_As_int(obj1));
3360 if (SWIG_arg_fail(2)) SWIG_fail;
3361 }
3362 if (arg1) (arg1)->x = arg2;
3363
3364 Py_INCREF(Py_None); resultobj = Py_None;
3365 return resultobj;
3366 fail:
3367 return NULL;
3368 }
3369
3370
3371 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3372 PyObject *resultobj;
3373 wxSize *arg1 = (wxSize *) 0 ;
3374 int result;
3375 PyObject * obj0 = 0 ;
3376 char *kwnames[] = {
3377 (char *) "self", NULL
3378 };
3379
3380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3382 if (SWIG_arg_fail(1)) SWIG_fail;
3383 result = (int) ((arg1)->x);
3384
3385 {
3386 resultobj = SWIG_From_int((int)(result));
3387 }
3388 return resultobj;
3389 fail:
3390 return NULL;
3391 }
3392
3393
3394 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj;
3396 wxSize *arg1 = (wxSize *) 0 ;
3397 int arg2 ;
3398 PyObject * obj0 = 0 ;
3399 PyObject * obj1 = 0 ;
3400 char *kwnames[] = {
3401 (char *) "self",(char *) "y", NULL
3402 };
3403
3404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3406 if (SWIG_arg_fail(1)) SWIG_fail;
3407 {
3408 arg2 = (int)(SWIG_As_int(obj1));
3409 if (SWIG_arg_fail(2)) SWIG_fail;
3410 }
3411 if (arg1) (arg1)->y = arg2;
3412
3413 Py_INCREF(Py_None); resultobj = Py_None;
3414 return resultobj;
3415 fail:
3416 return NULL;
3417 }
3418
3419
3420 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3421 PyObject *resultobj;
3422 wxSize *arg1 = (wxSize *) 0 ;
3423 int result;
3424 PyObject * obj0 = 0 ;
3425 char *kwnames[] = {
3426 (char *) "self", NULL
3427 };
3428
3429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3431 if (SWIG_arg_fail(1)) SWIG_fail;
3432 result = (int) ((arg1)->y);
3433
3434 {
3435 resultobj = SWIG_From_int((int)(result));
3436 }
3437 return resultobj;
3438 fail:
3439 return NULL;
3440 }
3441
3442
3443 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3444 PyObject *resultobj;
3445 int arg1 = (int) 0 ;
3446 int arg2 = (int) 0 ;
3447 wxSize *result;
3448 PyObject * obj0 = 0 ;
3449 PyObject * obj1 = 0 ;
3450 char *kwnames[] = {
3451 (char *) "w",(char *) "h", NULL
3452 };
3453
3454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3455 if (obj0) {
3456 {
3457 arg1 = (int)(SWIG_As_int(obj0));
3458 if (SWIG_arg_fail(1)) SWIG_fail;
3459 }
3460 }
3461 if (obj1) {
3462 {
3463 arg2 = (int)(SWIG_As_int(obj1));
3464 if (SWIG_arg_fail(2)) SWIG_fail;
3465 }
3466 }
3467 {
3468 PyThreadState* __tstate = wxPyBeginAllowThreads();
3469 result = (wxSize *)new wxSize(arg1,arg2);
3470
3471 wxPyEndAllowThreads(__tstate);
3472 if (PyErr_Occurred()) SWIG_fail;
3473 }
3474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3475 return resultobj;
3476 fail:
3477 return NULL;
3478 }
3479
3480
3481 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3482 PyObject *resultobj;
3483 wxSize *arg1 = (wxSize *) 0 ;
3484 PyObject * obj0 = 0 ;
3485 char *kwnames[] = {
3486 (char *) "self", NULL
3487 };
3488
3489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3491 if (SWIG_arg_fail(1)) SWIG_fail;
3492 {
3493 PyThreadState* __tstate = wxPyBeginAllowThreads();
3494 delete arg1;
3495
3496 wxPyEndAllowThreads(__tstate);
3497 if (PyErr_Occurred()) SWIG_fail;
3498 }
3499 Py_INCREF(Py_None); resultobj = Py_None;
3500 return resultobj;
3501 fail:
3502 return NULL;
3503 }
3504
3505
3506 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3507 PyObject *resultobj;
3508 wxSize *arg1 = (wxSize *) 0 ;
3509 wxSize *arg2 = 0 ;
3510 bool result;
3511 wxSize temp2 ;
3512 PyObject * obj0 = 0 ;
3513 PyObject * obj1 = 0 ;
3514 char *kwnames[] = {
3515 (char *) "self",(char *) "sz", NULL
3516 };
3517
3518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3520 if (SWIG_arg_fail(1)) SWIG_fail;
3521 {
3522 arg2 = &temp2;
3523 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3524 }
3525 {
3526 PyThreadState* __tstate = wxPyBeginAllowThreads();
3527 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3528
3529 wxPyEndAllowThreads(__tstate);
3530 if (PyErr_Occurred()) SWIG_fail;
3531 }
3532 {
3533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3534 }
3535 return resultobj;
3536 fail:
3537 return NULL;
3538 }
3539
3540
3541 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3542 PyObject *resultobj;
3543 wxSize *arg1 = (wxSize *) 0 ;
3544 wxSize *arg2 = 0 ;
3545 bool result;
3546 wxSize temp2 ;
3547 PyObject * obj0 = 0 ;
3548 PyObject * obj1 = 0 ;
3549 char *kwnames[] = {
3550 (char *) "self",(char *) "sz", NULL
3551 };
3552
3553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3555 if (SWIG_arg_fail(1)) SWIG_fail;
3556 {
3557 arg2 = &temp2;
3558 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3559 }
3560 {
3561 PyThreadState* __tstate = wxPyBeginAllowThreads();
3562 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3563
3564 wxPyEndAllowThreads(__tstate);
3565 if (PyErr_Occurred()) SWIG_fail;
3566 }
3567 {
3568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3569 }
3570 return resultobj;
3571 fail:
3572 return NULL;
3573 }
3574
3575
3576 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3577 PyObject *resultobj;
3578 wxSize *arg1 = (wxSize *) 0 ;
3579 wxSize *arg2 = 0 ;
3580 wxSize result;
3581 wxSize temp2 ;
3582 PyObject * obj0 = 0 ;
3583 PyObject * obj1 = 0 ;
3584 char *kwnames[] = {
3585 (char *) "self",(char *) "sz", NULL
3586 };
3587
3588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3590 if (SWIG_arg_fail(1)) SWIG_fail;
3591 {
3592 arg2 = &temp2;
3593 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3594 }
3595 {
3596 PyThreadState* __tstate = wxPyBeginAllowThreads();
3597 result = (arg1)->operator +((wxSize const &)*arg2);
3598
3599 wxPyEndAllowThreads(__tstate);
3600 if (PyErr_Occurred()) SWIG_fail;
3601 }
3602 {
3603 wxSize * resultptr;
3604 resultptr = new wxSize((wxSize &)(result));
3605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3606 }
3607 return resultobj;
3608 fail:
3609 return NULL;
3610 }
3611
3612
3613 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3614 PyObject *resultobj;
3615 wxSize *arg1 = (wxSize *) 0 ;
3616 wxSize *arg2 = 0 ;
3617 wxSize result;
3618 wxSize temp2 ;
3619 PyObject * obj0 = 0 ;
3620 PyObject * obj1 = 0 ;
3621 char *kwnames[] = {
3622 (char *) "self",(char *) "sz", NULL
3623 };
3624
3625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3627 if (SWIG_arg_fail(1)) SWIG_fail;
3628 {
3629 arg2 = &temp2;
3630 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3631 }
3632 {
3633 PyThreadState* __tstate = wxPyBeginAllowThreads();
3634 result = (arg1)->operator -((wxSize const &)*arg2);
3635
3636 wxPyEndAllowThreads(__tstate);
3637 if (PyErr_Occurred()) SWIG_fail;
3638 }
3639 {
3640 wxSize * resultptr;
3641 resultptr = new wxSize((wxSize &)(result));
3642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3643 }
3644 return resultobj;
3645 fail:
3646 return NULL;
3647 }
3648
3649
3650 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3651 PyObject *resultobj;
3652 wxSize *arg1 = (wxSize *) 0 ;
3653 wxSize *arg2 = 0 ;
3654 wxSize temp2 ;
3655 PyObject * obj0 = 0 ;
3656 PyObject * obj1 = 0 ;
3657 char *kwnames[] = {
3658 (char *) "self",(char *) "sz", NULL
3659 };
3660
3661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3663 if (SWIG_arg_fail(1)) SWIG_fail;
3664 {
3665 arg2 = &temp2;
3666 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3667 }
3668 {
3669 PyThreadState* __tstate = wxPyBeginAllowThreads();
3670 (arg1)->IncTo((wxSize const &)*arg2);
3671
3672 wxPyEndAllowThreads(__tstate);
3673 if (PyErr_Occurred()) SWIG_fail;
3674 }
3675 Py_INCREF(Py_None); resultobj = Py_None;
3676 return resultobj;
3677 fail:
3678 return NULL;
3679 }
3680
3681
3682 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3683 PyObject *resultobj;
3684 wxSize *arg1 = (wxSize *) 0 ;
3685 wxSize *arg2 = 0 ;
3686 wxSize temp2 ;
3687 PyObject * obj0 = 0 ;
3688 PyObject * obj1 = 0 ;
3689 char *kwnames[] = {
3690 (char *) "self",(char *) "sz", NULL
3691 };
3692
3693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3695 if (SWIG_arg_fail(1)) SWIG_fail;
3696 {
3697 arg2 = &temp2;
3698 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3699 }
3700 {
3701 PyThreadState* __tstate = wxPyBeginAllowThreads();
3702 (arg1)->DecTo((wxSize const &)*arg2);
3703
3704 wxPyEndAllowThreads(__tstate);
3705 if (PyErr_Occurred()) SWIG_fail;
3706 }
3707 Py_INCREF(Py_None); resultobj = Py_None;
3708 return resultobj;
3709 fail:
3710 return NULL;
3711 }
3712
3713
3714 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3715 PyObject *resultobj;
3716 wxSize *arg1 = (wxSize *) 0 ;
3717 int arg2 ;
3718 int arg3 ;
3719 PyObject * obj0 = 0 ;
3720 PyObject * obj1 = 0 ;
3721 PyObject * obj2 = 0 ;
3722 char *kwnames[] = {
3723 (char *) "self",(char *) "w",(char *) "h", NULL
3724 };
3725
3726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3728 if (SWIG_arg_fail(1)) SWIG_fail;
3729 {
3730 arg2 = (int)(SWIG_As_int(obj1));
3731 if (SWIG_arg_fail(2)) SWIG_fail;
3732 }
3733 {
3734 arg3 = (int)(SWIG_As_int(obj2));
3735 if (SWIG_arg_fail(3)) SWIG_fail;
3736 }
3737 {
3738 PyThreadState* __tstate = wxPyBeginAllowThreads();
3739 (arg1)->Set(arg2,arg3);
3740
3741 wxPyEndAllowThreads(__tstate);
3742 if (PyErr_Occurred()) SWIG_fail;
3743 }
3744 Py_INCREF(Py_None); resultobj = Py_None;
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
3751 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3752 PyObject *resultobj;
3753 wxSize *arg1 = (wxSize *) 0 ;
3754 int arg2 ;
3755 PyObject * obj0 = 0 ;
3756 PyObject * obj1 = 0 ;
3757 char *kwnames[] = {
3758 (char *) "self",(char *) "w", NULL
3759 };
3760
3761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3763 if (SWIG_arg_fail(1)) SWIG_fail;
3764 {
3765 arg2 = (int)(SWIG_As_int(obj1));
3766 if (SWIG_arg_fail(2)) SWIG_fail;
3767 }
3768 {
3769 PyThreadState* __tstate = wxPyBeginAllowThreads();
3770 (arg1)->SetWidth(arg2);
3771
3772 wxPyEndAllowThreads(__tstate);
3773 if (PyErr_Occurred()) SWIG_fail;
3774 }
3775 Py_INCREF(Py_None); resultobj = Py_None;
3776 return resultobj;
3777 fail:
3778 return NULL;
3779 }
3780
3781
3782 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3783 PyObject *resultobj;
3784 wxSize *arg1 = (wxSize *) 0 ;
3785 int arg2 ;
3786 PyObject * obj0 = 0 ;
3787 PyObject * obj1 = 0 ;
3788 char *kwnames[] = {
3789 (char *) "self",(char *) "h", NULL
3790 };
3791
3792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3794 if (SWIG_arg_fail(1)) SWIG_fail;
3795 {
3796 arg2 = (int)(SWIG_As_int(obj1));
3797 if (SWIG_arg_fail(2)) SWIG_fail;
3798 }
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 (arg1)->SetHeight(arg2);
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 Py_INCREF(Py_None); resultobj = Py_None;
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj;
3815 wxSize *arg1 = (wxSize *) 0 ;
3816 int result;
3817 PyObject * obj0 = 0 ;
3818 char *kwnames[] = {
3819 (char *) "self", NULL
3820 };
3821
3822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3824 if (SWIG_arg_fail(1)) SWIG_fail;
3825 {
3826 PyThreadState* __tstate = wxPyBeginAllowThreads();
3827 result = (int)((wxSize const *)arg1)->GetWidth();
3828
3829 wxPyEndAllowThreads(__tstate);
3830 if (PyErr_Occurred()) SWIG_fail;
3831 }
3832 {
3833 resultobj = SWIG_From_int((int)(result));
3834 }
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxSize *arg1 = (wxSize *) 0 ;
3844 int result;
3845 PyObject * obj0 = 0 ;
3846 char *kwnames[] = {
3847 (char *) "self", NULL
3848 };
3849
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3852 if (SWIG_arg_fail(1)) SWIG_fail;
3853 {
3854 PyThreadState* __tstate = wxPyBeginAllowThreads();
3855 result = (int)((wxSize const *)arg1)->GetHeight();
3856
3857 wxPyEndAllowThreads(__tstate);
3858 if (PyErr_Occurred()) SWIG_fail;
3859 }
3860 {
3861 resultobj = SWIG_From_int((int)(result));
3862 }
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj;
3871 wxSize *arg1 = (wxSize *) 0 ;
3872 bool result;
3873 PyObject * obj0 = 0 ;
3874 char *kwnames[] = {
3875 (char *) "self", NULL
3876 };
3877
3878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3880 if (SWIG_arg_fail(1)) SWIG_fail;
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3884
3885 wxPyEndAllowThreads(__tstate);
3886 if (PyErr_Occurred()) SWIG_fail;
3887 }
3888 {
3889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3890 }
3891 return resultobj;
3892 fail:
3893 return NULL;
3894 }
3895
3896
3897 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3898 PyObject *resultobj;
3899 wxSize *arg1 = (wxSize *) 0 ;
3900 wxSize *arg2 = 0 ;
3901 wxSize temp2 ;
3902 PyObject * obj0 = 0 ;
3903 PyObject * obj1 = 0 ;
3904 char *kwnames[] = {
3905 (char *) "self",(char *) "size", NULL
3906 };
3907
3908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3910 if (SWIG_arg_fail(1)) SWIG_fail;
3911 {
3912 arg2 = &temp2;
3913 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3914 }
3915 {
3916 PyThreadState* __tstate = wxPyBeginAllowThreads();
3917 (arg1)->SetDefaults((wxSize const &)*arg2);
3918
3919 wxPyEndAllowThreads(__tstate);
3920 if (PyErr_Occurred()) SWIG_fail;
3921 }
3922 Py_INCREF(Py_None); resultobj = Py_None;
3923 return resultobj;
3924 fail:
3925 return NULL;
3926 }
3927
3928
3929 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3930 PyObject *resultobj;
3931 wxSize *arg1 = (wxSize *) 0 ;
3932 PyObject *result;
3933 PyObject * obj0 = 0 ;
3934 char *kwnames[] = {
3935 (char *) "self", NULL
3936 };
3937
3938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3940 if (SWIG_arg_fail(1)) SWIG_fail;
3941 {
3942 PyThreadState* __tstate = wxPyBeginAllowThreads();
3943 result = (PyObject *)wxSize_Get(arg1);
3944
3945 wxPyEndAllowThreads(__tstate);
3946 if (PyErr_Occurred()) SWIG_fail;
3947 }
3948 resultobj = result;
3949 return resultobj;
3950 fail:
3951 return NULL;
3952 }
3953
3954
3955 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3956 PyObject *obj;
3957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3958 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3959 Py_INCREF(obj);
3960 return Py_BuildValue((char *)"");
3961 }
3962 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3963 PyObject *resultobj;
3964 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3965 double arg2 ;
3966 PyObject * obj0 = 0 ;
3967 PyObject * obj1 = 0 ;
3968 char *kwnames[] = {
3969 (char *) "self",(char *) "x", NULL
3970 };
3971
3972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3974 if (SWIG_arg_fail(1)) SWIG_fail;
3975 {
3976 arg2 = (double)(SWIG_As_double(obj1));
3977 if (SWIG_arg_fail(2)) SWIG_fail;
3978 }
3979 if (arg1) (arg1)->x = arg2;
3980
3981 Py_INCREF(Py_None); resultobj = Py_None;
3982 return resultobj;
3983 fail:
3984 return NULL;
3985 }
3986
3987
3988 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3989 PyObject *resultobj;
3990 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3991 double result;
3992 PyObject * obj0 = 0 ;
3993 char *kwnames[] = {
3994 (char *) "self", NULL
3995 };
3996
3997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3999 if (SWIG_arg_fail(1)) SWIG_fail;
4000 result = (double) ((arg1)->x);
4001
4002 {
4003 resultobj = SWIG_From_double((double)(result));
4004 }
4005 return resultobj;
4006 fail:
4007 return NULL;
4008 }
4009
4010
4011 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4012 PyObject *resultobj;
4013 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4014 double arg2 ;
4015 PyObject * obj0 = 0 ;
4016 PyObject * obj1 = 0 ;
4017 char *kwnames[] = {
4018 (char *) "self",(char *) "y", NULL
4019 };
4020
4021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4023 if (SWIG_arg_fail(1)) SWIG_fail;
4024 {
4025 arg2 = (double)(SWIG_As_double(obj1));
4026 if (SWIG_arg_fail(2)) SWIG_fail;
4027 }
4028 if (arg1) (arg1)->y = arg2;
4029
4030 Py_INCREF(Py_None); resultobj = Py_None;
4031 return resultobj;
4032 fail:
4033 return NULL;
4034 }
4035
4036
4037 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4038 PyObject *resultobj;
4039 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4040 double result;
4041 PyObject * obj0 = 0 ;
4042 char *kwnames[] = {
4043 (char *) "self", NULL
4044 };
4045
4046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4048 if (SWIG_arg_fail(1)) SWIG_fail;
4049 result = (double) ((arg1)->y);
4050
4051 {
4052 resultobj = SWIG_From_double((double)(result));
4053 }
4054 return resultobj;
4055 fail:
4056 return NULL;
4057 }
4058
4059
4060 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4061 PyObject *resultobj;
4062 double arg1 = (double) 0.0 ;
4063 double arg2 = (double) 0.0 ;
4064 wxRealPoint *result;
4065 PyObject * obj0 = 0 ;
4066 PyObject * obj1 = 0 ;
4067 char *kwnames[] = {
4068 (char *) "x",(char *) "y", NULL
4069 };
4070
4071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4072 if (obj0) {
4073 {
4074 arg1 = (double)(SWIG_As_double(obj0));
4075 if (SWIG_arg_fail(1)) SWIG_fail;
4076 }
4077 }
4078 if (obj1) {
4079 {
4080 arg2 = (double)(SWIG_As_double(obj1));
4081 if (SWIG_arg_fail(2)) SWIG_fail;
4082 }
4083 }
4084 {
4085 PyThreadState* __tstate = wxPyBeginAllowThreads();
4086 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4087
4088 wxPyEndAllowThreads(__tstate);
4089 if (PyErr_Occurred()) SWIG_fail;
4090 }
4091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4092 return resultobj;
4093 fail:
4094 return NULL;
4095 }
4096
4097
4098 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4099 PyObject *resultobj;
4100 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4101 PyObject * obj0 = 0 ;
4102 char *kwnames[] = {
4103 (char *) "self", NULL
4104 };
4105
4106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4108 if (SWIG_arg_fail(1)) SWIG_fail;
4109 {
4110 PyThreadState* __tstate = wxPyBeginAllowThreads();
4111 delete arg1;
4112
4113 wxPyEndAllowThreads(__tstate);
4114 if (PyErr_Occurred()) SWIG_fail;
4115 }
4116 Py_INCREF(Py_None); resultobj = Py_None;
4117 return resultobj;
4118 fail:
4119 return NULL;
4120 }
4121
4122
4123 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4124 PyObject *resultobj;
4125 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4126 wxRealPoint *arg2 = 0 ;
4127 bool result;
4128 wxRealPoint temp2 ;
4129 PyObject * obj0 = 0 ;
4130 PyObject * obj1 = 0 ;
4131 char *kwnames[] = {
4132 (char *) "self",(char *) "pt", NULL
4133 };
4134
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4137 if (SWIG_arg_fail(1)) SWIG_fail;
4138 {
4139 arg2 = &temp2;
4140 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4141 }
4142 {
4143 PyThreadState* __tstate = wxPyBeginAllowThreads();
4144 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4145
4146 wxPyEndAllowThreads(__tstate);
4147 if (PyErr_Occurred()) SWIG_fail;
4148 }
4149 {
4150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4151 }
4152 return resultobj;
4153 fail:
4154 return NULL;
4155 }
4156
4157
4158 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4159 PyObject *resultobj;
4160 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4161 wxRealPoint *arg2 = 0 ;
4162 bool result;
4163 wxRealPoint temp2 ;
4164 PyObject * obj0 = 0 ;
4165 PyObject * obj1 = 0 ;
4166 char *kwnames[] = {
4167 (char *) "self",(char *) "pt", NULL
4168 };
4169
4170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4172 if (SWIG_arg_fail(1)) SWIG_fail;
4173 {
4174 arg2 = &temp2;
4175 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4176 }
4177 {
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4180
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 {
4185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4186 }
4187 return resultobj;
4188 fail:
4189 return NULL;
4190 }
4191
4192
4193 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4194 PyObject *resultobj;
4195 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4196 wxRealPoint *arg2 = 0 ;
4197 wxRealPoint result;
4198 wxRealPoint temp2 ;
4199 PyObject * obj0 = 0 ;
4200 PyObject * obj1 = 0 ;
4201 char *kwnames[] = {
4202 (char *) "self",(char *) "pt", NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4207 if (SWIG_arg_fail(1)) SWIG_fail;
4208 {
4209 arg2 = &temp2;
4210 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4211 }
4212 {
4213 PyThreadState* __tstate = wxPyBeginAllowThreads();
4214 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4215
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 {
4220 wxRealPoint * resultptr;
4221 resultptr = new wxRealPoint((wxRealPoint &)(result));
4222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4223 }
4224 return resultobj;
4225 fail:
4226 return NULL;
4227 }
4228
4229
4230 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4231 PyObject *resultobj;
4232 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4233 wxRealPoint *arg2 = 0 ;
4234 wxRealPoint result;
4235 wxRealPoint temp2 ;
4236 PyObject * obj0 = 0 ;
4237 PyObject * obj1 = 0 ;
4238 char *kwnames[] = {
4239 (char *) "self",(char *) "pt", NULL
4240 };
4241
4242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4244 if (SWIG_arg_fail(1)) SWIG_fail;
4245 {
4246 arg2 = &temp2;
4247 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4248 }
4249 {
4250 PyThreadState* __tstate = wxPyBeginAllowThreads();
4251 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4252
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 {
4257 wxRealPoint * resultptr;
4258 resultptr = new wxRealPoint((wxRealPoint &)(result));
4259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4260 }
4261 return resultobj;
4262 fail:
4263 return NULL;
4264 }
4265
4266
4267 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4268 PyObject *resultobj;
4269 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4270 double arg2 ;
4271 double arg3 ;
4272 PyObject * obj0 = 0 ;
4273 PyObject * obj1 = 0 ;
4274 PyObject * obj2 = 0 ;
4275 char *kwnames[] = {
4276 (char *) "self",(char *) "x",(char *) "y", NULL
4277 };
4278
4279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4281 if (SWIG_arg_fail(1)) SWIG_fail;
4282 {
4283 arg2 = (double)(SWIG_As_double(obj1));
4284 if (SWIG_arg_fail(2)) SWIG_fail;
4285 }
4286 {
4287 arg3 = (double)(SWIG_As_double(obj2));
4288 if (SWIG_arg_fail(3)) SWIG_fail;
4289 }
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 wxRealPoint_Set(arg1,arg2,arg3);
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 Py_INCREF(Py_None); resultobj = Py_None;
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4305 PyObject *resultobj;
4306 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4307 PyObject *result;
4308 PyObject * obj0 = 0 ;
4309 char *kwnames[] = {
4310 (char *) "self", NULL
4311 };
4312
4313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4315 if (SWIG_arg_fail(1)) SWIG_fail;
4316 {
4317 PyThreadState* __tstate = wxPyBeginAllowThreads();
4318 result = (PyObject *)wxRealPoint_Get(arg1);
4319
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = result;
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4331 PyObject *obj;
4332 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4333 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4334 Py_INCREF(obj);
4335 return Py_BuildValue((char *)"");
4336 }
4337 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxPoint *arg1 = (wxPoint *) 0 ;
4340 int arg2 ;
4341 PyObject * obj0 = 0 ;
4342 PyObject * obj1 = 0 ;
4343 char *kwnames[] = {
4344 (char *) "self",(char *) "x", NULL
4345 };
4346
4347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4349 if (SWIG_arg_fail(1)) SWIG_fail;
4350 {
4351 arg2 = (int)(SWIG_As_int(obj1));
4352 if (SWIG_arg_fail(2)) SWIG_fail;
4353 }
4354 if (arg1) (arg1)->x = arg2;
4355
4356 Py_INCREF(Py_None); resultobj = Py_None;
4357 return resultobj;
4358 fail:
4359 return NULL;
4360 }
4361
4362
4363 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4364 PyObject *resultobj;
4365 wxPoint *arg1 = (wxPoint *) 0 ;
4366 int result;
4367 PyObject * obj0 = 0 ;
4368 char *kwnames[] = {
4369 (char *) "self", NULL
4370 };
4371
4372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4374 if (SWIG_arg_fail(1)) SWIG_fail;
4375 result = (int) ((arg1)->x);
4376
4377 {
4378 resultobj = SWIG_From_int((int)(result));
4379 }
4380 return resultobj;
4381 fail:
4382 return NULL;
4383 }
4384
4385
4386 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4387 PyObject *resultobj;
4388 wxPoint *arg1 = (wxPoint *) 0 ;
4389 int arg2 ;
4390 PyObject * obj0 = 0 ;
4391 PyObject * obj1 = 0 ;
4392 char *kwnames[] = {
4393 (char *) "self",(char *) "y", NULL
4394 };
4395
4396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4398 if (SWIG_arg_fail(1)) SWIG_fail;
4399 {
4400 arg2 = (int)(SWIG_As_int(obj1));
4401 if (SWIG_arg_fail(2)) SWIG_fail;
4402 }
4403 if (arg1) (arg1)->y = arg2;
4404
4405 Py_INCREF(Py_None); resultobj = Py_None;
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4413 PyObject *resultobj;
4414 wxPoint *arg1 = (wxPoint *) 0 ;
4415 int result;
4416 PyObject * obj0 = 0 ;
4417 char *kwnames[] = {
4418 (char *) "self", NULL
4419 };
4420
4421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4423 if (SWIG_arg_fail(1)) SWIG_fail;
4424 result = (int) ((arg1)->y);
4425
4426 {
4427 resultobj = SWIG_From_int((int)(result));
4428 }
4429 return resultobj;
4430 fail:
4431 return NULL;
4432 }
4433
4434
4435 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj;
4437 int arg1 = (int) 0 ;
4438 int arg2 = (int) 0 ;
4439 wxPoint *result;
4440 PyObject * obj0 = 0 ;
4441 PyObject * obj1 = 0 ;
4442 char *kwnames[] = {
4443 (char *) "x",(char *) "y", NULL
4444 };
4445
4446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4447 if (obj0) {
4448 {
4449 arg1 = (int)(SWIG_As_int(obj0));
4450 if (SWIG_arg_fail(1)) SWIG_fail;
4451 }
4452 }
4453 if (obj1) {
4454 {
4455 arg2 = (int)(SWIG_As_int(obj1));
4456 if (SWIG_arg_fail(2)) SWIG_fail;
4457 }
4458 }
4459 {
4460 PyThreadState* __tstate = wxPyBeginAllowThreads();
4461 result = (wxPoint *)new wxPoint(arg1,arg2);
4462
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4467 return resultobj;
4468 fail:
4469 return NULL;
4470 }
4471
4472
4473 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4474 PyObject *resultobj;
4475 wxPoint *arg1 = (wxPoint *) 0 ;
4476 PyObject * obj0 = 0 ;
4477 char *kwnames[] = {
4478 (char *) "self", NULL
4479 };
4480
4481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4483 if (SWIG_arg_fail(1)) SWIG_fail;
4484 {
4485 PyThreadState* __tstate = wxPyBeginAllowThreads();
4486 delete arg1;
4487
4488 wxPyEndAllowThreads(__tstate);
4489 if (PyErr_Occurred()) SWIG_fail;
4490 }
4491 Py_INCREF(Py_None); resultobj = Py_None;
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4499 PyObject *resultobj;
4500 wxPoint *arg1 = (wxPoint *) 0 ;
4501 wxPoint *arg2 = 0 ;
4502 bool result;
4503 wxPoint temp2 ;
4504 PyObject * obj0 = 0 ;
4505 PyObject * obj1 = 0 ;
4506 char *kwnames[] = {
4507 (char *) "self",(char *) "pt", NULL
4508 };
4509
4510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4512 if (SWIG_arg_fail(1)) SWIG_fail;
4513 {
4514 arg2 = &temp2;
4515 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4516 }
4517 {
4518 PyThreadState* __tstate = wxPyBeginAllowThreads();
4519 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4520
4521 wxPyEndAllowThreads(__tstate);
4522 if (PyErr_Occurred()) SWIG_fail;
4523 }
4524 {
4525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4526 }
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4534 PyObject *resultobj;
4535 wxPoint *arg1 = (wxPoint *) 0 ;
4536 wxPoint *arg2 = 0 ;
4537 bool result;
4538 wxPoint temp2 ;
4539 PyObject * obj0 = 0 ;
4540 PyObject * obj1 = 0 ;
4541 char *kwnames[] = {
4542 (char *) "self",(char *) "pt", NULL
4543 };
4544
4545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4547 if (SWIG_arg_fail(1)) SWIG_fail;
4548 {
4549 arg2 = &temp2;
4550 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4551 }
4552 {
4553 PyThreadState* __tstate = wxPyBeginAllowThreads();
4554 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4555
4556 wxPyEndAllowThreads(__tstate);
4557 if (PyErr_Occurred()) SWIG_fail;
4558 }
4559 {
4560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4561 }
4562 return resultobj;
4563 fail:
4564 return NULL;
4565 }
4566
4567
4568 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4569 PyObject *resultobj;
4570 wxPoint *arg1 = (wxPoint *) 0 ;
4571 wxPoint *arg2 = 0 ;
4572 wxPoint result;
4573 wxPoint temp2 ;
4574 PyObject * obj0 = 0 ;
4575 PyObject * obj1 = 0 ;
4576 char *kwnames[] = {
4577 (char *) "self",(char *) "pt", NULL
4578 };
4579
4580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4582 if (SWIG_arg_fail(1)) SWIG_fail;
4583 {
4584 arg2 = &temp2;
4585 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4586 }
4587 {
4588 PyThreadState* __tstate = wxPyBeginAllowThreads();
4589 result = (arg1)->operator +((wxPoint const &)*arg2);
4590
4591 wxPyEndAllowThreads(__tstate);
4592 if (PyErr_Occurred()) SWIG_fail;
4593 }
4594 {
4595 wxPoint * resultptr;
4596 resultptr = new wxPoint((wxPoint &)(result));
4597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4598 }
4599 return resultobj;
4600 fail:
4601 return NULL;
4602 }
4603
4604
4605 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4606 PyObject *resultobj;
4607 wxPoint *arg1 = (wxPoint *) 0 ;
4608 wxPoint *arg2 = 0 ;
4609 wxPoint result;
4610 wxPoint temp2 ;
4611 PyObject * obj0 = 0 ;
4612 PyObject * obj1 = 0 ;
4613 char *kwnames[] = {
4614 (char *) "self",(char *) "pt", NULL
4615 };
4616
4617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4619 if (SWIG_arg_fail(1)) SWIG_fail;
4620 {
4621 arg2 = &temp2;
4622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4623 }
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 result = (arg1)->operator -((wxPoint const &)*arg2);
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 {
4632 wxPoint * resultptr;
4633 resultptr = new wxPoint((wxPoint &)(result));
4634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4635 }
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj;
4644 wxPoint *arg1 = (wxPoint *) 0 ;
4645 wxPoint *arg2 = 0 ;
4646 wxPoint *result;
4647 wxPoint temp2 ;
4648 PyObject * obj0 = 0 ;
4649 PyObject * obj1 = 0 ;
4650 char *kwnames[] = {
4651 (char *) "self",(char *) "pt", NULL
4652 };
4653
4654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4656 if (SWIG_arg_fail(1)) SWIG_fail;
4657 {
4658 arg2 = &temp2;
4659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4660 }
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 {
4664 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4665 result = (wxPoint *) &_result_ref;
4666 }
4667
4668 wxPyEndAllowThreads(__tstate);
4669 if (PyErr_Occurred()) SWIG_fail;
4670 }
4671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4672 return resultobj;
4673 fail:
4674 return NULL;
4675 }
4676
4677
4678 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4679 PyObject *resultobj;
4680 wxPoint *arg1 = (wxPoint *) 0 ;
4681 wxPoint *arg2 = 0 ;
4682 wxPoint *result;
4683 wxPoint temp2 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char *kwnames[] = {
4687 (char *) "self",(char *) "pt", NULL
4688 };
4689
4690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4692 if (SWIG_arg_fail(1)) SWIG_fail;
4693 {
4694 arg2 = &temp2;
4695 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4696 }
4697 {
4698 PyThreadState* __tstate = wxPyBeginAllowThreads();
4699 {
4700 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4701 result = (wxPoint *) &_result_ref;
4702 }
4703
4704 wxPyEndAllowThreads(__tstate);
4705 if (PyErr_Occurred()) SWIG_fail;
4706 }
4707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4708 return resultobj;
4709 fail:
4710 return NULL;
4711 }
4712
4713
4714 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4715 PyObject *resultobj;
4716 wxPoint *arg1 = (wxPoint *) 0 ;
4717 long arg2 ;
4718 long arg3 ;
4719 PyObject * obj0 = 0 ;
4720 PyObject * obj1 = 0 ;
4721 PyObject * obj2 = 0 ;
4722 char *kwnames[] = {
4723 (char *) "self",(char *) "x",(char *) "y", NULL
4724 };
4725
4726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4728 if (SWIG_arg_fail(1)) SWIG_fail;
4729 {
4730 arg2 = (long)(SWIG_As_long(obj1));
4731 if (SWIG_arg_fail(2)) SWIG_fail;
4732 }
4733 {
4734 arg3 = (long)(SWIG_As_long(obj2));
4735 if (SWIG_arg_fail(3)) SWIG_fail;
4736 }
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 wxPoint_Set(arg1,arg2,arg3);
4740
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 Py_INCREF(Py_None); resultobj = Py_None;
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4752 PyObject *resultobj;
4753 wxPoint *arg1 = (wxPoint *) 0 ;
4754 PyObject *result;
4755 PyObject * obj0 = 0 ;
4756 char *kwnames[] = {
4757 (char *) "self", NULL
4758 };
4759
4760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4762 if (SWIG_arg_fail(1)) SWIG_fail;
4763 {
4764 PyThreadState* __tstate = wxPyBeginAllowThreads();
4765 result = (PyObject *)wxPoint_Get(arg1);
4766
4767 wxPyEndAllowThreads(__tstate);
4768 if (PyErr_Occurred()) SWIG_fail;
4769 }
4770 resultobj = result;
4771 return resultobj;
4772 fail:
4773 return NULL;
4774 }
4775
4776
4777 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4778 PyObject *obj;
4779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4780 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4781 Py_INCREF(obj);
4782 return Py_BuildValue((char *)"");
4783 }
4784 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj;
4786 int arg1 = (int) 0 ;
4787 int arg2 = (int) 0 ;
4788 int arg3 = (int) 0 ;
4789 int arg4 = (int) 0 ;
4790 wxRect *result;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 PyObject * obj2 = 0 ;
4794 PyObject * obj3 = 0 ;
4795 char *kwnames[] = {
4796 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4797 };
4798
4799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4800 if (obj0) {
4801 {
4802 arg1 = (int)(SWIG_As_int(obj0));
4803 if (SWIG_arg_fail(1)) SWIG_fail;
4804 }
4805 }
4806 if (obj1) {
4807 {
4808 arg2 = (int)(SWIG_As_int(obj1));
4809 if (SWIG_arg_fail(2)) SWIG_fail;
4810 }
4811 }
4812 if (obj2) {
4813 {
4814 arg3 = (int)(SWIG_As_int(obj2));
4815 if (SWIG_arg_fail(3)) SWIG_fail;
4816 }
4817 }
4818 if (obj3) {
4819 {
4820 arg4 = (int)(SWIG_As_int(obj3));
4821 if (SWIG_arg_fail(4)) SWIG_fail;
4822 }
4823 }
4824 {
4825 PyThreadState* __tstate = wxPyBeginAllowThreads();
4826 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4827
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4832 return resultobj;
4833 fail:
4834 return NULL;
4835 }
4836
4837
4838 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj;
4840 wxPoint *arg1 = 0 ;
4841 wxPoint *arg2 = 0 ;
4842 wxRect *result;
4843 wxPoint temp1 ;
4844 wxPoint temp2 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 char *kwnames[] = {
4848 (char *) "topLeft",(char *) "bottomRight", NULL
4849 };
4850
4851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4852 {
4853 arg1 = &temp1;
4854 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4855 }
4856 {
4857 arg2 = &temp2;
4858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4859 }
4860 {
4861 PyThreadState* __tstate = wxPyBeginAllowThreads();
4862 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4863
4864 wxPyEndAllowThreads(__tstate);
4865 if (PyErr_Occurred()) SWIG_fail;
4866 }
4867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4868 return resultobj;
4869 fail:
4870 return NULL;
4871 }
4872
4873
4874 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4875 PyObject *resultobj;
4876 wxPoint *arg1 = 0 ;
4877 wxSize *arg2 = 0 ;
4878 wxRect *result;
4879 wxPoint temp1 ;
4880 wxSize temp2 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 char *kwnames[] = {
4884 (char *) "pos",(char *) "size", NULL
4885 };
4886
4887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4888 {
4889 arg1 = &temp1;
4890 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4891 }
4892 {
4893 arg2 = &temp2;
4894 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4895 }
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4904 return resultobj;
4905 fail:
4906 return NULL;
4907 }
4908
4909
4910 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4911 PyObject *resultobj;
4912 wxSize *arg1 = 0 ;
4913 wxRect *result;
4914 wxSize temp1 ;
4915 PyObject * obj0 = 0 ;
4916 char *kwnames[] = {
4917 (char *) "size", NULL
4918 };
4919
4920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4921 {
4922 arg1 = &temp1;
4923 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4924 }
4925 {
4926 PyThreadState* __tstate = wxPyBeginAllowThreads();
4927 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4928
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4933 return resultobj;
4934 fail:
4935 return NULL;
4936 }
4937
4938
4939 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4940 PyObject *resultobj;
4941 wxRect *arg1 = (wxRect *) 0 ;
4942 PyObject * obj0 = 0 ;
4943 char *kwnames[] = {
4944 (char *) "self", NULL
4945 };
4946
4947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4949 if (SWIG_arg_fail(1)) SWIG_fail;
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 delete arg1;
4953
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 Py_INCREF(Py_None); resultobj = Py_None;
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj;
4966 wxRect *arg1 = (wxRect *) 0 ;
4967 int result;
4968 PyObject * obj0 = 0 ;
4969 char *kwnames[] = {
4970 (char *) "self", NULL
4971 };
4972
4973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4975 if (SWIG_arg_fail(1)) SWIG_fail;
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (int)((wxRect const *)arg1)->GetX();
4979
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 {
4984 resultobj = SWIG_From_int((int)(result));
4985 }
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4993 PyObject *resultobj;
4994 wxRect *arg1 = (wxRect *) 0 ;
4995 int arg2 ;
4996 PyObject * obj0 = 0 ;
4997 PyObject * obj1 = 0 ;
4998 char *kwnames[] = {
4999 (char *) "self",(char *) "x", NULL
5000 };
5001
5002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5004 if (SWIG_arg_fail(1)) SWIG_fail;
5005 {
5006 arg2 = (int)(SWIG_As_int(obj1));
5007 if (SWIG_arg_fail(2)) SWIG_fail;
5008 }
5009 {
5010 PyThreadState* __tstate = wxPyBeginAllowThreads();
5011 (arg1)->SetX(arg2);
5012
5013 wxPyEndAllowThreads(__tstate);
5014 if (PyErr_Occurred()) SWIG_fail;
5015 }
5016 Py_INCREF(Py_None); resultobj = Py_None;
5017 return resultobj;
5018 fail:
5019 return NULL;
5020 }
5021
5022
5023 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5024 PyObject *resultobj;
5025 wxRect *arg1 = (wxRect *) 0 ;
5026 int result;
5027 PyObject * obj0 = 0 ;
5028 char *kwnames[] = {
5029 (char *) "self", NULL
5030 };
5031
5032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5034 if (SWIG_arg_fail(1)) SWIG_fail;
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = (int)(arg1)->GetY();
5038
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 {
5043 resultobj = SWIG_From_int((int)(result));
5044 }
5045 return resultobj;
5046 fail:
5047 return NULL;
5048 }
5049
5050
5051 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5052 PyObject *resultobj;
5053 wxRect *arg1 = (wxRect *) 0 ;
5054 int arg2 ;
5055 PyObject * obj0 = 0 ;
5056 PyObject * obj1 = 0 ;
5057 char *kwnames[] = {
5058 (char *) "self",(char *) "y", NULL
5059 };
5060
5061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5063 if (SWIG_arg_fail(1)) SWIG_fail;
5064 {
5065 arg2 = (int)(SWIG_As_int(obj1));
5066 if (SWIG_arg_fail(2)) SWIG_fail;
5067 }
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 (arg1)->SetY(arg2);
5071
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 Py_INCREF(Py_None); resultobj = Py_None;
5076 return resultobj;
5077 fail:
5078 return NULL;
5079 }
5080
5081
5082 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5083 PyObject *resultobj;
5084 wxRect *arg1 = (wxRect *) 0 ;
5085 int result;
5086 PyObject * obj0 = 0 ;
5087 char *kwnames[] = {
5088 (char *) "self", NULL
5089 };
5090
5091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5093 if (SWIG_arg_fail(1)) SWIG_fail;
5094 {
5095 PyThreadState* __tstate = wxPyBeginAllowThreads();
5096 result = (int)((wxRect const *)arg1)->GetWidth();
5097
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 {
5102 resultobj = SWIG_From_int((int)(result));
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj;
5112 wxRect *arg1 = (wxRect *) 0 ;
5113 int arg2 ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 char *kwnames[] = {
5117 (char *) "self",(char *) "w", NULL
5118 };
5119
5120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5122 if (SWIG_arg_fail(1)) SWIG_fail;
5123 {
5124 arg2 = (int)(SWIG_As_int(obj1));
5125 if (SWIG_arg_fail(2)) SWIG_fail;
5126 }
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 (arg1)->SetWidth(arg2);
5130
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 Py_INCREF(Py_None); resultobj = Py_None;
5135 return resultobj;
5136 fail:
5137 return NULL;
5138 }
5139
5140
5141 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5142 PyObject *resultobj;
5143 wxRect *arg1 = (wxRect *) 0 ;
5144 int result;
5145 PyObject * obj0 = 0 ;
5146 char *kwnames[] = {
5147 (char *) "self", NULL
5148 };
5149
5150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5152 if (SWIG_arg_fail(1)) SWIG_fail;
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (int)((wxRect const *)arg1)->GetHeight();
5156
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 {
5161 resultobj = SWIG_From_int((int)(result));
5162 }
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5170 PyObject *resultobj;
5171 wxRect *arg1 = (wxRect *) 0 ;
5172 int arg2 ;
5173 PyObject * obj0 = 0 ;
5174 PyObject * obj1 = 0 ;
5175 char *kwnames[] = {
5176 (char *) "self",(char *) "h", NULL
5177 };
5178
5179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5181 if (SWIG_arg_fail(1)) SWIG_fail;
5182 {
5183 arg2 = (int)(SWIG_As_int(obj1));
5184 if (SWIG_arg_fail(2)) SWIG_fail;
5185 }
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 (arg1)->SetHeight(arg2);
5189
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 Py_INCREF(Py_None); resultobj = Py_None;
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj;
5202 wxRect *arg1 = (wxRect *) 0 ;
5203 wxPoint result;
5204 PyObject * obj0 = 0 ;
5205 char *kwnames[] = {
5206 (char *) "self", NULL
5207 };
5208
5209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5211 if (SWIG_arg_fail(1)) SWIG_fail;
5212 {
5213 PyThreadState* __tstate = wxPyBeginAllowThreads();
5214 result = ((wxRect const *)arg1)->GetPosition();
5215
5216 wxPyEndAllowThreads(__tstate);
5217 if (PyErr_Occurred()) SWIG_fail;
5218 }
5219 {
5220 wxPoint * resultptr;
5221 resultptr = new wxPoint((wxPoint &)(result));
5222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5223 }
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5231 PyObject *resultobj;
5232 wxRect *arg1 = (wxRect *) 0 ;
5233 wxPoint *arg2 = 0 ;
5234 wxPoint temp2 ;
5235 PyObject * obj0 = 0 ;
5236 PyObject * obj1 = 0 ;
5237 char *kwnames[] = {
5238 (char *) "self",(char *) "p", NULL
5239 };
5240
5241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5243 if (SWIG_arg_fail(1)) SWIG_fail;
5244 {
5245 arg2 = &temp2;
5246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5247 }
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 (arg1)->SetPosition((wxPoint const &)*arg2);
5251
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 Py_INCREF(Py_None); resultobj = Py_None;
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj;
5264 wxRect *arg1 = (wxRect *) 0 ;
5265 wxSize result;
5266 PyObject * obj0 = 0 ;
5267 char *kwnames[] = {
5268 (char *) "self", NULL
5269 };
5270
5271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5273 if (SWIG_arg_fail(1)) SWIG_fail;
5274 {
5275 PyThreadState* __tstate = wxPyBeginAllowThreads();
5276 result = ((wxRect const *)arg1)->GetSize();
5277
5278 wxPyEndAllowThreads(__tstate);
5279 if (PyErr_Occurred()) SWIG_fail;
5280 }
5281 {
5282 wxSize * resultptr;
5283 resultptr = new wxSize((wxSize &)(result));
5284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5285 }
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj;
5294 wxRect *arg1 = (wxRect *) 0 ;
5295 wxSize *arg2 = 0 ;
5296 wxSize temp2 ;
5297 PyObject * obj0 = 0 ;
5298 PyObject * obj1 = 0 ;
5299 char *kwnames[] = {
5300 (char *) "self",(char *) "s", NULL
5301 };
5302
5303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5305 if (SWIG_arg_fail(1)) SWIG_fail;
5306 {
5307 arg2 = &temp2;
5308 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5309 }
5310 {
5311 PyThreadState* __tstate = wxPyBeginAllowThreads();
5312 (arg1)->SetSize((wxSize const &)*arg2);
5313
5314 wxPyEndAllowThreads(__tstate);
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 Py_INCREF(Py_None); resultobj = Py_None;
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5325 PyObject *resultobj;
5326 wxRect *arg1 = (wxRect *) 0 ;
5327 bool result;
5328 PyObject * obj0 = 0 ;
5329 char *kwnames[] = {
5330 (char *) "self", NULL
5331 };
5332
5333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5335 if (SWIG_arg_fail(1)) SWIG_fail;
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 result = (bool)((wxRect const *)arg1)->IsEmpty();
5339
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 {
5344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5345 }
5346 return resultobj;
5347 fail:
5348 return NULL;
5349 }
5350
5351
5352 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5353 PyObject *resultobj;
5354 wxRect *arg1 = (wxRect *) 0 ;
5355 wxPoint result;
5356 PyObject * obj0 = 0 ;
5357 char *kwnames[] = {
5358 (char *) "self", NULL
5359 };
5360
5361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5363 if (SWIG_arg_fail(1)) SWIG_fail;
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 result = ((wxRect const *)arg1)->GetTopLeft();
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 wxPoint * resultptr;
5373 resultptr = new wxPoint((wxPoint &)(result));
5374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5375 }
5376 return resultobj;
5377 fail:
5378 return NULL;
5379 }
5380
5381
5382 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5383 PyObject *resultobj;
5384 wxRect *arg1 = (wxRect *) 0 ;
5385 wxPoint *arg2 = 0 ;
5386 wxPoint temp2 ;
5387 PyObject * obj0 = 0 ;
5388 PyObject * obj1 = 0 ;
5389 char *kwnames[] = {
5390 (char *) "self",(char *) "p", NULL
5391 };
5392
5393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5395 if (SWIG_arg_fail(1)) SWIG_fail;
5396 {
5397 arg2 = &temp2;
5398 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5399 }
5400 {
5401 PyThreadState* __tstate = wxPyBeginAllowThreads();
5402 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5403
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 Py_INCREF(Py_None); resultobj = Py_None;
5408 return resultobj;
5409 fail:
5410 return NULL;
5411 }
5412
5413
5414 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5415 PyObject *resultobj;
5416 wxRect *arg1 = (wxRect *) 0 ;
5417 wxPoint result;
5418 PyObject * obj0 = 0 ;
5419 char *kwnames[] = {
5420 (char *) "self", NULL
5421 };
5422
5423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5425 if (SWIG_arg_fail(1)) SWIG_fail;
5426 {
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 result = ((wxRect const *)arg1)->GetBottomRight();
5429
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 {
5434 wxPoint * resultptr;
5435 resultptr = new wxPoint((wxPoint &)(result));
5436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj;
5446 wxRect *arg1 = (wxRect *) 0 ;
5447 wxPoint *arg2 = 0 ;
5448 wxPoint temp2 ;
5449 PyObject * obj0 = 0 ;
5450 PyObject * obj1 = 0 ;
5451 char *kwnames[] = {
5452 (char *) "self",(char *) "p", NULL
5453 };
5454
5455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5457 if (SWIG_arg_fail(1)) SWIG_fail;
5458 {
5459 arg2 = &temp2;
5460 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5461 }
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5465
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 Py_INCREF(Py_None); resultobj = Py_None;
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5477 PyObject *resultobj;
5478 wxRect *arg1 = (wxRect *) 0 ;
5479 int result;
5480 PyObject * obj0 = 0 ;
5481 char *kwnames[] = {
5482 (char *) "self", NULL
5483 };
5484
5485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5487 if (SWIG_arg_fail(1)) SWIG_fail;
5488 {
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 result = (int)((wxRect const *)arg1)->GetLeft();
5491
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 {
5496 resultobj = SWIG_From_int((int)(result));
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj;
5506 wxRect *arg1 = (wxRect *) 0 ;
5507 int result;
5508 PyObject * obj0 = 0 ;
5509 char *kwnames[] = {
5510 (char *) "self", NULL
5511 };
5512
5513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5515 if (SWIG_arg_fail(1)) SWIG_fail;
5516 {
5517 PyThreadState* __tstate = wxPyBeginAllowThreads();
5518 result = (int)((wxRect const *)arg1)->GetTop();
5519
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 {
5524 resultobj = SWIG_From_int((int)(result));
5525 }
5526 return resultobj;
5527 fail:
5528 return NULL;
5529 }
5530
5531
5532 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5533 PyObject *resultobj;
5534 wxRect *arg1 = (wxRect *) 0 ;
5535 int result;
5536 PyObject * obj0 = 0 ;
5537 char *kwnames[] = {
5538 (char *) "self", NULL
5539 };
5540
5541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5543 if (SWIG_arg_fail(1)) SWIG_fail;
5544 {
5545 PyThreadState* __tstate = wxPyBeginAllowThreads();
5546 result = (int)((wxRect const *)arg1)->GetBottom();
5547
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 {
5552 resultobj = SWIG_From_int((int)(result));
5553 }
5554 return resultobj;
5555 fail:
5556 return NULL;
5557 }
5558
5559
5560 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5561 PyObject *resultobj;
5562 wxRect *arg1 = (wxRect *) 0 ;
5563 int result;
5564 PyObject * obj0 = 0 ;
5565 char *kwnames[] = {
5566 (char *) "self", NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5571 if (SWIG_arg_fail(1)) SWIG_fail;
5572 {
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (int)((wxRect const *)arg1)->GetRight();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = SWIG_From_int((int)(result));
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 wxRect *arg1 = (wxRect *) 0 ;
5591 int arg2 ;
5592 PyObject * obj0 = 0 ;
5593 PyObject * obj1 = 0 ;
5594 char *kwnames[] = {
5595 (char *) "self",(char *) "left", NULL
5596 };
5597
5598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5600 if (SWIG_arg_fail(1)) SWIG_fail;
5601 {
5602 arg2 = (int)(SWIG_As_int(obj1));
5603 if (SWIG_arg_fail(2)) SWIG_fail;
5604 }
5605 {
5606 PyThreadState* __tstate = wxPyBeginAllowThreads();
5607 (arg1)->SetLeft(arg2);
5608
5609 wxPyEndAllowThreads(__tstate);
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 Py_INCREF(Py_None); resultobj = Py_None;
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5620 PyObject *resultobj;
5621 wxRect *arg1 = (wxRect *) 0 ;
5622 int arg2 ;
5623 PyObject * obj0 = 0 ;
5624 PyObject * obj1 = 0 ;
5625 char *kwnames[] = {
5626 (char *) "self",(char *) "right", NULL
5627 };
5628
5629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5631 if (SWIG_arg_fail(1)) SWIG_fail;
5632 {
5633 arg2 = (int)(SWIG_As_int(obj1));
5634 if (SWIG_arg_fail(2)) SWIG_fail;
5635 }
5636 {
5637 PyThreadState* __tstate = wxPyBeginAllowThreads();
5638 (arg1)->SetRight(arg2);
5639
5640 wxPyEndAllowThreads(__tstate);
5641 if (PyErr_Occurred()) SWIG_fail;
5642 }
5643 Py_INCREF(Py_None); resultobj = Py_None;
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj;
5652 wxRect *arg1 = (wxRect *) 0 ;
5653 int arg2 ;
5654 PyObject * obj0 = 0 ;
5655 PyObject * obj1 = 0 ;
5656 char *kwnames[] = {
5657 (char *) "self",(char *) "top", NULL
5658 };
5659
5660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5662 if (SWIG_arg_fail(1)) SWIG_fail;
5663 {
5664 arg2 = (int)(SWIG_As_int(obj1));
5665 if (SWIG_arg_fail(2)) SWIG_fail;
5666 }
5667 {
5668 PyThreadState* __tstate = wxPyBeginAllowThreads();
5669 (arg1)->SetTop(arg2);
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 Py_INCREF(Py_None); resultobj = Py_None;
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj;
5683 wxRect *arg1 = (wxRect *) 0 ;
5684 int arg2 ;
5685 PyObject * obj0 = 0 ;
5686 PyObject * obj1 = 0 ;
5687 char *kwnames[] = {
5688 (char *) "self",(char *) "bottom", NULL
5689 };
5690
5691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5693 if (SWIG_arg_fail(1)) SWIG_fail;
5694 {
5695 arg2 = (int)(SWIG_As_int(obj1));
5696 if (SWIG_arg_fail(2)) SWIG_fail;
5697 }
5698 {
5699 PyThreadState* __tstate = wxPyBeginAllowThreads();
5700 (arg1)->SetBottom(arg2);
5701
5702 wxPyEndAllowThreads(__tstate);
5703 if (PyErr_Occurred()) SWIG_fail;
5704 }
5705 Py_INCREF(Py_None); resultobj = Py_None;
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5713 PyObject *resultobj;
5714 wxRect *arg1 = (wxRect *) 0 ;
5715 int arg2 ;
5716 int arg3 ;
5717 wxRect *result;
5718 PyObject * obj0 = 0 ;
5719 PyObject * obj1 = 0 ;
5720 PyObject * obj2 = 0 ;
5721 char *kwnames[] = {
5722 (char *) "self",(char *) "dx",(char *) "dy", NULL
5723 };
5724
5725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5727 if (SWIG_arg_fail(1)) SWIG_fail;
5728 {
5729 arg2 = (int)(SWIG_As_int(obj1));
5730 if (SWIG_arg_fail(2)) SWIG_fail;
5731 }
5732 {
5733 arg3 = (int)(SWIG_As_int(obj2));
5734 if (SWIG_arg_fail(3)) SWIG_fail;
5735 }
5736 {
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 {
5739 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5740 result = (wxRect *) &_result_ref;
5741 }
5742
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5754 PyObject *resultobj;
5755 wxRect *arg1 = (wxRect *) 0 ;
5756 int arg2 ;
5757 int arg3 ;
5758 wxRect *result;
5759 PyObject * obj0 = 0 ;
5760 PyObject * obj1 = 0 ;
5761 PyObject * obj2 = 0 ;
5762 char *kwnames[] = {
5763 (char *) "self",(char *) "dx",(char *) "dy", NULL
5764 };
5765
5766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5768 if (SWIG_arg_fail(1)) SWIG_fail;
5769 {
5770 arg2 = (int)(SWIG_As_int(obj1));
5771 if (SWIG_arg_fail(2)) SWIG_fail;
5772 }
5773 {
5774 arg3 = (int)(SWIG_As_int(obj2));
5775 if (SWIG_arg_fail(3)) SWIG_fail;
5776 }
5777 {
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 {
5780 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5781 result = (wxRect *) &_result_ref;
5782 }
5783
5784 wxPyEndAllowThreads(__tstate);
5785 if (PyErr_Occurred()) SWIG_fail;
5786 }
5787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj;
5796 wxRect *arg1 = (wxRect *) 0 ;
5797 int arg2 ;
5798 int arg3 ;
5799 PyObject * obj0 = 0 ;
5800 PyObject * obj1 = 0 ;
5801 PyObject * obj2 = 0 ;
5802 char *kwnames[] = {
5803 (char *) "self",(char *) "dx",(char *) "dy", NULL
5804 };
5805
5806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5808 if (SWIG_arg_fail(1)) SWIG_fail;
5809 {
5810 arg2 = (int)(SWIG_As_int(obj1));
5811 if (SWIG_arg_fail(2)) SWIG_fail;
5812 }
5813 {
5814 arg3 = (int)(SWIG_As_int(obj2));
5815 if (SWIG_arg_fail(3)) SWIG_fail;
5816 }
5817 {
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 (arg1)->Offset(arg2,arg3);
5820
5821 wxPyEndAllowThreads(__tstate);
5822 if (PyErr_Occurred()) SWIG_fail;
5823 }
5824 Py_INCREF(Py_None); resultobj = Py_None;
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj;
5833 wxRect *arg1 = (wxRect *) 0 ;
5834 wxPoint *arg2 = 0 ;
5835 wxPoint temp2 ;
5836 PyObject * obj0 = 0 ;
5837 PyObject * obj1 = 0 ;
5838 char *kwnames[] = {
5839 (char *) "self",(char *) "pt", NULL
5840 };
5841
5842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5844 if (SWIG_arg_fail(1)) SWIG_fail;
5845 {
5846 arg2 = &temp2;
5847 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5848 }
5849 {
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 (arg1)->Offset((wxPoint const &)*arg2);
5852
5853 wxPyEndAllowThreads(__tstate);
5854 if (PyErr_Occurred()) SWIG_fail;
5855 }
5856 Py_INCREF(Py_None); resultobj = Py_None;
5857 return resultobj;
5858 fail:
5859 return NULL;
5860 }
5861
5862
5863 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5864 PyObject *resultobj;
5865 wxRect *arg1 = (wxRect *) 0 ;
5866 wxRect *arg2 = 0 ;
5867 wxRect result;
5868 wxRect temp2 ;
5869 PyObject * obj0 = 0 ;
5870 PyObject * obj1 = 0 ;
5871 char *kwnames[] = {
5872 (char *) "self",(char *) "rect", NULL
5873 };
5874
5875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5877 if (SWIG_arg_fail(1)) SWIG_fail;
5878 {
5879 arg2 = &temp2;
5880 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5881 }
5882 {
5883 PyThreadState* __tstate = wxPyBeginAllowThreads();
5884 result = (arg1)->Intersect((wxRect const &)*arg2);
5885
5886 wxPyEndAllowThreads(__tstate);
5887 if (PyErr_Occurred()) SWIG_fail;
5888 }
5889 {
5890 wxRect * resultptr;
5891 resultptr = new wxRect((wxRect &)(result));
5892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5893 }
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxRect *arg1 = (wxRect *) 0 ;
5903 wxRect *arg2 = 0 ;
5904 wxRect result;
5905 wxRect temp2 ;
5906 PyObject * obj0 = 0 ;
5907 PyObject * obj1 = 0 ;
5908 char *kwnames[] = {
5909 (char *) "self",(char *) "rect", NULL
5910 };
5911
5912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5914 if (SWIG_arg_fail(1)) SWIG_fail;
5915 {
5916 arg2 = &temp2;
5917 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5918 }
5919 {
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 result = (arg1)->Union((wxRect const &)*arg2);
5922
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 {
5927 wxRect * resultptr;
5928 resultptr = new wxRect((wxRect &)(result));
5929 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5930 }
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5938 PyObject *resultobj;
5939 wxRect *arg1 = (wxRect *) 0 ;
5940 wxRect *arg2 = 0 ;
5941 wxRect result;
5942 wxRect temp2 ;
5943 PyObject * obj0 = 0 ;
5944 PyObject * obj1 = 0 ;
5945 char *kwnames[] = {
5946 (char *) "self",(char *) "rect", NULL
5947 };
5948
5949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5951 if (SWIG_arg_fail(1)) SWIG_fail;
5952 {
5953 arg2 = &temp2;
5954 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5955 }
5956 {
5957 PyThreadState* __tstate = wxPyBeginAllowThreads();
5958 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5959
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 {
5964 wxRect * resultptr;
5965 resultptr = new wxRect((wxRect &)(result));
5966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5967 }
5968 return resultobj;
5969 fail:
5970 return NULL;
5971 }
5972
5973
5974 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5975 PyObject *resultobj;
5976 wxRect *arg1 = (wxRect *) 0 ;
5977 wxRect *arg2 = 0 ;
5978 wxRect *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___iadd__",kwnames,&obj0,&obj1)) goto fail;
5987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
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 {
5996 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5997 result = (wxRect *) &_result_ref;
5998 }
5999
6000 wxPyEndAllowThreads(__tstate);
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj;
6012 wxRect *arg1 = (wxRect *) 0 ;
6013 wxRect *arg2 = 0 ;
6014 bool result;
6015 wxRect temp2 ;
6016 PyObject * obj0 = 0 ;
6017 PyObject * obj1 = 0 ;
6018 char *kwnames[] = {
6019 (char *) "self",(char *) "rect", NULL
6020 };
6021
6022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) 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 = &temp2;
6027 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6028 }
6029 {
6030 PyThreadState* __tstate = wxPyBeginAllowThreads();
6031 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6032
6033 wxPyEndAllowThreads(__tstate);
6034 if (PyErr_Occurred()) SWIG_fail;
6035 }
6036 {
6037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6038 }
6039 return resultobj;
6040 fail:
6041 return NULL;
6042 }
6043
6044
6045 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6046 PyObject *resultobj;
6047 wxRect *arg1 = (wxRect *) 0 ;
6048 wxRect *arg2 = 0 ;
6049 bool result;
6050 wxRect temp2 ;
6051 PyObject * obj0 = 0 ;
6052 PyObject * obj1 = 0 ;
6053 char *kwnames[] = {
6054 (char *) "self",(char *) "rect", NULL
6055 };
6056
6057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6059 if (SWIG_arg_fail(1)) SWIG_fail;
6060 {
6061 arg2 = &temp2;
6062 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6063 }
6064 {
6065 PyThreadState* __tstate = wxPyBeginAllowThreads();
6066 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6067
6068 wxPyEndAllowThreads(__tstate);
6069 if (PyErr_Occurred()) SWIG_fail;
6070 }
6071 {
6072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6073 }
6074 return resultobj;
6075 fail:
6076 return NULL;
6077 }
6078
6079
6080 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6081 PyObject *resultobj;
6082 wxRect *arg1 = (wxRect *) 0 ;
6083 int arg2 ;
6084 int arg3 ;
6085 bool result;
6086 PyObject * obj0 = 0 ;
6087 PyObject * obj1 = 0 ;
6088 PyObject * obj2 = 0 ;
6089 char *kwnames[] = {
6090 (char *) "self",(char *) "x",(char *) "y", NULL
6091 };
6092
6093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6095 if (SWIG_arg_fail(1)) SWIG_fail;
6096 {
6097 arg2 = (int)(SWIG_As_int(obj1));
6098 if (SWIG_arg_fail(2)) SWIG_fail;
6099 }
6100 {
6101 arg3 = (int)(SWIG_As_int(obj2));
6102 if (SWIG_arg_fail(3)) SWIG_fail;
6103 }
6104 {
6105 PyThreadState* __tstate = wxPyBeginAllowThreads();
6106 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6107
6108 wxPyEndAllowThreads(__tstate);
6109 if (PyErr_Occurred()) SWIG_fail;
6110 }
6111 {
6112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6113 }
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj;
6122 wxRect *arg1 = (wxRect *) 0 ;
6123 wxPoint *arg2 = 0 ;
6124 bool result;
6125 wxPoint temp2 ;
6126 PyObject * obj0 = 0 ;
6127 PyObject * obj1 = 0 ;
6128 char *kwnames[] = {
6129 (char *) "self",(char *) "pt", NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6134 if (SWIG_arg_fail(1)) SWIG_fail;
6135 {
6136 arg2 = &temp2;
6137 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6142
6143 wxPyEndAllowThreads(__tstate);
6144 if (PyErr_Occurred()) SWIG_fail;
6145 }
6146 {
6147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6148 }
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6156 PyObject *resultobj;
6157 wxRect *arg1 = (wxRect *) 0 ;
6158 wxRect *arg2 = 0 ;
6159 bool result;
6160 wxRect temp2 ;
6161 PyObject * obj0 = 0 ;
6162 PyObject * obj1 = 0 ;
6163 char *kwnames[] = {
6164 (char *) "self",(char *) "rect", NULL
6165 };
6166
6167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6169 if (SWIG_arg_fail(1)) SWIG_fail;
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6177
6178 wxPyEndAllowThreads(__tstate);
6179 if (PyErr_Occurred()) SWIG_fail;
6180 }
6181 {
6182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6183 }
6184 return resultobj;
6185 fail:
6186 return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj;
6192 wxRect *arg1 = (wxRect *) 0 ;
6193 int arg2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char *kwnames[] = {
6197 (char *) "self",(char *) "x", NULL
6198 };
6199
6200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6202 if (SWIG_arg_fail(1)) SWIG_fail;
6203 {
6204 arg2 = (int)(SWIG_As_int(obj1));
6205 if (SWIG_arg_fail(2)) SWIG_fail;
6206 }
6207 if (arg1) (arg1)->x = arg2;
6208
6209 Py_INCREF(Py_None); resultobj = Py_None;
6210 return resultobj;
6211 fail:
6212 return NULL;
6213 }
6214
6215
6216 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6217 PyObject *resultobj;
6218 wxRect *arg1 = (wxRect *) 0 ;
6219 int result;
6220 PyObject * obj0 = 0 ;
6221 char *kwnames[] = {
6222 (char *) "self", NULL
6223 };
6224
6225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6227 if (SWIG_arg_fail(1)) SWIG_fail;
6228 result = (int) ((arg1)->x);
6229
6230 {
6231 resultobj = SWIG_From_int((int)(result));
6232 }
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int arg2 ;
6243 PyObject * obj0 = 0 ;
6244 PyObject * obj1 = 0 ;
6245 char *kwnames[] = {
6246 (char *) "self",(char *) "y", NULL
6247 };
6248
6249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6251 if (SWIG_arg_fail(1)) SWIG_fail;
6252 {
6253 arg2 = (int)(SWIG_As_int(obj1));
6254 if (SWIG_arg_fail(2)) SWIG_fail;
6255 }
6256 if (arg1) (arg1)->y = arg2;
6257
6258 Py_INCREF(Py_None); resultobj = Py_None;
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj;
6267 wxRect *arg1 = (wxRect *) 0 ;
6268 int result;
6269 PyObject * obj0 = 0 ;
6270 char *kwnames[] = {
6271 (char *) "self", NULL
6272 };
6273
6274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6276 if (SWIG_arg_fail(1)) SWIG_fail;
6277 result = (int) ((arg1)->y);
6278
6279 {
6280 resultobj = SWIG_From_int((int)(result));
6281 }
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 wxRect *arg1 = (wxRect *) 0 ;
6291 int arg2 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 char *kwnames[] = {
6295 (char *) "self",(char *) "width", NULL
6296 };
6297
6298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6300 if (SWIG_arg_fail(1)) SWIG_fail;
6301 {
6302 arg2 = (int)(SWIG_As_int(obj1));
6303 if (SWIG_arg_fail(2)) SWIG_fail;
6304 }
6305 if (arg1) (arg1)->width = arg2;
6306
6307 Py_INCREF(Py_None); resultobj = Py_None;
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6315 PyObject *resultobj;
6316 wxRect *arg1 = (wxRect *) 0 ;
6317 int result;
6318 PyObject * obj0 = 0 ;
6319 char *kwnames[] = {
6320 (char *) "self", NULL
6321 };
6322
6323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6325 if (SWIG_arg_fail(1)) SWIG_fail;
6326 result = (int) ((arg1)->width);
6327
6328 {
6329 resultobj = SWIG_From_int((int)(result));
6330 }
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj;
6339 wxRect *arg1 = (wxRect *) 0 ;
6340 int arg2 ;
6341 PyObject * obj0 = 0 ;
6342 PyObject * obj1 = 0 ;
6343 char *kwnames[] = {
6344 (char *) "self",(char *) "height", NULL
6345 };
6346
6347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6349 if (SWIG_arg_fail(1)) SWIG_fail;
6350 {
6351 arg2 = (int)(SWIG_As_int(obj1));
6352 if (SWIG_arg_fail(2)) SWIG_fail;
6353 }
6354 if (arg1) (arg1)->height = arg2;
6355
6356 Py_INCREF(Py_None); resultobj = Py_None;
6357 return resultobj;
6358 fail:
6359 return NULL;
6360 }
6361
6362
6363 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6364 PyObject *resultobj;
6365 wxRect *arg1 = (wxRect *) 0 ;
6366 int result;
6367 PyObject * obj0 = 0 ;
6368 char *kwnames[] = {
6369 (char *) "self", NULL
6370 };
6371
6372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6374 if (SWIG_arg_fail(1)) SWIG_fail;
6375 result = (int) ((arg1)->height);
6376
6377 {
6378 resultobj = SWIG_From_int((int)(result));
6379 }
6380 return resultobj;
6381 fail:
6382 return NULL;
6383 }
6384
6385
6386 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6387 PyObject *resultobj;
6388 wxRect *arg1 = (wxRect *) 0 ;
6389 int arg2 = (int) 0 ;
6390 int arg3 = (int) 0 ;
6391 int arg4 = (int) 0 ;
6392 int arg5 = (int) 0 ;
6393 PyObject * obj0 = 0 ;
6394 PyObject * obj1 = 0 ;
6395 PyObject * obj2 = 0 ;
6396 PyObject * obj3 = 0 ;
6397 PyObject * obj4 = 0 ;
6398 char *kwnames[] = {
6399 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6400 };
6401
6402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6404 if (SWIG_arg_fail(1)) SWIG_fail;
6405 if (obj1) {
6406 {
6407 arg2 = (int)(SWIG_As_int(obj1));
6408 if (SWIG_arg_fail(2)) SWIG_fail;
6409 }
6410 }
6411 if (obj2) {
6412 {
6413 arg3 = (int)(SWIG_As_int(obj2));
6414 if (SWIG_arg_fail(3)) SWIG_fail;
6415 }
6416 }
6417 if (obj3) {
6418 {
6419 arg4 = (int)(SWIG_As_int(obj3));
6420 if (SWIG_arg_fail(4)) SWIG_fail;
6421 }
6422 }
6423 if (obj4) {
6424 {
6425 arg5 = (int)(SWIG_As_int(obj4));
6426 if (SWIG_arg_fail(5)) SWIG_fail;
6427 }
6428 }
6429 {
6430 PyThreadState* __tstate = wxPyBeginAllowThreads();
6431 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6432
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 Py_INCREF(Py_None); resultobj = Py_None;
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6444 PyObject *resultobj;
6445 wxRect *arg1 = (wxRect *) 0 ;
6446 PyObject *result;
6447 PyObject * obj0 = 0 ;
6448 char *kwnames[] = {
6449 (char *) "self", NULL
6450 };
6451
6452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6454 if (SWIG_arg_fail(1)) SWIG_fail;
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 result = (PyObject *)wxRect_Get(arg1);
6458
6459 wxPyEndAllowThreads(__tstate);
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 resultobj = result;
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6470 PyObject *obj;
6471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6472 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6473 Py_INCREF(obj);
6474 return Py_BuildValue((char *)"");
6475 }
6476 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 wxRect *arg2 = (wxRect *) 0 ;
6480 PyObject *result;
6481 PyObject * obj0 = 0 ;
6482 PyObject * obj1 = 0 ;
6483 char *kwnames[] = {
6484 (char *) "r1",(char *) "r2", NULL
6485 };
6486
6487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6489 if (SWIG_arg_fail(1)) SWIG_fail;
6490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6491 if (SWIG_arg_fail(2)) SWIG_fail;
6492 {
6493 if (!wxPyCheckForApp()) SWIG_fail;
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 result = (PyObject *)wxIntersectRect(arg1,arg2);
6496
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = result;
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj;
6509 double arg1 = (double) 0.0 ;
6510 double arg2 = (double) 0.0 ;
6511 wxPoint2D *result;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char *kwnames[] = {
6515 (char *) "x",(char *) "y", NULL
6516 };
6517
6518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6519 if (obj0) {
6520 {
6521 arg1 = (double)(SWIG_As_double(obj0));
6522 if (SWIG_arg_fail(1)) SWIG_fail;
6523 }
6524 }
6525 if (obj1) {
6526 {
6527 arg2 = (double)(SWIG_As_double(obj1));
6528 if (SWIG_arg_fail(2)) SWIG_fail;
6529 }
6530 }
6531 {
6532 PyThreadState* __tstate = wxPyBeginAllowThreads();
6533 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6534
6535 wxPyEndAllowThreads(__tstate);
6536 if (PyErr_Occurred()) SWIG_fail;
6537 }
6538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6546 PyObject *resultobj;
6547 wxPoint2D *arg1 = 0 ;
6548 wxPoint2D *result;
6549 wxPoint2D temp1 ;
6550 PyObject * obj0 = 0 ;
6551 char *kwnames[] = {
6552 (char *) "pt", NULL
6553 };
6554
6555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6556 {
6557 arg1 = &temp1;
6558 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6559 }
6560 {
6561 PyThreadState* __tstate = wxPyBeginAllowThreads();
6562 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6563
6564 wxPyEndAllowThreads(__tstate);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6575 PyObject *resultobj;
6576 wxPoint *arg1 = 0 ;
6577 wxPoint2D *result;
6578 wxPoint temp1 ;
6579 PyObject * obj0 = 0 ;
6580 char *kwnames[] = {
6581 (char *) "pt", NULL
6582 };
6583
6584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6585 {
6586 arg1 = &temp1;
6587 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6588 }
6589 {
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6592
6593 wxPyEndAllowThreads(__tstate);
6594 if (PyErr_Occurred()) SWIG_fail;
6595 }
6596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6597 return resultobj;
6598 fail:
6599 return NULL;
6600 }
6601
6602
6603 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6604 PyObject *resultobj;
6605 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6606 int *arg2 = (int *) 0 ;
6607 int *arg3 = (int *) 0 ;
6608 int temp2 ;
6609 int res2 = 0 ;
6610 int temp3 ;
6611 int res3 = 0 ;
6612 PyObject * obj0 = 0 ;
6613 char *kwnames[] = {
6614 (char *) "self", NULL
6615 };
6616
6617 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6618 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6621 if (SWIG_arg_fail(1)) SWIG_fail;
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6625
6626 wxPyEndAllowThreads(__tstate);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 Py_INCREF(Py_None); resultobj = Py_None;
6630 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6631 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6632 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6633 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6634 return resultobj;
6635 fail:
6636 return NULL;
6637 }
6638
6639
6640 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6641 PyObject *resultobj;
6642 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6643 int *arg2 = (int *) 0 ;
6644 int *arg3 = (int *) 0 ;
6645 int temp2 ;
6646 int res2 = 0 ;
6647 int temp3 ;
6648 int res3 = 0 ;
6649 PyObject * obj0 = 0 ;
6650 char *kwnames[] = {
6651 (char *) "self", NULL
6652 };
6653
6654 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6655 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6658 if (SWIG_arg_fail(1)) SWIG_fail;
6659 {
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6662
6663 wxPyEndAllowThreads(__tstate);
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 Py_INCREF(Py_None); resultobj = Py_None;
6667 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6668 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6669 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6670 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6678 PyObject *resultobj;
6679 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6680 double result;
6681 PyObject * obj0 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 {
6697 resultobj = SWIG_From_double((double)(result));
6698 }
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6706 PyObject *resultobj;
6707 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6708 double result;
6709 PyObject * obj0 = 0 ;
6710 char *kwnames[] = {
6711 (char *) "self", NULL
6712 };
6713
6714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6716 if (SWIG_arg_fail(1)) SWIG_fail;
6717 {
6718 PyThreadState* __tstate = wxPyBeginAllowThreads();
6719 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6720
6721 wxPyEndAllowThreads(__tstate);
6722 if (PyErr_Occurred()) SWIG_fail;
6723 }
6724 {
6725 resultobj = SWIG_From_double((double)(result));
6726 }
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6734 PyObject *resultobj;
6735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6736 double arg2 ;
6737 PyObject * obj0 = 0 ;
6738 PyObject * obj1 = 0 ;
6739 char *kwnames[] = {
6740 (char *) "self",(char *) "length", NULL
6741 };
6742
6743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6745 if (SWIG_arg_fail(1)) SWIG_fail;
6746 {
6747 arg2 = (double)(SWIG_As_double(obj1));
6748 if (SWIG_arg_fail(2)) SWIG_fail;
6749 }
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 (arg1)->SetVectorLength(arg2);
6753
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 Py_INCREF(Py_None); resultobj = Py_None;
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6765 PyObject *resultobj;
6766 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6767 double arg2 ;
6768 PyObject * obj0 = 0 ;
6769 PyObject * obj1 = 0 ;
6770 char *kwnames[] = {
6771 (char *) "self",(char *) "degrees", NULL
6772 };
6773
6774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6776 if (SWIG_arg_fail(1)) SWIG_fail;
6777 {
6778 arg2 = (double)(SWIG_As_double(obj1));
6779 if (SWIG_arg_fail(2)) SWIG_fail;
6780 }
6781 {
6782 PyThreadState* __tstate = wxPyBeginAllowThreads();
6783 (arg1)->SetVectorAngle(arg2);
6784
6785 wxPyEndAllowThreads(__tstate);
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 Py_INCREF(Py_None); resultobj = Py_None;
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6796 PyObject *resultobj;
6797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6798 wxPoint2D *arg2 = 0 ;
6799 double result;
6800 wxPoint2D temp2 ;
6801 PyObject * obj0 = 0 ;
6802 PyObject * obj1 = 0 ;
6803 char *kwnames[] = {
6804 (char *) "self",(char *) "pt", NULL
6805 };
6806
6807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6809 if (SWIG_arg_fail(1)) SWIG_fail;
6810 {
6811 arg2 = &temp2;
6812 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6813 }
6814 {
6815 PyThreadState* __tstate = wxPyBeginAllowThreads();
6816 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6817
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 {
6822 resultobj = SWIG_From_double((double)(result));
6823 }
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6831 PyObject *resultobj;
6832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6833 wxPoint2D *arg2 = 0 ;
6834 double result;
6835 wxPoint2D temp2 ;
6836 PyObject * obj0 = 0 ;
6837 PyObject * obj1 = 0 ;
6838 char *kwnames[] = {
6839 (char *) "self",(char *) "pt", NULL
6840 };
6841
6842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6844 if (SWIG_arg_fail(1)) SWIG_fail;
6845 {
6846 arg2 = &temp2;
6847 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6848 }
6849 {
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6852
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 {
6857 resultobj = SWIG_From_double((double)(result));
6858 }
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6866 PyObject *resultobj;
6867 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6868 wxPoint2D *arg2 = 0 ;
6869 double result;
6870 wxPoint2D temp2 ;
6871 PyObject * obj0 = 0 ;
6872 PyObject * obj1 = 0 ;
6873 char *kwnames[] = {
6874 (char *) "self",(char *) "vec", NULL
6875 };
6876
6877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6879 if (SWIG_arg_fail(1)) SWIG_fail;
6880 {
6881 arg2 = &temp2;
6882 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6883 }
6884 {
6885 PyThreadState* __tstate = wxPyBeginAllowThreads();
6886 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6887
6888 wxPyEndAllowThreads(__tstate);
6889 if (PyErr_Occurred()) SWIG_fail;
6890 }
6891 {
6892 resultobj = SWIG_From_double((double)(result));
6893 }
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6901 PyObject *resultobj;
6902 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6903 wxPoint2D *arg2 = 0 ;
6904 double result;
6905 wxPoint2D temp2 ;
6906 PyObject * obj0 = 0 ;
6907 PyObject * obj1 = 0 ;
6908 char *kwnames[] = {
6909 (char *) "self",(char *) "vec", NULL
6910 };
6911
6912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6914 if (SWIG_arg_fail(1)) SWIG_fail;
6915 {
6916 arg2 = &temp2;
6917 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6918 }
6919 {
6920 PyThreadState* __tstate = wxPyBeginAllowThreads();
6921 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6922
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 {
6927 resultobj = SWIG_From_double((double)(result));
6928 }
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6936 PyObject *resultobj;
6937 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6938 wxPoint2D result;
6939 PyObject * obj0 = 0 ;
6940 char *kwnames[] = {
6941 (char *) "self", NULL
6942 };
6943
6944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6946 if (SWIG_arg_fail(1)) SWIG_fail;
6947 {
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (arg1)->operator -();
6950
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 {
6955 wxPoint2D * resultptr;
6956 resultptr = new wxPoint2D((wxPoint2D &)(result));
6957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6958 }
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6966 PyObject *resultobj;
6967 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6968 wxPoint2D *arg2 = 0 ;
6969 wxPoint2D *result;
6970 wxPoint2D temp2 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char *kwnames[] = {
6974 (char *) "self",(char *) "pt", NULL
6975 };
6976
6977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6979 if (SWIG_arg_fail(1)) SWIG_fail;
6980 {
6981 arg2 = &temp2;
6982 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6983 }
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 {
6987 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6988 result = (wxPoint2D *) &_result_ref;
6989 }
6990
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7002 PyObject *resultobj;
7003 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7004 wxPoint2D *arg2 = 0 ;
7005 wxPoint2D *result;
7006 wxPoint2D temp2 ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 char *kwnames[] = {
7010 (char *) "self",(char *) "pt", NULL
7011 };
7012
7013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7015 if (SWIG_arg_fail(1)) SWIG_fail;
7016 {
7017 arg2 = &temp2;
7018 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7019 }
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 {
7023 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7024 result = (wxPoint2D *) &_result_ref;
7025 }
7026
7027 wxPyEndAllowThreads(__tstate);
7028 if (PyErr_Occurred()) SWIG_fail;
7029 }
7030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
7037 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7038 PyObject *resultobj;
7039 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7040 wxPoint2D *arg2 = 0 ;
7041 wxPoint2D *result;
7042 wxPoint2D temp2 ;
7043 PyObject * obj0 = 0 ;
7044 PyObject * obj1 = 0 ;
7045 char *kwnames[] = {
7046 (char *) "self",(char *) "pt", NULL
7047 };
7048
7049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7051 if (SWIG_arg_fail(1)) SWIG_fail;
7052 {
7053 arg2 = &temp2;
7054 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7055 }
7056 {
7057 PyThreadState* __tstate = wxPyBeginAllowThreads();
7058 {
7059 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7060 result = (wxPoint2D *) &_result_ref;
7061 }
7062
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj;
7075 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7076 wxPoint2D *arg2 = 0 ;
7077 wxPoint2D *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___idiv__",kwnames,&obj0,&obj1)) goto fail;
7086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
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 {
7095 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7096 result = (wxPoint2D *) &_result_ref;
7097 }
7098
7099 wxPyEndAllowThreads(__tstate);
7100 if (PyErr_Occurred()) SWIG_fail;
7101 }
7102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7103 return resultobj;
7104 fail:
7105 return NULL;
7106 }
7107
7108
7109 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7110 PyObject *resultobj;
7111 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7112 wxPoint2D *arg2 = 0 ;
7113 bool result;
7114 wxPoint2D temp2 ;
7115 PyObject * obj0 = 0 ;
7116 PyObject * obj1 = 0 ;
7117 char *kwnames[] = {
7118 (char *) "self",(char *) "pt", NULL
7119 };
7120
7121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7123 if (SWIG_arg_fail(1)) SWIG_fail;
7124 {
7125 arg2 = &temp2;
7126 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7127 }
7128 {
7129 PyThreadState* __tstate = wxPyBeginAllowThreads();
7130 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7131
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj;
7146 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7147 wxPoint2D *arg2 = 0 ;
7148 bool result;
7149 wxPoint2D temp2 ;
7150 PyObject * obj0 = 0 ;
7151 PyObject * obj1 = 0 ;
7152 char *kwnames[] = {
7153 (char *) "self",(char *) "pt", NULL
7154 };
7155
7156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7158 if (SWIG_arg_fail(1)) SWIG_fail;
7159 {
7160 arg2 = &temp2;
7161 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7162 }
7163 {
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7166
7167 wxPyEndAllowThreads(__tstate);
7168 if (PyErr_Occurred()) SWIG_fail;
7169 }
7170 {
7171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7172 }
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj;
7181 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7182 double arg2 ;
7183 PyObject * obj0 = 0 ;
7184 PyObject * obj1 = 0 ;
7185 char *kwnames[] = {
7186 (char *) "self",(char *) "m_x", NULL
7187 };
7188
7189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7191 if (SWIG_arg_fail(1)) SWIG_fail;
7192 {
7193 arg2 = (double)(SWIG_As_double(obj1));
7194 if (SWIG_arg_fail(2)) SWIG_fail;
7195 }
7196 if (arg1) (arg1)->m_x = arg2;
7197
7198 Py_INCREF(Py_None); resultobj = Py_None;
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7206 PyObject *resultobj;
7207 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7208 double result;
7209 PyObject * obj0 = 0 ;
7210 char *kwnames[] = {
7211 (char *) "self", NULL
7212 };
7213
7214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7216 if (SWIG_arg_fail(1)) SWIG_fail;
7217 result = (double) ((arg1)->m_x);
7218
7219 {
7220 resultobj = SWIG_From_double((double)(result));
7221 }
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7229 PyObject *resultobj;
7230 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7231 double arg2 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char *kwnames[] = {
7235 (char *) "self",(char *) "m_y", NULL
7236 };
7237
7238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7240 if (SWIG_arg_fail(1)) SWIG_fail;
7241 {
7242 arg2 = (double)(SWIG_As_double(obj1));
7243 if (SWIG_arg_fail(2)) SWIG_fail;
7244 }
7245 if (arg1) (arg1)->m_y = arg2;
7246
7247 Py_INCREF(Py_None); resultobj = Py_None;
7248 return resultobj;
7249 fail:
7250 return NULL;
7251 }
7252
7253
7254 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7255 PyObject *resultobj;
7256 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7257 double result;
7258 PyObject * obj0 = 0 ;
7259 char *kwnames[] = {
7260 (char *) "self", NULL
7261 };
7262
7263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7265 if (SWIG_arg_fail(1)) SWIG_fail;
7266 result = (double) ((arg1)->m_y);
7267
7268 {
7269 resultobj = SWIG_From_double((double)(result));
7270 }
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj;
7279 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7280 double arg2 = (double) 0 ;
7281 double arg3 = (double) 0 ;
7282 PyObject * obj0 = 0 ;
7283 PyObject * obj1 = 0 ;
7284 PyObject * obj2 = 0 ;
7285 char *kwnames[] = {
7286 (char *) "self",(char *) "x",(char *) "y", NULL
7287 };
7288
7289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7291 if (SWIG_arg_fail(1)) SWIG_fail;
7292 if (obj1) {
7293 {
7294 arg2 = (double)(SWIG_As_double(obj1));
7295 if (SWIG_arg_fail(2)) SWIG_fail;
7296 }
7297 }
7298 if (obj2) {
7299 {
7300 arg3 = (double)(SWIG_As_double(obj2));
7301 if (SWIG_arg_fail(3)) SWIG_fail;
7302 }
7303 }
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 wxPoint2D_Set(arg1,arg2,arg3);
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 Py_INCREF(Py_None); resultobj = Py_None;
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7319 PyObject *resultobj;
7320 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7321 PyObject *result;
7322 PyObject * obj0 = 0 ;
7323 char *kwnames[] = {
7324 (char *) "self", NULL
7325 };
7326
7327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7329 if (SWIG_arg_fail(1)) SWIG_fail;
7330 {
7331 PyThreadState* __tstate = wxPyBeginAllowThreads();
7332 result = (PyObject *)wxPoint2D_Get(arg1);
7333
7334 wxPyEndAllowThreads(__tstate);
7335 if (PyErr_Occurred()) SWIG_fail;
7336 }
7337 resultobj = result;
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7345 PyObject *obj;
7346 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7347 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7348 Py_INCREF(obj);
7349 return Py_BuildValue((char *)"");
7350 }
7351 static int _wrap_DefaultPosition_set(PyObject *) {
7352 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7353 return 1;
7354 }
7355
7356
7357 static PyObject *_wrap_DefaultPosition_get(void) {
7358 PyObject *pyobj;
7359
7360 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7361 return pyobj;
7362 }
7363
7364
7365 static int _wrap_DefaultSize_set(PyObject *) {
7366 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7367 return 1;
7368 }
7369
7370
7371 static PyObject *_wrap_DefaultSize_get(void) {
7372 PyObject *pyobj;
7373
7374 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7375 return pyobj;
7376 }
7377
7378
7379 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7380 PyObject *resultobj;
7381 PyObject *arg1 = (PyObject *) 0 ;
7382 wxPyInputStream *result;
7383 PyObject * obj0 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "p", NULL
7386 };
7387
7388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7389 arg1 = obj0;
7390 {
7391 PyThreadState* __tstate = wxPyBeginAllowThreads();
7392 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7393
7394 wxPyEndAllowThreads(__tstate);
7395 if (PyErr_Occurred()) SWIG_fail;
7396 }
7397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7398 return resultobj;
7399 fail:
7400 return NULL;
7401 }
7402
7403
7404 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7405 PyObject *resultobj;
7406 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7407 PyObject * obj0 = 0 ;
7408 char *kwnames[] = {
7409 (char *) "self", NULL
7410 };
7411
7412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7414 if (SWIG_arg_fail(1)) SWIG_fail;
7415 {
7416 PyThreadState* __tstate = wxPyBeginAllowThreads();
7417 delete arg1;
7418
7419 wxPyEndAllowThreads(__tstate);
7420 if (PyErr_Occurred()) SWIG_fail;
7421 }
7422 Py_INCREF(Py_None); resultobj = Py_None;
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj;
7431 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7432 PyObject * obj0 = 0 ;
7433 char *kwnames[] = {
7434 (char *) "self", NULL
7435 };
7436
7437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7439 if (SWIG_arg_fail(1)) SWIG_fail;
7440 {
7441 PyThreadState* __tstate = wxPyBeginAllowThreads();
7442 (arg1)->close();
7443
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 Py_INCREF(Py_None); resultobj = Py_None;
7448 return resultobj;
7449 fail:
7450 return NULL;
7451 }
7452
7453
7454 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7455 PyObject *resultobj;
7456 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 (arg1)->flush();
7468
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 Py_INCREF(Py_None); resultobj = Py_None;
7473 return resultobj;
7474 fail:
7475 return NULL;
7476 }
7477
7478
7479 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7480 PyObject *resultobj;
7481 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7482 bool result;
7483 PyObject * obj0 = 0 ;
7484 char *kwnames[] = {
7485 (char *) "self", NULL
7486 };
7487
7488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7490 if (SWIG_arg_fail(1)) SWIG_fail;
7491 {
7492 PyThreadState* __tstate = wxPyBeginAllowThreads();
7493 result = (bool)(arg1)->eof();
7494
7495 wxPyEndAllowThreads(__tstate);
7496 if (PyErr_Occurred()) SWIG_fail;
7497 }
7498 {
7499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7500 }
7501 return resultobj;
7502 fail:
7503 return NULL;
7504 }
7505
7506
7507 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7508 PyObject *resultobj;
7509 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7510 int arg2 = (int) -1 ;
7511 PyObject *result;
7512 PyObject * obj0 = 0 ;
7513 PyObject * obj1 = 0 ;
7514 char *kwnames[] = {
7515 (char *) "self",(char *) "size", NULL
7516 };
7517
7518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7520 if (SWIG_arg_fail(1)) SWIG_fail;
7521 if (obj1) {
7522 {
7523 arg2 = (int)(SWIG_As_int(obj1));
7524 if (SWIG_arg_fail(2)) SWIG_fail;
7525 }
7526 }
7527 {
7528 PyThreadState* __tstate = wxPyBeginAllowThreads();
7529 result = (PyObject *)(arg1)->read(arg2);
7530
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 resultobj = result;
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7542 PyObject *resultobj;
7543 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7544 int arg2 = (int) -1 ;
7545 PyObject *result;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char *kwnames[] = {
7549 (char *) "self",(char *) "size", NULL
7550 };
7551
7552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7554 if (SWIG_arg_fail(1)) SWIG_fail;
7555 if (obj1) {
7556 {
7557 arg2 = (int)(SWIG_As_int(obj1));
7558 if (SWIG_arg_fail(2)) SWIG_fail;
7559 }
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (PyObject *)(arg1)->readline(arg2);
7564
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 resultobj = result;
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj;
7577 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7578 int arg2 = (int) -1 ;
7579 PyObject *result;
7580 PyObject * obj0 = 0 ;
7581 PyObject * obj1 = 0 ;
7582 char *kwnames[] = {
7583 (char *) "self",(char *) "sizehint", NULL
7584 };
7585
7586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) 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 if (obj1) {
7590 {
7591 arg2 = (int)(SWIG_As_int(obj1));
7592 if (SWIG_arg_fail(2)) SWIG_fail;
7593 }
7594 }
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 result = (PyObject *)(arg1)->readlines(arg2);
7598
7599 wxPyEndAllowThreads(__tstate);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 resultobj = result;
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj;
7611 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7612 int arg2 ;
7613 int arg3 = (int) 0 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 PyObject * obj2 = 0 ;
7617 char *kwnames[] = {
7618 (char *) "self",(char *) "offset",(char *) "whence", NULL
7619 };
7620
7621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7623 if (SWIG_arg_fail(1)) SWIG_fail;
7624 {
7625 arg2 = (int)(SWIG_As_int(obj1));
7626 if (SWIG_arg_fail(2)) SWIG_fail;
7627 }
7628 if (obj2) {
7629 {
7630 arg3 = (int)(SWIG_As_int(obj2));
7631 if (SWIG_arg_fail(3)) SWIG_fail;
7632 }
7633 }
7634 {
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 (arg1)->seek(arg2,arg3);
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 Py_INCREF(Py_None); resultobj = Py_None;
7642 return resultobj;
7643 fail:
7644 return NULL;
7645 }
7646
7647
7648 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7649 PyObject *resultobj;
7650 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7651 int result;
7652 PyObject * obj0 = 0 ;
7653 char *kwnames[] = {
7654 (char *) "self", NULL
7655 };
7656
7657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7659 if (SWIG_arg_fail(1)) SWIG_fail;
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (int)(arg1)->tell();
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 {
7668 resultobj = SWIG_From_int((int)(result));
7669 }
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj;
7678 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7679 char result;
7680 PyObject * obj0 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 result = (char)(arg1)->Peek();
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 resultobj = SWIG_From_char((char)(result));
7697 }
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj;
7706 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7707 char result;
7708 PyObject * obj0 = 0 ;
7709 char *kwnames[] = {
7710 (char *) "self", NULL
7711 };
7712
7713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7715 if (SWIG_arg_fail(1)) SWIG_fail;
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 result = (char)(arg1)->GetC();
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 {
7724 resultobj = SWIG_From_char((char)(result));
7725 }
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7733 PyObject *resultobj;
7734 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7735 size_t result;
7736 PyObject * obj0 = 0 ;
7737 char *kwnames[] = {
7738 (char *) "self", NULL
7739 };
7740
7741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7743 if (SWIG_arg_fail(1)) SWIG_fail;
7744 {
7745 PyThreadState* __tstate = wxPyBeginAllowThreads();
7746 result = (size_t)(arg1)->LastRead();
7747
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 {
7752 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7753 }
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj;
7762 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7763 bool result;
7764 PyObject * obj0 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 PyThreadState* __tstate = wxPyBeginAllowThreads();
7774 result = (bool)(arg1)->CanRead();
7775
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 {
7780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7781 }
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj;
7790 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7791 bool result;
7792 PyObject * obj0 = 0 ;
7793 char *kwnames[] = {
7794 (char *) "self", NULL
7795 };
7796
7797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7799 if (SWIG_arg_fail(1)) SWIG_fail;
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 result = (bool)(arg1)->Eof();
7803
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 {
7808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7809 }
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj;
7818 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7819 char arg2 ;
7820 bool result;
7821 PyObject * obj0 = 0 ;
7822 PyObject * obj1 = 0 ;
7823 char *kwnames[] = {
7824 (char *) "self",(char *) "c", NULL
7825 };
7826
7827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7829 if (SWIG_arg_fail(1)) SWIG_fail;
7830 {
7831 arg2 = (char)(SWIG_As_char(obj1));
7832 if (SWIG_arg_fail(2)) SWIG_fail;
7833 }
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (bool)(arg1)->Ungetch(arg2);
7837
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj;
7852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7853 long arg2 ;
7854 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7855 long result;
7856 PyObject * obj0 = 0 ;
7857 PyObject * obj1 = 0 ;
7858 PyObject * obj2 = 0 ;
7859 char *kwnames[] = {
7860 (char *) "self",(char *) "pos",(char *) "mode", NULL
7861 };
7862
7863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7865 if (SWIG_arg_fail(1)) SWIG_fail;
7866 {
7867 arg2 = (long)(SWIG_As_long(obj1));
7868 if (SWIG_arg_fail(2)) SWIG_fail;
7869 }
7870 if (obj2) {
7871 {
7872 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7873 if (SWIG_arg_fail(3)) SWIG_fail;
7874 }
7875 }
7876 {
7877 PyThreadState* __tstate = wxPyBeginAllowThreads();
7878 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7879
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 {
7884 resultobj = SWIG_From_long((long)(result));
7885 }
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7893 PyObject *resultobj;
7894 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7895 long result;
7896 PyObject * obj0 = 0 ;
7897 char *kwnames[] = {
7898 (char *) "self", NULL
7899 };
7900
7901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7903 if (SWIG_arg_fail(1)) SWIG_fail;
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 result = (long)(arg1)->TellI();
7907
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 {
7912 resultobj = SWIG_From_long((long)(result));
7913 }
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7921 PyObject *obj;
7922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7923 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7924 Py_INCREF(obj);
7925 return Py_BuildValue((char *)"");
7926 }
7927 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7928 PyObject *resultobj;
7929 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7930 PyObject *arg2 = (PyObject *) 0 ;
7931 PyObject * obj0 = 0 ;
7932 PyObject * obj1 = 0 ;
7933 char *kwnames[] = {
7934 (char *) "self",(char *) "obj", NULL
7935 };
7936
7937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7939 if (SWIG_arg_fail(1)) SWIG_fail;
7940 arg2 = obj1;
7941 {
7942 PyThreadState* __tstate = wxPyBeginAllowThreads();
7943 wxOutputStream_write(arg1,arg2);
7944
7945 wxPyEndAllowThreads(__tstate);
7946 if (PyErr_Occurred()) SWIG_fail;
7947 }
7948 Py_INCREF(Py_None); resultobj = Py_None;
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7956 PyObject *obj;
7957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7958 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7959 Py_INCREF(obj);
7960 return Py_BuildValue((char *)"");
7961 }
7962 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7963 PyObject *resultobj;
7964 wxInputStream *arg1 = (wxInputStream *) 0 ;
7965 wxString *arg2 = 0 ;
7966 wxString *arg3 = 0 ;
7967 wxString *arg4 = 0 ;
7968 wxDateTime arg5 ;
7969 wxFSFile *result;
7970 wxPyInputStream *temp1 ;
7971 bool temp2 = false ;
7972 bool temp3 = false ;
7973 bool temp4 = false ;
7974 PyObject * obj0 = 0 ;
7975 PyObject * obj1 = 0 ;
7976 PyObject * obj2 = 0 ;
7977 PyObject * obj3 = 0 ;
7978 PyObject * obj4 = 0 ;
7979 char *kwnames[] = {
7980 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7981 };
7982
7983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7984 {
7985 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7986 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7987 } else {
7988 PyErr_Clear(); // clear the failure of the wxPyConvert above
7989 arg1 = wxPyCBInputStream_create(obj0, true);
7990 if (arg1 == NULL) {
7991 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7992 SWIG_fail;
7993 }
7994 }
7995 }
7996 {
7997 arg2 = wxString_in_helper(obj1);
7998 if (arg2 == NULL) SWIG_fail;
7999 temp2 = true;
8000 }
8001 {
8002 arg3 = wxString_in_helper(obj2);
8003 if (arg3 == NULL) SWIG_fail;
8004 temp3 = true;
8005 }
8006 {
8007 arg4 = wxString_in_helper(obj3);
8008 if (arg4 == NULL) SWIG_fail;
8009 temp4 = true;
8010 }
8011 {
8012 wxDateTime * argp;
8013 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8014 if (SWIG_arg_fail(5)) SWIG_fail;
8015 if (argp == NULL) {
8016 SWIG_null_ref("wxDateTime");
8017 }
8018 if (SWIG_arg_fail(5)) SWIG_fail;
8019 arg5 = *argp;
8020 }
8021 {
8022 PyThreadState* __tstate = wxPyBeginAllowThreads();
8023 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8024
8025 wxPyEndAllowThreads(__tstate);
8026 if (PyErr_Occurred()) SWIG_fail;
8027 }
8028 {
8029 resultobj = wxPyMake_wxObject(result, 1);
8030 }
8031 {
8032 if (temp2)
8033 delete arg2;
8034 }
8035 {
8036 if (temp3)
8037 delete arg3;
8038 }
8039 {
8040 if (temp4)
8041 delete arg4;
8042 }
8043 return resultobj;
8044 fail:
8045 {
8046 if (temp2)
8047 delete arg2;
8048 }
8049 {
8050 if (temp3)
8051 delete arg3;
8052 }
8053 {
8054 if (temp4)
8055 delete arg4;
8056 }
8057 return NULL;
8058 }
8059
8060
8061 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8062 PyObject *resultobj;
8063 wxFSFile *arg1 = (wxFSFile *) 0 ;
8064 PyObject * obj0 = 0 ;
8065 char *kwnames[] = {
8066 (char *) "self", NULL
8067 };
8068
8069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8071 if (SWIG_arg_fail(1)) SWIG_fail;
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 delete arg1;
8075
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 Py_INCREF(Py_None); resultobj = Py_None;
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj;
8088 wxFSFile *arg1 = (wxFSFile *) 0 ;
8089 wxInputStream *result;
8090 PyObject * obj0 = 0 ;
8091 char *kwnames[] = {
8092 (char *) "self", NULL
8093 };
8094
8095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8097 if (SWIG_arg_fail(1)) SWIG_fail;
8098 {
8099 PyThreadState* __tstate = wxPyBeginAllowThreads();
8100 result = (wxInputStream *)(arg1)->GetStream();
8101
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 {
8106 wxPyInputStream * _ptr = NULL;
8107
8108 if (result) {
8109 _ptr = new wxPyInputStream(result);
8110 }
8111 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8112 }
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8120 PyObject *resultobj;
8121 wxFSFile *arg1 = (wxFSFile *) 0 ;
8122 wxString *result;
8123 PyObject * obj0 = 0 ;
8124 char *kwnames[] = {
8125 (char *) "self", NULL
8126 };
8127
8128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8130 if (SWIG_arg_fail(1)) SWIG_fail;
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 {
8134 wxString const &_result_ref = (arg1)->GetMimeType();
8135 result = (wxString *) &_result_ref;
8136 }
8137
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 {
8142 #if wxUSE_UNICODE
8143 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8144 #else
8145 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8146 #endif
8147 }
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj;
8156 wxFSFile *arg1 = (wxFSFile *) 0 ;
8157 wxString *result;
8158 PyObject * obj0 = 0 ;
8159 char *kwnames[] = {
8160 (char *) "self", NULL
8161 };
8162
8163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8165 if (SWIG_arg_fail(1)) SWIG_fail;
8166 {
8167 PyThreadState* __tstate = wxPyBeginAllowThreads();
8168 {
8169 wxString const &_result_ref = (arg1)->GetLocation();
8170 result = (wxString *) &_result_ref;
8171 }
8172
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 {
8177 #if wxUSE_UNICODE
8178 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8179 #else
8180 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8181 #endif
8182 }
8183 return resultobj;
8184 fail:
8185 return NULL;
8186 }
8187
8188
8189 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8190 PyObject *resultobj;
8191 wxFSFile *arg1 = (wxFSFile *) 0 ;
8192 wxString *result;
8193 PyObject * obj0 = 0 ;
8194 char *kwnames[] = {
8195 (char *) "self", NULL
8196 };
8197
8198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8200 if (SWIG_arg_fail(1)) SWIG_fail;
8201 {
8202 PyThreadState* __tstate = wxPyBeginAllowThreads();
8203 {
8204 wxString const &_result_ref = (arg1)->GetAnchor();
8205 result = (wxString *) &_result_ref;
8206 }
8207
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 {
8212 #if wxUSE_UNICODE
8213 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8214 #else
8215 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8216 #endif
8217 }
8218 return resultobj;
8219 fail:
8220 return NULL;
8221 }
8222
8223
8224 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8225 PyObject *resultobj;
8226 wxFSFile *arg1 = (wxFSFile *) 0 ;
8227 wxDateTime result;
8228 PyObject * obj0 = 0 ;
8229 char *kwnames[] = {
8230 (char *) "self", NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(1)) SWIG_fail;
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 result = (arg1)->GetModificationTime();
8239
8240 wxPyEndAllowThreads(__tstate);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 {
8244 wxDateTime * resultptr;
8245 resultptr = new wxDateTime((wxDateTime &)(result));
8246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8247 }
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8255 PyObject *obj;
8256 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8257 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8258 Py_INCREF(obj);
8259 return Py_BuildValue((char *)"");
8260 }
8261 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8262 PyObject *obj;
8263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8264 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8265 Py_INCREF(obj);
8266 return Py_BuildValue((char *)"");
8267 }
8268 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8269 PyObject *resultobj;
8270 wxPyFileSystemHandler *result;
8271 char *kwnames[] = {
8272 NULL
8273 };
8274
8275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8276 {
8277 PyThreadState* __tstate = wxPyBeginAllowThreads();
8278 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8279
8280 wxPyEndAllowThreads(__tstate);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8284 return resultobj;
8285 fail:
8286 return NULL;
8287 }
8288
8289
8290 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj;
8292 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8293 PyObject *arg2 = (PyObject *) 0 ;
8294 PyObject *arg3 = (PyObject *) 0 ;
8295 PyObject * obj0 = 0 ;
8296 PyObject * obj1 = 0 ;
8297 PyObject * obj2 = 0 ;
8298 char *kwnames[] = {
8299 (char *) "self",(char *) "self",(char *) "_class", NULL
8300 };
8301
8302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8304 if (SWIG_arg_fail(1)) SWIG_fail;
8305 arg2 = obj1;
8306 arg3 = obj2;
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 (arg1)->_setCallbackInfo(arg2,arg3);
8310
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 Py_INCREF(Py_None); resultobj = Py_None;
8315 return resultobj;
8316 fail:
8317 return NULL;
8318 }
8319
8320
8321 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj;
8323 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8324 wxString *arg2 = 0 ;
8325 bool result;
8326 bool temp2 = false ;
8327 PyObject * obj0 = 0 ;
8328 PyObject * obj1 = 0 ;
8329 char *kwnames[] = {
8330 (char *) "self",(char *) "location", NULL
8331 };
8332
8333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8335 if (SWIG_arg_fail(1)) SWIG_fail;
8336 {
8337 arg2 = wxString_in_helper(obj1);
8338 if (arg2 == NULL) SWIG_fail;
8339 temp2 = true;
8340 }
8341 {
8342 PyThreadState* __tstate = wxPyBeginAllowThreads();
8343 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8344
8345 wxPyEndAllowThreads(__tstate);
8346 if (PyErr_Occurred()) SWIG_fail;
8347 }
8348 {
8349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8350 }
8351 {
8352 if (temp2)
8353 delete arg2;
8354 }
8355 return resultobj;
8356 fail:
8357 {
8358 if (temp2)
8359 delete arg2;
8360 }
8361 return NULL;
8362 }
8363
8364
8365 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8366 PyObject *resultobj;
8367 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8368 wxFileSystem *arg2 = 0 ;
8369 wxString *arg3 = 0 ;
8370 wxFSFile *result;
8371 bool temp3 = false ;
8372 PyObject * obj0 = 0 ;
8373 PyObject * obj1 = 0 ;
8374 PyObject * obj2 = 0 ;
8375 char *kwnames[] = {
8376 (char *) "self",(char *) "fs",(char *) "location", NULL
8377 };
8378
8379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8381 if (SWIG_arg_fail(1)) SWIG_fail;
8382 {
8383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8384 if (SWIG_arg_fail(2)) SWIG_fail;
8385 if (arg2 == NULL) {
8386 SWIG_null_ref("wxFileSystem");
8387 }
8388 if (SWIG_arg_fail(2)) SWIG_fail;
8389 }
8390 {
8391 arg3 = wxString_in_helper(obj2);
8392 if (arg3 == NULL) SWIG_fail;
8393 temp3 = true;
8394 }
8395 {
8396 PyThreadState* __tstate = wxPyBeginAllowThreads();
8397 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8398
8399 wxPyEndAllowThreads(__tstate);
8400 if (PyErr_Occurred()) SWIG_fail;
8401 }
8402 {
8403 resultobj = wxPyMake_wxObject(result, 1);
8404 }
8405 {
8406 if (temp3)
8407 delete arg3;
8408 }
8409 return resultobj;
8410 fail:
8411 {
8412 if (temp3)
8413 delete arg3;
8414 }
8415 return NULL;
8416 }
8417
8418
8419 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8420 PyObject *resultobj;
8421 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8422 wxString *arg2 = 0 ;
8423 int arg3 = (int) 0 ;
8424 wxString result;
8425 bool temp2 = false ;
8426 PyObject * obj0 = 0 ;
8427 PyObject * obj1 = 0 ;
8428 PyObject * obj2 = 0 ;
8429 char *kwnames[] = {
8430 (char *) "self",(char *) "spec",(char *) "flags", NULL
8431 };
8432
8433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8435 if (SWIG_arg_fail(1)) SWIG_fail;
8436 {
8437 arg2 = wxString_in_helper(obj1);
8438 if (arg2 == NULL) SWIG_fail;
8439 temp2 = true;
8440 }
8441 if (obj2) {
8442 {
8443 arg3 = (int)(SWIG_As_int(obj2));
8444 if (SWIG_arg_fail(3)) SWIG_fail;
8445 }
8446 }
8447 {
8448 PyThreadState* __tstate = wxPyBeginAllowThreads();
8449 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8450
8451 wxPyEndAllowThreads(__tstate);
8452 if (PyErr_Occurred()) SWIG_fail;
8453 }
8454 {
8455 #if wxUSE_UNICODE
8456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8457 #else
8458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8459 #endif
8460 }
8461 {
8462 if (temp2)
8463 delete arg2;
8464 }
8465 return resultobj;
8466 fail:
8467 {
8468 if (temp2)
8469 delete arg2;
8470 }
8471 return NULL;
8472 }
8473
8474
8475 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8476 PyObject *resultobj;
8477 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8478 wxString result;
8479 PyObject * obj0 = 0 ;
8480 char *kwnames[] = {
8481 (char *) "self", NULL
8482 };
8483
8484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8486 if (SWIG_arg_fail(1)) SWIG_fail;
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (arg1)->FindNext();
8490
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 {
8495 #if wxUSE_UNICODE
8496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8497 #else
8498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8499 #endif
8500 }
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8508 PyObject *resultobj;
8509 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8510 wxString *arg2 = 0 ;
8511 wxString result;
8512 bool temp2 = false ;
8513 PyObject * obj0 = 0 ;
8514 PyObject * obj1 = 0 ;
8515 char *kwnames[] = {
8516 (char *) "self",(char *) "location", NULL
8517 };
8518
8519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8521 if (SWIG_arg_fail(1)) SWIG_fail;
8522 {
8523 arg2 = wxString_in_helper(obj1);
8524 if (arg2 == NULL) SWIG_fail;
8525 temp2 = true;
8526 }
8527 {
8528 PyThreadState* __tstate = wxPyBeginAllowThreads();
8529 result = (arg1)->GetProtocol((wxString const &)*arg2);
8530
8531 wxPyEndAllowThreads(__tstate);
8532 if (PyErr_Occurred()) SWIG_fail;
8533 }
8534 {
8535 #if wxUSE_UNICODE
8536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8537 #else
8538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8539 #endif
8540 }
8541 {
8542 if (temp2)
8543 delete arg2;
8544 }
8545 return resultobj;
8546 fail:
8547 {
8548 if (temp2)
8549 delete arg2;
8550 }
8551 return NULL;
8552 }
8553
8554
8555 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj;
8557 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8558 wxString *arg2 = 0 ;
8559 wxString result;
8560 bool temp2 = false ;
8561 PyObject * obj0 = 0 ;
8562 PyObject * obj1 = 0 ;
8563 char *kwnames[] = {
8564 (char *) "self",(char *) "location", NULL
8565 };
8566
8567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8569 if (SWIG_arg_fail(1)) SWIG_fail;
8570 {
8571 arg2 = wxString_in_helper(obj1);
8572 if (arg2 == NULL) SWIG_fail;
8573 temp2 = true;
8574 }
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8578
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 {
8583 #if wxUSE_UNICODE
8584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8585 #else
8586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8587 #endif
8588 }
8589 {
8590 if (temp2)
8591 delete arg2;
8592 }
8593 return resultobj;
8594 fail:
8595 {
8596 if (temp2)
8597 delete arg2;
8598 }
8599 return NULL;
8600 }
8601
8602
8603 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8604 PyObject *resultobj;
8605 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8606 wxString *arg2 = 0 ;
8607 wxString result;
8608 bool temp2 = false ;
8609 PyObject * obj0 = 0 ;
8610 PyObject * obj1 = 0 ;
8611 char *kwnames[] = {
8612 (char *) "self",(char *) "location", NULL
8613 };
8614
8615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8617 if (SWIG_arg_fail(1)) SWIG_fail;
8618 {
8619 arg2 = wxString_in_helper(obj1);
8620 if (arg2 == NULL) SWIG_fail;
8621 temp2 = true;
8622 }
8623 {
8624 PyThreadState* __tstate = wxPyBeginAllowThreads();
8625 result = (arg1)->GetAnchor((wxString const &)*arg2);
8626
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 {
8631 #if wxUSE_UNICODE
8632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8633 #else
8634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8635 #endif
8636 }
8637 {
8638 if (temp2)
8639 delete arg2;
8640 }
8641 return resultobj;
8642 fail:
8643 {
8644 if (temp2)
8645 delete arg2;
8646 }
8647 return NULL;
8648 }
8649
8650
8651 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj;
8653 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8654 wxString *arg2 = 0 ;
8655 wxString result;
8656 bool temp2 = false ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char *kwnames[] = {
8660 (char *) "self",(char *) "location", NULL
8661 };
8662
8663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8665 if (SWIG_arg_fail(1)) SWIG_fail;
8666 {
8667 arg2 = wxString_in_helper(obj1);
8668 if (arg2 == NULL) SWIG_fail;
8669 temp2 = true;
8670 }
8671 {
8672 PyThreadState* __tstate = wxPyBeginAllowThreads();
8673 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8674
8675 wxPyEndAllowThreads(__tstate);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 {
8679 #if wxUSE_UNICODE
8680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8681 #else
8682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8683 #endif
8684 }
8685 {
8686 if (temp2)
8687 delete arg2;
8688 }
8689 return resultobj;
8690 fail:
8691 {
8692 if (temp2)
8693 delete arg2;
8694 }
8695 return NULL;
8696 }
8697
8698
8699 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8700 PyObject *resultobj;
8701 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8702 wxString *arg2 = 0 ;
8703 wxString result;
8704 bool temp2 = false ;
8705 PyObject * obj0 = 0 ;
8706 PyObject * obj1 = 0 ;
8707 char *kwnames[] = {
8708 (char *) "self",(char *) "location", NULL
8709 };
8710
8711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8713 if (SWIG_arg_fail(1)) SWIG_fail;
8714 {
8715 arg2 = wxString_in_helper(obj1);
8716 if (arg2 == NULL) SWIG_fail;
8717 temp2 = true;
8718 }
8719 {
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8722
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 {
8727 #if wxUSE_UNICODE
8728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8729 #else
8730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8731 #endif
8732 }
8733 {
8734 if (temp2)
8735 delete arg2;
8736 }
8737 return resultobj;
8738 fail:
8739 {
8740 if (temp2)
8741 delete arg2;
8742 }
8743 return NULL;
8744 }
8745
8746
8747 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8748 PyObject *obj;
8749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8750 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8751 Py_INCREF(obj);
8752 return Py_BuildValue((char *)"");
8753 }
8754 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj;
8756 wxFileSystem *result;
8757 char *kwnames[] = {
8758 NULL
8759 };
8760
8761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8762 {
8763 PyThreadState* __tstate = wxPyBeginAllowThreads();
8764 result = (wxFileSystem *)new wxFileSystem();
8765
8766 wxPyEndAllowThreads(__tstate);
8767 if (PyErr_Occurred()) SWIG_fail;
8768 }
8769 {
8770 resultobj = wxPyMake_wxObject(result, 1);
8771 }
8772 return resultobj;
8773 fail:
8774 return NULL;
8775 }
8776
8777
8778 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8779 PyObject *resultobj;
8780 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8781 PyObject * obj0 = 0 ;
8782 char *kwnames[] = {
8783 (char *) "self", NULL
8784 };
8785
8786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8788 if (SWIG_arg_fail(1)) SWIG_fail;
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 delete arg1;
8792
8793 wxPyEndAllowThreads(__tstate);
8794 if (PyErr_Occurred()) SWIG_fail;
8795 }
8796 Py_INCREF(Py_None); resultobj = Py_None;
8797 return resultobj;
8798 fail:
8799 return NULL;
8800 }
8801
8802
8803 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8804 PyObject *resultobj;
8805 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8806 wxString *arg2 = 0 ;
8807 bool arg3 = (bool) false ;
8808 bool temp2 = false ;
8809 PyObject * obj0 = 0 ;
8810 PyObject * obj1 = 0 ;
8811 PyObject * obj2 = 0 ;
8812 char *kwnames[] = {
8813 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8814 };
8815
8816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8818 if (SWIG_arg_fail(1)) SWIG_fail;
8819 {
8820 arg2 = wxString_in_helper(obj1);
8821 if (arg2 == NULL) SWIG_fail;
8822 temp2 = true;
8823 }
8824 if (obj2) {
8825 {
8826 arg3 = (bool)(SWIG_As_bool(obj2));
8827 if (SWIG_arg_fail(3)) SWIG_fail;
8828 }
8829 }
8830 {
8831 PyThreadState* __tstate = wxPyBeginAllowThreads();
8832 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8833
8834 wxPyEndAllowThreads(__tstate);
8835 if (PyErr_Occurred()) SWIG_fail;
8836 }
8837 Py_INCREF(Py_None); resultobj = Py_None;
8838 {
8839 if (temp2)
8840 delete arg2;
8841 }
8842 return resultobj;
8843 fail:
8844 {
8845 if (temp2)
8846 delete arg2;
8847 }
8848 return NULL;
8849 }
8850
8851
8852 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8853 PyObject *resultobj;
8854 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8855 wxString result;
8856 PyObject * obj0 = 0 ;
8857 char *kwnames[] = {
8858 (char *) "self", NULL
8859 };
8860
8861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8863 if (SWIG_arg_fail(1)) SWIG_fail;
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 result = (arg1)->GetPath();
8867
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 {
8872 #if wxUSE_UNICODE
8873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8874 #else
8875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8876 #endif
8877 }
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj;
8886 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8887 wxString *arg2 = 0 ;
8888 wxFSFile *result;
8889 bool temp2 = false ;
8890 PyObject * obj0 = 0 ;
8891 PyObject * obj1 = 0 ;
8892 char *kwnames[] = {
8893 (char *) "self",(char *) "location", NULL
8894 };
8895
8896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8898 if (SWIG_arg_fail(1)) SWIG_fail;
8899 {
8900 arg2 = wxString_in_helper(obj1);
8901 if (arg2 == NULL) SWIG_fail;
8902 temp2 = true;
8903 }
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8907
8908 wxPyEndAllowThreads(__tstate);
8909 if (PyErr_Occurred()) SWIG_fail;
8910 }
8911 {
8912 resultobj = wxPyMake_wxObject(result, 1);
8913 }
8914 {
8915 if (temp2)
8916 delete arg2;
8917 }
8918 return resultobj;
8919 fail:
8920 {
8921 if (temp2)
8922 delete arg2;
8923 }
8924 return NULL;
8925 }
8926
8927
8928 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj;
8930 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8931 wxString *arg2 = 0 ;
8932 int arg3 = (int) 0 ;
8933 wxString result;
8934 bool temp2 = false ;
8935 PyObject * obj0 = 0 ;
8936 PyObject * obj1 = 0 ;
8937 PyObject * obj2 = 0 ;
8938 char *kwnames[] = {
8939 (char *) "self",(char *) "spec",(char *) "flags", NULL
8940 };
8941
8942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8944 if (SWIG_arg_fail(1)) SWIG_fail;
8945 {
8946 arg2 = wxString_in_helper(obj1);
8947 if (arg2 == NULL) SWIG_fail;
8948 temp2 = true;
8949 }
8950 if (obj2) {
8951 {
8952 arg3 = (int)(SWIG_As_int(obj2));
8953 if (SWIG_arg_fail(3)) SWIG_fail;
8954 }
8955 }
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8959
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 {
8964 #if wxUSE_UNICODE
8965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8966 #else
8967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8968 #endif
8969 }
8970 {
8971 if (temp2)
8972 delete arg2;
8973 }
8974 return resultobj;
8975 fail:
8976 {
8977 if (temp2)
8978 delete arg2;
8979 }
8980 return NULL;
8981 }
8982
8983
8984 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8985 PyObject *resultobj;
8986 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8987 wxString result;
8988 PyObject * obj0 = 0 ;
8989 char *kwnames[] = {
8990 (char *) "self", NULL
8991 };
8992
8993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8995 if (SWIG_arg_fail(1)) SWIG_fail;
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 result = (arg1)->FindNext();
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 {
9004 #if wxUSE_UNICODE
9005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9006 #else
9007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9008 #endif
9009 }
9010 return resultobj;
9011 fail:
9012 return NULL;
9013 }
9014
9015
9016 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9017 PyObject *resultobj;
9018 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9019 PyObject * obj0 = 0 ;
9020 char *kwnames[] = {
9021 (char *) "handler", NULL
9022 };
9023
9024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9026 if (SWIG_arg_fail(1)) SWIG_fail;
9027 {
9028 PyThreadState* __tstate = wxPyBeginAllowThreads();
9029 wxFileSystem::AddHandler(arg1);
9030
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 Py_INCREF(Py_None); resultobj = Py_None;
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj;
9043 char *kwnames[] = {
9044 NULL
9045 };
9046
9047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9048 {
9049 PyThreadState* __tstate = wxPyBeginAllowThreads();
9050 wxFileSystem::CleanUpHandlers();
9051
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 Py_INCREF(Py_None); resultobj = Py_None;
9056 return resultobj;
9057 fail:
9058 return NULL;
9059 }
9060
9061
9062 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj;
9064 wxString *arg1 = 0 ;
9065 wxString result;
9066 bool temp1 = false ;
9067 PyObject * obj0 = 0 ;
9068 char *kwnames[] = {
9069 (char *) "filename", NULL
9070 };
9071
9072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9073 {
9074 arg1 = wxString_in_helper(obj0);
9075 if (arg1 == NULL) SWIG_fail;
9076 temp1 = true;
9077 }
9078 {
9079 PyThreadState* __tstate = wxPyBeginAllowThreads();
9080 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9081
9082 wxPyEndAllowThreads(__tstate);
9083 if (PyErr_Occurred()) SWIG_fail;
9084 }
9085 {
9086 #if wxUSE_UNICODE
9087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9088 #else
9089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9090 #endif
9091 }
9092 {
9093 if (temp1)
9094 delete arg1;
9095 }
9096 return resultobj;
9097 fail:
9098 {
9099 if (temp1)
9100 delete arg1;
9101 }
9102 return NULL;
9103 }
9104
9105
9106 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9107 PyObject *resultobj;
9108 wxString *arg1 = 0 ;
9109 wxString result;
9110 bool temp1 = false ;
9111 PyObject * obj0 = 0 ;
9112 char *kwnames[] = {
9113 (char *) "url", NULL
9114 };
9115
9116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9117 {
9118 arg1 = wxString_in_helper(obj0);
9119 if (arg1 == NULL) SWIG_fail;
9120 temp1 = true;
9121 }
9122 {
9123 PyThreadState* __tstate = wxPyBeginAllowThreads();
9124 result = FileSystem_URLToFileName((wxString const &)*arg1);
9125
9126 wxPyEndAllowThreads(__tstate);
9127 if (PyErr_Occurred()) SWIG_fail;
9128 }
9129 {
9130 #if wxUSE_UNICODE
9131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9132 #else
9133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9134 #endif
9135 }
9136 {
9137 if (temp1)
9138 delete arg1;
9139 }
9140 return resultobj;
9141 fail:
9142 {
9143 if (temp1)
9144 delete arg1;
9145 }
9146 return NULL;
9147 }
9148
9149
9150 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9151 PyObject *obj;
9152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9153 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9154 Py_INCREF(obj);
9155 return Py_BuildValue((char *)"");
9156 }
9157 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj;
9159 wxInternetFSHandler *result;
9160 char *kwnames[] = {
9161 NULL
9162 };
9163
9164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9165 {
9166 PyThreadState* __tstate = wxPyBeginAllowThreads();
9167 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9168
9169 wxPyEndAllowThreads(__tstate);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9180 PyObject *resultobj;
9181 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9182 wxString *arg2 = 0 ;
9183 bool result;
9184 bool temp2 = false ;
9185 PyObject * obj0 = 0 ;
9186 PyObject * obj1 = 0 ;
9187 char *kwnames[] = {
9188 (char *) "self",(char *) "location", NULL
9189 };
9190
9191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9193 if (SWIG_arg_fail(1)) SWIG_fail;
9194 {
9195 arg2 = wxString_in_helper(obj1);
9196 if (arg2 == NULL) SWIG_fail;
9197 temp2 = true;
9198 }
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9202
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 {
9207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9208 }
9209 {
9210 if (temp2)
9211 delete arg2;
9212 }
9213 return resultobj;
9214 fail:
9215 {
9216 if (temp2)
9217 delete arg2;
9218 }
9219 return NULL;
9220 }
9221
9222
9223 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9224 PyObject *resultobj;
9225 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9226 wxFileSystem *arg2 = 0 ;
9227 wxString *arg3 = 0 ;
9228 wxFSFile *result;
9229 bool temp3 = false ;
9230 PyObject * obj0 = 0 ;
9231 PyObject * obj1 = 0 ;
9232 PyObject * obj2 = 0 ;
9233 char *kwnames[] = {
9234 (char *) "self",(char *) "fs",(char *) "location", NULL
9235 };
9236
9237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9239 if (SWIG_arg_fail(1)) SWIG_fail;
9240 {
9241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9242 if (SWIG_arg_fail(2)) SWIG_fail;
9243 if (arg2 == NULL) {
9244 SWIG_null_ref("wxFileSystem");
9245 }
9246 if (SWIG_arg_fail(2)) SWIG_fail;
9247 }
9248 {
9249 arg3 = wxString_in_helper(obj2);
9250 if (arg3 == NULL) SWIG_fail;
9251 temp3 = true;
9252 }
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 {
9261 resultobj = wxPyMake_wxObject(result, 1);
9262 }
9263 {
9264 if (temp3)
9265 delete arg3;
9266 }
9267 return resultobj;
9268 fail:
9269 {
9270 if (temp3)
9271 delete arg3;
9272 }
9273 return NULL;
9274 }
9275
9276
9277 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9278 PyObject *obj;
9279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9280 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9281 Py_INCREF(obj);
9282 return Py_BuildValue((char *)"");
9283 }
9284 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj;
9286 wxZipFSHandler *result;
9287 char *kwnames[] = {
9288 NULL
9289 };
9290
9291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9292 {
9293 PyThreadState* __tstate = wxPyBeginAllowThreads();
9294 result = (wxZipFSHandler *)new wxZipFSHandler();
9295
9296 wxPyEndAllowThreads(__tstate);
9297 if (PyErr_Occurred()) SWIG_fail;
9298 }
9299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9300 return resultobj;
9301 fail:
9302 return NULL;
9303 }
9304
9305
9306 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj;
9308 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9309 wxString *arg2 = 0 ;
9310 bool result;
9311 bool temp2 = false ;
9312 PyObject * obj0 = 0 ;
9313 PyObject * obj1 = 0 ;
9314 char *kwnames[] = {
9315 (char *) "self",(char *) "location", NULL
9316 };
9317
9318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9320 if (SWIG_arg_fail(1)) SWIG_fail;
9321 {
9322 arg2 = wxString_in_helper(obj1);
9323 if (arg2 == NULL) SWIG_fail;
9324 temp2 = true;
9325 }
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9329
9330 wxPyEndAllowThreads(__tstate);
9331 if (PyErr_Occurred()) SWIG_fail;
9332 }
9333 {
9334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9335 }
9336 {
9337 if (temp2)
9338 delete arg2;
9339 }
9340 return resultobj;
9341 fail:
9342 {
9343 if (temp2)
9344 delete arg2;
9345 }
9346 return NULL;
9347 }
9348
9349
9350 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9351 PyObject *resultobj;
9352 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9353 wxFileSystem *arg2 = 0 ;
9354 wxString *arg3 = 0 ;
9355 wxFSFile *result;
9356 bool temp3 = false ;
9357 PyObject * obj0 = 0 ;
9358 PyObject * obj1 = 0 ;
9359 PyObject * obj2 = 0 ;
9360 char *kwnames[] = {
9361 (char *) "self",(char *) "fs",(char *) "location", NULL
9362 };
9363
9364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9366 if (SWIG_arg_fail(1)) SWIG_fail;
9367 {
9368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9369 if (SWIG_arg_fail(2)) SWIG_fail;
9370 if (arg2 == NULL) {
9371 SWIG_null_ref("wxFileSystem");
9372 }
9373 if (SWIG_arg_fail(2)) SWIG_fail;
9374 }
9375 {
9376 arg3 = wxString_in_helper(obj2);
9377 if (arg3 == NULL) SWIG_fail;
9378 temp3 = true;
9379 }
9380 {
9381 PyThreadState* __tstate = wxPyBeginAllowThreads();
9382 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9383
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = wxPyMake_wxObject(result, 1);
9389 }
9390 {
9391 if (temp3)
9392 delete arg3;
9393 }
9394 return resultobj;
9395 fail:
9396 {
9397 if (temp3)
9398 delete arg3;
9399 }
9400 return NULL;
9401 }
9402
9403
9404 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj;
9406 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9407 wxString *arg2 = 0 ;
9408 int arg3 = (int) 0 ;
9409 wxString result;
9410 bool temp2 = false ;
9411 PyObject * obj0 = 0 ;
9412 PyObject * obj1 = 0 ;
9413 PyObject * obj2 = 0 ;
9414 char *kwnames[] = {
9415 (char *) "self",(char *) "spec",(char *) "flags", NULL
9416 };
9417
9418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9420 if (SWIG_arg_fail(1)) SWIG_fail;
9421 {
9422 arg2 = wxString_in_helper(obj1);
9423 if (arg2 == NULL) SWIG_fail;
9424 temp2 = true;
9425 }
9426 if (obj2) {
9427 {
9428 arg3 = (int)(SWIG_As_int(obj2));
9429 if (SWIG_arg_fail(3)) SWIG_fail;
9430 }
9431 }
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9435
9436 wxPyEndAllowThreads(__tstate);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 {
9440 #if wxUSE_UNICODE
9441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9442 #else
9443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9444 #endif
9445 }
9446 {
9447 if (temp2)
9448 delete arg2;
9449 }
9450 return resultobj;
9451 fail:
9452 {
9453 if (temp2)
9454 delete arg2;
9455 }
9456 return NULL;
9457 }
9458
9459
9460 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9461 PyObject *resultobj;
9462 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9463 wxString result;
9464 PyObject * obj0 = 0 ;
9465 char *kwnames[] = {
9466 (char *) "self", NULL
9467 };
9468
9469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9471 if (SWIG_arg_fail(1)) SWIG_fail;
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (arg1)->FindNext();
9475
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 #if wxUSE_UNICODE
9481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9482 #else
9483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9484 #endif
9485 }
9486 return resultobj;
9487 fail:
9488 return NULL;
9489 }
9490
9491
9492 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9493 PyObject *obj;
9494 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9495 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9496 Py_INCREF(obj);
9497 return Py_BuildValue((char *)"");
9498 }
9499 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9500 PyObject *resultobj;
9501 wxString *arg1 = 0 ;
9502 wxImage *arg2 = 0 ;
9503 long arg3 ;
9504 bool temp1 = false ;
9505 PyObject * obj0 = 0 ;
9506 PyObject * obj1 = 0 ;
9507 PyObject * obj2 = 0 ;
9508 char *kwnames[] = {
9509 (char *) "filename",(char *) "image",(char *) "type", NULL
9510 };
9511
9512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9513 {
9514 arg1 = wxString_in_helper(obj0);
9515 if (arg1 == NULL) SWIG_fail;
9516 temp1 = true;
9517 }
9518 {
9519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9520 if (SWIG_arg_fail(2)) SWIG_fail;
9521 if (arg2 == NULL) {
9522 SWIG_null_ref("wxImage");
9523 }
9524 if (SWIG_arg_fail(2)) SWIG_fail;
9525 }
9526 {
9527 arg3 = (long)(SWIG_As_long(obj2));
9528 if (SWIG_arg_fail(3)) SWIG_fail;
9529 }
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9533
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 Py_INCREF(Py_None); resultobj = Py_None;
9538 {
9539 if (temp1)
9540 delete arg1;
9541 }
9542 return resultobj;
9543 fail:
9544 {
9545 if (temp1)
9546 delete arg1;
9547 }
9548 return NULL;
9549 }
9550
9551
9552 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9553 PyObject *resultobj;
9554 wxString *arg1 = 0 ;
9555 wxBitmap *arg2 = 0 ;
9556 long arg3 ;
9557 bool temp1 = false ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 PyObject * obj2 = 0 ;
9561 char *kwnames[] = {
9562 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9563 };
9564
9565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9566 {
9567 arg1 = wxString_in_helper(obj0);
9568 if (arg1 == NULL) SWIG_fail;
9569 temp1 = true;
9570 }
9571 {
9572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9573 if (SWIG_arg_fail(2)) SWIG_fail;
9574 if (arg2 == NULL) {
9575 SWIG_null_ref("wxBitmap");
9576 }
9577 if (SWIG_arg_fail(2)) SWIG_fail;
9578 }
9579 {
9580 arg3 = (long)(SWIG_As_long(obj2));
9581 if (SWIG_arg_fail(3)) SWIG_fail;
9582 }
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9586
9587 wxPyEndAllowThreads(__tstate);
9588 if (PyErr_Occurred()) SWIG_fail;
9589 }
9590 Py_INCREF(Py_None); resultobj = Py_None;
9591 {
9592 if (temp1)
9593 delete arg1;
9594 }
9595 return resultobj;
9596 fail:
9597 {
9598 if (temp1)
9599 delete arg1;
9600 }
9601 return NULL;
9602 }
9603
9604
9605 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9606 PyObject *resultobj;
9607 wxString *arg1 = 0 ;
9608 PyObject *arg2 = (PyObject *) 0 ;
9609 bool temp1 = false ;
9610 PyObject * obj0 = 0 ;
9611 PyObject * obj1 = 0 ;
9612 char *kwnames[] = {
9613 (char *) "filename",(char *) "data", NULL
9614 };
9615
9616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9617 {
9618 arg1 = wxString_in_helper(obj0);
9619 if (arg1 == NULL) SWIG_fail;
9620 temp1 = true;
9621 }
9622 arg2 = obj1;
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9626
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 Py_INCREF(Py_None); resultobj = Py_None;
9631 {
9632 if (temp1)
9633 delete arg1;
9634 }
9635 return resultobj;
9636 fail:
9637 {
9638 if (temp1)
9639 delete arg1;
9640 }
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxMemoryFSHandler *result;
9648 char *kwnames[] = {
9649 NULL
9650 };
9651
9652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9656
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9668 PyObject *resultobj;
9669 wxString *arg1 = 0 ;
9670 bool temp1 = false ;
9671 PyObject * obj0 = 0 ;
9672 char *kwnames[] = {
9673 (char *) "filename", NULL
9674 };
9675
9676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9677 {
9678 arg1 = wxString_in_helper(obj0);
9679 if (arg1 == NULL) SWIG_fail;
9680 temp1 = true;
9681 }
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9685
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 Py_INCREF(Py_None); resultobj = Py_None;
9690 {
9691 if (temp1)
9692 delete arg1;
9693 }
9694 return resultobj;
9695 fail:
9696 {
9697 if (temp1)
9698 delete arg1;
9699 }
9700 return NULL;
9701 }
9702
9703
9704 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj;
9706 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9707 wxString *arg2 = 0 ;
9708 bool result;
9709 bool temp2 = false ;
9710 PyObject * obj0 = 0 ;
9711 PyObject * obj1 = 0 ;
9712 char *kwnames[] = {
9713 (char *) "self",(char *) "location", NULL
9714 };
9715
9716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9718 if (SWIG_arg_fail(1)) SWIG_fail;
9719 {
9720 arg2 = wxString_in_helper(obj1);
9721 if (arg2 == NULL) SWIG_fail;
9722 temp2 = true;
9723 }
9724 {
9725 PyThreadState* __tstate = wxPyBeginAllowThreads();
9726 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9727
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 {
9732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9733 }
9734 {
9735 if (temp2)
9736 delete arg2;
9737 }
9738 return resultobj;
9739 fail:
9740 {
9741 if (temp2)
9742 delete arg2;
9743 }
9744 return NULL;
9745 }
9746
9747
9748 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9749 PyObject *resultobj;
9750 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9751 wxFileSystem *arg2 = 0 ;
9752 wxString *arg3 = 0 ;
9753 wxFSFile *result;
9754 bool temp3 = false ;
9755 PyObject * obj0 = 0 ;
9756 PyObject * obj1 = 0 ;
9757 PyObject * obj2 = 0 ;
9758 char *kwnames[] = {
9759 (char *) "self",(char *) "fs",(char *) "location", NULL
9760 };
9761
9762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9764 if (SWIG_arg_fail(1)) SWIG_fail;
9765 {
9766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9767 if (SWIG_arg_fail(2)) SWIG_fail;
9768 if (arg2 == NULL) {
9769 SWIG_null_ref("wxFileSystem");
9770 }
9771 if (SWIG_arg_fail(2)) SWIG_fail;
9772 }
9773 {
9774 arg3 = wxString_in_helper(obj2);
9775 if (arg3 == NULL) SWIG_fail;
9776 temp3 = true;
9777 }
9778 {
9779 PyThreadState* __tstate = wxPyBeginAllowThreads();
9780 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9781
9782 wxPyEndAllowThreads(__tstate);
9783 if (PyErr_Occurred()) SWIG_fail;
9784 }
9785 {
9786 resultobj = wxPyMake_wxObject(result, 1);
9787 }
9788 {
9789 if (temp3)
9790 delete arg3;
9791 }
9792 return resultobj;
9793 fail:
9794 {
9795 if (temp3)
9796 delete arg3;
9797 }
9798 return NULL;
9799 }
9800
9801
9802 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9803 PyObject *resultobj;
9804 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9805 wxString *arg2 = 0 ;
9806 int arg3 = (int) 0 ;
9807 wxString result;
9808 bool temp2 = false ;
9809 PyObject * obj0 = 0 ;
9810 PyObject * obj1 = 0 ;
9811 PyObject * obj2 = 0 ;
9812 char *kwnames[] = {
9813 (char *) "self",(char *) "spec",(char *) "flags", NULL
9814 };
9815
9816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9818 if (SWIG_arg_fail(1)) SWIG_fail;
9819 {
9820 arg2 = wxString_in_helper(obj1);
9821 if (arg2 == NULL) SWIG_fail;
9822 temp2 = true;
9823 }
9824 if (obj2) {
9825 {
9826 arg3 = (int)(SWIG_As_int(obj2));
9827 if (SWIG_arg_fail(3)) SWIG_fail;
9828 }
9829 }
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9833
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 {
9838 #if wxUSE_UNICODE
9839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9840 #else
9841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9842 #endif
9843 }
9844 {
9845 if (temp2)
9846 delete arg2;
9847 }
9848 return resultobj;
9849 fail:
9850 {
9851 if (temp2)
9852 delete arg2;
9853 }
9854 return NULL;
9855 }
9856
9857
9858 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj;
9860 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9861 wxString result;
9862 PyObject * obj0 = 0 ;
9863 char *kwnames[] = {
9864 (char *) "self", NULL
9865 };
9866
9867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9869 if (SWIG_arg_fail(1)) SWIG_fail;
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (arg1)->FindNext();
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 {
9878 #if wxUSE_UNICODE
9879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9880 #else
9881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9882 #endif
9883 }
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9891 PyObject *obj;
9892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9893 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9894 Py_INCREF(obj);
9895 return Py_BuildValue((char *)"");
9896 }
9897 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj;
9899 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9900 wxString result;
9901 PyObject * obj0 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = (arg1)->GetName();
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_ImageHandler_GetExtension(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_GetExtension",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)->GetExtension();
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_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9964 long result;
9965 PyObject * obj0 = 0 ;
9966 char *kwnames[] = {
9967 (char *) "self", NULL
9968 };
9969
9970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9972 if (SWIG_arg_fail(1)) SWIG_fail;
9973 {
9974 PyThreadState* __tstate = wxPyBeginAllowThreads();
9975 result = (long)(arg1)->GetType();
9976
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 {
9981 resultobj = SWIG_From_long((long)(result));
9982 }
9983 return resultobj;
9984 fail:
9985 return NULL;
9986 }
9987
9988
9989 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9990 PyObject *resultobj;
9991 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9992 wxString result;
9993 PyObject * obj0 = 0 ;
9994 char *kwnames[] = {
9995 (char *) "self", NULL
9996 };
9997
9998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10000 if (SWIG_arg_fail(1)) SWIG_fail;
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = (arg1)->GetMimeType();
10004
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 {
10009 #if wxUSE_UNICODE
10010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10011 #else
10012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10013 #endif
10014 }
10015 return resultobj;
10016 fail:
10017 return NULL;
10018 }
10019
10020
10021 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj;
10023 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10024 wxString *arg2 = 0 ;
10025 bool result;
10026 bool temp2 = false ;
10027 PyObject * obj0 = 0 ;
10028 PyObject * obj1 = 0 ;
10029 char *kwnames[] = {
10030 (char *) "self",(char *) "name", NULL
10031 };
10032
10033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10035 if (SWIG_arg_fail(1)) SWIG_fail;
10036 {
10037 arg2 = wxString_in_helper(obj1);
10038 if (arg2 == NULL) SWIG_fail;
10039 temp2 = true;
10040 }
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 {
10049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10050 }
10051 {
10052 if (temp2)
10053 delete arg2;
10054 }
10055 return resultobj;
10056 fail:
10057 {
10058 if (temp2)
10059 delete arg2;
10060 }
10061 return NULL;
10062 }
10063
10064
10065 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10066 PyObject *resultobj;
10067 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10068 wxString *arg2 = 0 ;
10069 bool temp2 = false ;
10070 PyObject * obj0 = 0 ;
10071 PyObject * obj1 = 0 ;
10072 char *kwnames[] = {
10073 (char *) "self",(char *) "name", NULL
10074 };
10075
10076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10078 if (SWIG_arg_fail(1)) SWIG_fail;
10079 {
10080 arg2 = wxString_in_helper(obj1);
10081 if (arg2 == NULL) SWIG_fail;
10082 temp2 = true;
10083 }
10084 {
10085 PyThreadState* __tstate = wxPyBeginAllowThreads();
10086 (arg1)->SetName((wxString const &)*arg2);
10087
10088 wxPyEndAllowThreads(__tstate);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 Py_INCREF(Py_None); resultobj = Py_None;
10092 {
10093 if (temp2)
10094 delete arg2;
10095 }
10096 return resultobj;
10097 fail:
10098 {
10099 if (temp2)
10100 delete arg2;
10101 }
10102 return NULL;
10103 }
10104
10105
10106 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10107 PyObject *resultobj;
10108 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10109 wxString *arg2 = 0 ;
10110 bool temp2 = false ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 char *kwnames[] = {
10114 (char *) "self",(char *) "extension", NULL
10115 };
10116
10117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10119 if (SWIG_arg_fail(1)) SWIG_fail;
10120 {
10121 arg2 = wxString_in_helper(obj1);
10122 if (arg2 == NULL) SWIG_fail;
10123 temp2 = true;
10124 }
10125 {
10126 PyThreadState* __tstate = wxPyBeginAllowThreads();
10127 (arg1)->SetExtension((wxString const &)*arg2);
10128
10129 wxPyEndAllowThreads(__tstate);
10130 if (PyErr_Occurred()) SWIG_fail;
10131 }
10132 Py_INCREF(Py_None); resultobj = Py_None;
10133 {
10134 if (temp2)
10135 delete arg2;
10136 }
10137 return resultobj;
10138 fail:
10139 {
10140 if (temp2)
10141 delete arg2;
10142 }
10143 return NULL;
10144 }
10145
10146
10147 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10148 PyObject *resultobj;
10149 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10150 long arg2 ;
10151 PyObject * obj0 = 0 ;
10152 PyObject * obj1 = 0 ;
10153 char *kwnames[] = {
10154 (char *) "self",(char *) "type", NULL
10155 };
10156
10157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10159 if (SWIG_arg_fail(1)) SWIG_fail;
10160 {
10161 arg2 = (long)(SWIG_As_long(obj1));
10162 if (SWIG_arg_fail(2)) SWIG_fail;
10163 }
10164 {
10165 PyThreadState* __tstate = wxPyBeginAllowThreads();
10166 (arg1)->SetType(arg2);
10167
10168 wxPyEndAllowThreads(__tstate);
10169 if (PyErr_Occurred()) SWIG_fail;
10170 }
10171 Py_INCREF(Py_None); resultobj = Py_None;
10172 return resultobj;
10173 fail:
10174 return NULL;
10175 }
10176
10177
10178 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj;
10180 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10181 wxString *arg2 = 0 ;
10182 bool temp2 = false ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char *kwnames[] = {
10186 (char *) "self",(char *) "mimetype", NULL
10187 };
10188
10189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10191 if (SWIG_arg_fail(1)) SWIG_fail;
10192 {
10193 arg2 = wxString_in_helper(obj1);
10194 if (arg2 == NULL) SWIG_fail;
10195 temp2 = true;
10196 }
10197 {
10198 PyThreadState* __tstate = wxPyBeginAllowThreads();
10199 (arg1)->SetMimeType((wxString const &)*arg2);
10200
10201 wxPyEndAllowThreads(__tstate);
10202 if (PyErr_Occurred()) SWIG_fail;
10203 }
10204 Py_INCREF(Py_None); resultobj = Py_None;
10205 {
10206 if (temp2)
10207 delete arg2;
10208 }
10209 return resultobj;
10210 fail:
10211 {
10212 if (temp2)
10213 delete arg2;
10214 }
10215 return NULL;
10216 }
10217
10218
10219 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10220 PyObject *obj;
10221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10222 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10223 Py_INCREF(obj);
10224 return Py_BuildValue((char *)"");
10225 }
10226 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10227 PyObject *resultobj;
10228 wxImageHistogram *result;
10229 char *kwnames[] = {
10230 NULL
10231 };
10232
10233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10234 {
10235 PyThreadState* __tstate = wxPyBeginAllowThreads();
10236 result = (wxImageHistogram *)new wxImageHistogram();
10237
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj;
10250 byte arg1 ;
10251 byte arg2 ;
10252 byte arg3 ;
10253 unsigned long result;
10254 PyObject * obj0 = 0 ;
10255 PyObject * obj1 = 0 ;
10256 PyObject * obj2 = 0 ;
10257 char *kwnames[] = {
10258 (char *) "r",(char *) "g",(char *) "b", NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10262 {
10263 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10264 if (SWIG_arg_fail(1)) SWIG_fail;
10265 }
10266 {
10267 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10268 if (SWIG_arg_fail(2)) SWIG_fail;
10269 }
10270 {
10271 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10272 if (SWIG_arg_fail(3)) SWIG_fail;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10277
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 {
10282 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10283 }
10284 return resultobj;
10285 fail:
10286 return NULL;
10287 }
10288
10289
10290 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj;
10292 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10293 byte *arg2 = (byte *) 0 ;
10294 byte *arg3 = (byte *) 0 ;
10295 byte *arg4 = (byte *) 0 ;
10296 byte arg5 = (byte) 1 ;
10297 byte arg6 = (byte) 0 ;
10298 byte arg7 = (byte) 0 ;
10299 bool result;
10300 byte temp2 ;
10301 int res2 = 0 ;
10302 byte temp3 ;
10303 int res3 = 0 ;
10304 byte temp4 ;
10305 int res4 = 0 ;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 PyObject * obj2 = 0 ;
10309 PyObject * obj3 = 0 ;
10310 char *kwnames[] = {
10311 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10312 };
10313
10314 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10315 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10316 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10319 if (SWIG_arg_fail(1)) SWIG_fail;
10320 if (obj1) {
10321 {
10322 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10323 if (SWIG_arg_fail(5)) SWIG_fail;
10324 }
10325 }
10326 if (obj2) {
10327 {
10328 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10329 if (SWIG_arg_fail(6)) SWIG_fail;
10330 }
10331 }
10332 if (obj3) {
10333 {
10334 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10335 if (SWIG_arg_fail(7)) SWIG_fail;
10336 }
10337 }
10338 {
10339 PyThreadState* __tstate = wxPyBeginAllowThreads();
10340 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10341
10342 wxPyEndAllowThreads(__tstate);
10343 if (PyErr_Occurred()) SWIG_fail;
10344 }
10345 {
10346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10347 }
10348 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10349 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10350 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10351 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10352 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10353 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10354 return resultobj;
10355 fail:
10356 return NULL;
10357 }
10358
10359
10360 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj;
10362 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10363 unsigned long arg2 ;
10364 unsigned long result;
10365 PyObject * obj0 = 0 ;
10366 PyObject * obj1 = 0 ;
10367 char *kwnames[] = {
10368 (char *) "self",(char *) "key", NULL
10369 };
10370
10371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10373 if (SWIG_arg_fail(1)) SWIG_fail;
10374 {
10375 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10376 if (SWIG_arg_fail(2)) SWIG_fail;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10381
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 {
10386 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10387 }
10388 return resultobj;
10389 fail:
10390 return NULL;
10391 }
10392
10393
10394 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10395 PyObject *resultobj;
10396 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10397 byte arg2 ;
10398 byte arg3 ;
10399 byte arg4 ;
10400 unsigned long result;
10401 PyObject * obj0 = 0 ;
10402 PyObject * obj1 = 0 ;
10403 PyObject * obj2 = 0 ;
10404 PyObject * obj3 = 0 ;
10405 char *kwnames[] = {
10406 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10407 };
10408
10409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10411 if (SWIG_arg_fail(1)) SWIG_fail;
10412 {
10413 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10414 if (SWIG_arg_fail(2)) SWIG_fail;
10415 }
10416 {
10417 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10418 if (SWIG_arg_fail(3)) SWIG_fail;
10419 }
10420 {
10421 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10422 if (SWIG_arg_fail(4)) SWIG_fail;
10423 }
10424 {
10425 PyThreadState* __tstate = wxPyBeginAllowThreads();
10426 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10427
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10433 }
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj;
10442 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10443 wxColour *arg2 = 0 ;
10444 unsigned long result;
10445 wxColour temp2 ;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 char *kwnames[] = {
10449 (char *) "self",(char *) "colour", NULL
10450 };
10451
10452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10454 if (SWIG_arg_fail(1)) SWIG_fail;
10455 {
10456 arg2 = &temp2;
10457 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10458 }
10459 {
10460 PyThreadState* __tstate = wxPyBeginAllowThreads();
10461 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10462
10463 wxPyEndAllowThreads(__tstate);
10464 if (PyErr_Occurred()) SWIG_fail;
10465 }
10466 {
10467 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10468 }
10469 return resultobj;
10470 fail:
10471 return NULL;
10472 }
10473
10474
10475 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10476 PyObject *obj;
10477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10478 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10479 Py_INCREF(obj);
10480 return Py_BuildValue((char *)"");
10481 }
10482 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10483 PyObject *resultobj;
10484 wxString *arg1 = 0 ;
10485 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10486 int arg3 = (int) -1 ;
10487 wxImage *result;
10488 bool temp1 = false ;
10489 PyObject * obj0 = 0 ;
10490 PyObject * obj1 = 0 ;
10491 PyObject * obj2 = 0 ;
10492 char *kwnames[] = {
10493 (char *) "name",(char *) "type",(char *) "index", NULL
10494 };
10495
10496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10497 {
10498 arg1 = wxString_in_helper(obj0);
10499 if (arg1 == NULL) SWIG_fail;
10500 temp1 = true;
10501 }
10502 if (obj1) {
10503 {
10504 arg2 = (long)(SWIG_As_long(obj1));
10505 if (SWIG_arg_fail(2)) SWIG_fail;
10506 }
10507 }
10508 if (obj2) {
10509 {
10510 arg3 = (int)(SWIG_As_int(obj2));
10511 if (SWIG_arg_fail(3)) SWIG_fail;
10512 }
10513 }
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10517
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10522 {
10523 if (temp1)
10524 delete arg1;
10525 }
10526 return resultobj;
10527 fail:
10528 {
10529 if (temp1)
10530 delete arg1;
10531 }
10532 return NULL;
10533 }
10534
10535
10536 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10537 PyObject *resultobj;
10538 wxImage *arg1 = (wxImage *) 0 ;
10539 PyObject * obj0 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "self", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10546 if (SWIG_arg_fail(1)) SWIG_fail;
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 delete arg1;
10550
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 Py_INCREF(Py_None); resultobj = Py_None;
10555 return resultobj;
10556 fail:
10557 return NULL;
10558 }
10559
10560
10561 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10562 PyObject *resultobj;
10563 wxString *arg1 = 0 ;
10564 wxString *arg2 = 0 ;
10565 int arg3 = (int) -1 ;
10566 wxImage *result;
10567 bool temp1 = false ;
10568 bool temp2 = false ;
10569 PyObject * obj0 = 0 ;
10570 PyObject * obj1 = 0 ;
10571 PyObject * obj2 = 0 ;
10572 char *kwnames[] = {
10573 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10574 };
10575
10576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10577 {
10578 arg1 = wxString_in_helper(obj0);
10579 if (arg1 == NULL) SWIG_fail;
10580 temp1 = true;
10581 }
10582 {
10583 arg2 = wxString_in_helper(obj1);
10584 if (arg2 == NULL) SWIG_fail;
10585 temp2 = true;
10586 }
10587 if (obj2) {
10588 {
10589 arg3 = (int)(SWIG_As_int(obj2));
10590 if (SWIG_arg_fail(3)) SWIG_fail;
10591 }
10592 }
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10596
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10601 {
10602 if (temp1)
10603 delete arg1;
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return resultobj;
10610 fail:
10611 {
10612 if (temp1)
10613 delete arg1;
10614 }
10615 {
10616 if (temp2)
10617 delete arg2;
10618 }
10619 return NULL;
10620 }
10621
10622
10623 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10624 PyObject *resultobj;
10625 wxInputStream *arg1 = 0 ;
10626 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10627 int arg3 = (int) -1 ;
10628 wxImage *result;
10629 wxPyInputStream *temp1 ;
10630 bool created1 ;
10631 PyObject * obj0 = 0 ;
10632 PyObject * obj1 = 0 ;
10633 PyObject * obj2 = 0 ;
10634 char *kwnames[] = {
10635 (char *) "stream",(char *) "type",(char *) "index", NULL
10636 };
10637
10638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10639 {
10640 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10641 arg1 = temp1->m_wxis;
10642 created1 = false;
10643 } else {
10644 PyErr_Clear(); // clear the failure of the wxPyConvert above
10645 arg1 = wxPyCBInputStream_create(obj0, false);
10646 if (arg1 == NULL) {
10647 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10648 SWIG_fail;
10649 }
10650 created1 = true;
10651 }
10652 }
10653 if (obj1) {
10654 {
10655 arg2 = (long)(SWIG_As_long(obj1));
10656 if (SWIG_arg_fail(2)) SWIG_fail;
10657 }
10658 }
10659 if (obj2) {
10660 {
10661 arg3 = (int)(SWIG_As_int(obj2));
10662 if (SWIG_arg_fail(3)) SWIG_fail;
10663 }
10664 }
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10673 {
10674 if (created1) delete arg1;
10675 }
10676 return resultobj;
10677 fail:
10678 {
10679 if (created1) delete arg1;
10680 }
10681 return NULL;
10682 }
10683
10684
10685 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10686 PyObject *resultobj;
10687 wxInputStream *arg1 = 0 ;
10688 wxString *arg2 = 0 ;
10689 int arg3 = (int) -1 ;
10690 wxImage *result;
10691 wxPyInputStream *temp1 ;
10692 bool created1 ;
10693 bool temp2 = false ;
10694 PyObject * obj0 = 0 ;
10695 PyObject * obj1 = 0 ;
10696 PyObject * obj2 = 0 ;
10697 char *kwnames[] = {
10698 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10699 };
10700
10701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10702 {
10703 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10704 arg1 = temp1->m_wxis;
10705 created1 = false;
10706 } else {
10707 PyErr_Clear(); // clear the failure of the wxPyConvert above
10708 arg1 = wxPyCBInputStream_create(obj0, false);
10709 if (arg1 == NULL) {
10710 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10711 SWIG_fail;
10712 }
10713 created1 = true;
10714 }
10715 }
10716 {
10717 arg2 = wxString_in_helper(obj1);
10718 if (arg2 == NULL) SWIG_fail;
10719 temp2 = true;
10720 }
10721 if (obj2) {
10722 {
10723 arg3 = (int)(SWIG_As_int(obj2));
10724 if (SWIG_arg_fail(3)) SWIG_fail;
10725 }
10726 }
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10730
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10735 {
10736 if (created1) delete arg1;
10737 }
10738 {
10739 if (temp2)
10740 delete arg2;
10741 }
10742 return resultobj;
10743 fail:
10744 {
10745 if (created1) delete arg1;
10746 }
10747 {
10748 if (temp2)
10749 delete arg2;
10750 }
10751 return NULL;
10752 }
10753
10754
10755 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj;
10757 int arg1 = (int) 0 ;
10758 int arg2 = (int) 0 ;
10759 bool arg3 = (bool) true ;
10760 wxImage *result;
10761 PyObject * obj0 = 0 ;
10762 PyObject * obj1 = 0 ;
10763 PyObject * obj2 = 0 ;
10764 char *kwnames[] = {
10765 (char *) "width",(char *) "height",(char *) "clear", NULL
10766 };
10767
10768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10769 if (obj0) {
10770 {
10771 arg1 = (int)(SWIG_As_int(obj0));
10772 if (SWIG_arg_fail(1)) SWIG_fail;
10773 }
10774 }
10775 if (obj1) {
10776 {
10777 arg2 = (int)(SWIG_As_int(obj1));
10778 if (SWIG_arg_fail(2)) SWIG_fail;
10779 }
10780 }
10781 if (obj2) {
10782 {
10783 arg3 = (bool)(SWIG_As_bool(obj2));
10784 if (SWIG_arg_fail(3)) SWIG_fail;
10785 }
10786 }
10787 {
10788 PyThreadState* __tstate = wxPyBeginAllowThreads();
10789 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10790
10791 wxPyEndAllowThreads(__tstate);
10792 if (PyErr_Occurred()) SWIG_fail;
10793 }
10794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10795 return resultobj;
10796 fail:
10797 return NULL;
10798 }
10799
10800
10801 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10802 PyObject *resultobj;
10803 wxBitmap *arg1 = 0 ;
10804 wxImage *result;
10805 PyObject * obj0 = 0 ;
10806 char *kwnames[] = {
10807 (char *) "bitmap", NULL
10808 };
10809
10810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10811 {
10812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10813 if (SWIG_arg_fail(1)) SWIG_fail;
10814 if (arg1 == NULL) {
10815 SWIG_null_ref("wxBitmap");
10816 }
10817 if (SWIG_arg_fail(1)) SWIG_fail;
10818 }
10819 {
10820 if (!wxPyCheckForApp()) SWIG_fail;
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10823
10824 wxPyEndAllowThreads(__tstate);
10825 if (PyErr_Occurred()) SWIG_fail;
10826 }
10827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10828 return resultobj;
10829 fail:
10830 return NULL;
10831 }
10832
10833
10834 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj;
10836 int arg1 ;
10837 int arg2 ;
10838 buffer arg3 ;
10839 int arg4 ;
10840 wxImage *result;
10841 PyObject * obj0 = 0 ;
10842 PyObject * obj1 = 0 ;
10843 PyObject * obj2 = 0 ;
10844 char *kwnames[] = {
10845 (char *) "width",(char *) "height",(char *) "data", NULL
10846 };
10847
10848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10849 {
10850 arg1 = (int)(SWIG_As_int(obj0));
10851 if (SWIG_arg_fail(1)) SWIG_fail;
10852 }
10853 {
10854 arg2 = (int)(SWIG_As_int(obj1));
10855 if (SWIG_arg_fail(2)) SWIG_fail;
10856 }
10857 {
10858 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10859 }
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10863
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj;
10876 int arg1 ;
10877 int arg2 ;
10878 buffer arg3 ;
10879 int arg4 ;
10880 buffer arg5 ;
10881 int arg6 ;
10882 wxImage *result;
10883 PyObject * obj0 = 0 ;
10884 PyObject * obj1 = 0 ;
10885 PyObject * obj2 = 0 ;
10886 PyObject * obj3 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10892 {
10893 arg1 = (int)(SWIG_As_int(obj0));
10894 if (SWIG_arg_fail(1)) SWIG_fail;
10895 }
10896 {
10897 arg2 = (int)(SWIG_As_int(obj1));
10898 if (SWIG_arg_fail(2)) SWIG_fail;
10899 }
10900 {
10901 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10902 }
10903 {
10904 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10909
10910 wxPyEndAllowThreads(__tstate);
10911 if (PyErr_Occurred()) SWIG_fail;
10912 }
10913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10914 return resultobj;
10915 fail:
10916 return NULL;
10917 }
10918
10919
10920 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10921 PyObject *resultobj;
10922 wxImage *arg1 = (wxImage *) 0 ;
10923 int arg2 ;
10924 int arg3 ;
10925 bool arg4 = (bool) true ;
10926 PyObject * obj0 = 0 ;
10927 PyObject * obj1 = 0 ;
10928 PyObject * obj2 = 0 ;
10929 PyObject * obj3 = 0 ;
10930 char *kwnames[] = {
10931 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
10932 };
10933
10934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10936 if (SWIG_arg_fail(1)) SWIG_fail;
10937 {
10938 arg2 = (int)(SWIG_As_int(obj1));
10939 if (SWIG_arg_fail(2)) SWIG_fail;
10940 }
10941 {
10942 arg3 = (int)(SWIG_As_int(obj2));
10943 if (SWIG_arg_fail(3)) SWIG_fail;
10944 }
10945 if (obj3) {
10946 {
10947 arg4 = (bool)(SWIG_As_bool(obj3));
10948 if (SWIG_arg_fail(4)) SWIG_fail;
10949 }
10950 }
10951 {
10952 PyThreadState* __tstate = wxPyBeginAllowThreads();
10953 (arg1)->Create(arg2,arg3,arg4);
10954
10955 wxPyEndAllowThreads(__tstate);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 Py_INCREF(Py_None); resultobj = Py_None;
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj;
10967 wxImage *arg1 = (wxImage *) 0 ;
10968 PyObject * obj0 = 0 ;
10969 char *kwnames[] = {
10970 (char *) "self", NULL
10971 };
10972
10973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10975 if (SWIG_arg_fail(1)) SWIG_fail;
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 (arg1)->Destroy();
10979
10980 wxPyEndAllowThreads(__tstate);
10981 if (PyErr_Occurred()) SWIG_fail;
10982 }
10983 Py_INCREF(Py_None); resultobj = Py_None;
10984 return resultobj;
10985 fail:
10986 return NULL;
10987 }
10988
10989
10990 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj;
10992 wxImage *arg1 = (wxImage *) 0 ;
10993 int arg2 ;
10994 int arg3 ;
10995 SwigValueWrapper<wxImage > result;
10996 PyObject * obj0 = 0 ;
10997 PyObject * obj1 = 0 ;
10998 PyObject * obj2 = 0 ;
10999 char *kwnames[] = {
11000 (char *) "self",(char *) "width",(char *) "height", NULL
11001 };
11002
11003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11005 if (SWIG_arg_fail(1)) SWIG_fail;
11006 {
11007 arg2 = (int)(SWIG_As_int(obj1));
11008 if (SWIG_arg_fail(2)) SWIG_fail;
11009 }
11010 {
11011 arg3 = (int)(SWIG_As_int(obj2));
11012 if (SWIG_arg_fail(3)) SWIG_fail;
11013 }
11014 {
11015 PyThreadState* __tstate = wxPyBeginAllowThreads();
11016 result = (arg1)->Scale(arg2,arg3);
11017
11018 wxPyEndAllowThreads(__tstate);
11019 if (PyErr_Occurred()) SWIG_fail;
11020 }
11021 {
11022 wxImage * resultptr;
11023 resultptr = new wxImage((wxImage &)(result));
11024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11025 }
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj;
11034 wxImage *arg1 = (wxImage *) 0 ;
11035 int arg2 ;
11036 int arg3 ;
11037 SwigValueWrapper<wxImage > result;
11038 PyObject * obj0 = 0 ;
11039 PyObject * obj1 = 0 ;
11040 PyObject * obj2 = 0 ;
11041 char *kwnames[] = {
11042 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11043 };
11044
11045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11047 if (SWIG_arg_fail(1)) SWIG_fail;
11048 {
11049 arg2 = (int)(SWIG_As_int(obj1));
11050 if (SWIG_arg_fail(2)) SWIG_fail;
11051 }
11052 {
11053 arg3 = (int)(SWIG_As_int(obj2));
11054 if (SWIG_arg_fail(3)) SWIG_fail;
11055 }
11056 {
11057 PyThreadState* __tstate = wxPyBeginAllowThreads();
11058 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11059
11060 wxPyEndAllowThreads(__tstate);
11061 if (PyErr_Occurred()) SWIG_fail;
11062 }
11063 {
11064 wxImage * resultptr;
11065 resultptr = new wxImage((wxImage &)(result));
11066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11067 }
11068 return resultobj;
11069 fail:
11070 return NULL;
11071 }
11072
11073
11074 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11075 PyObject *resultobj;
11076 wxImage *arg1 = (wxImage *) 0 ;
11077 int arg2 ;
11078 int arg3 ;
11079 wxImage *result;
11080 PyObject * obj0 = 0 ;
11081 PyObject * obj1 = 0 ;
11082 PyObject * obj2 = 0 ;
11083 char *kwnames[] = {
11084 (char *) "self",(char *) "width",(char *) "height", NULL
11085 };
11086
11087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11089 if (SWIG_arg_fail(1)) SWIG_fail;
11090 {
11091 arg2 = (int)(SWIG_As_int(obj1));
11092 if (SWIG_arg_fail(2)) SWIG_fail;
11093 }
11094 {
11095 arg3 = (int)(SWIG_As_int(obj2));
11096 if (SWIG_arg_fail(3)) SWIG_fail;
11097 }
11098 {
11099 PyThreadState* __tstate = wxPyBeginAllowThreads();
11100 {
11101 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11102 result = (wxImage *) &_result_ref;
11103 }
11104
11105 wxPyEndAllowThreads(__tstate);
11106 if (PyErr_Occurred()) SWIG_fail;
11107 }
11108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11109 return resultobj;
11110 fail:
11111 return NULL;
11112 }
11113
11114
11115 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj;
11117 wxImage *arg1 = (wxImage *) 0 ;
11118 wxSize *arg2 = 0 ;
11119 wxPoint *arg3 = 0 ;
11120 int arg4 = (int) -1 ;
11121 int arg5 = (int) -1 ;
11122 int arg6 = (int) -1 ;
11123 wxImage *result;
11124 wxSize temp2 ;
11125 wxPoint temp3 ;
11126 PyObject * obj0 = 0 ;
11127 PyObject * obj1 = 0 ;
11128 PyObject * obj2 = 0 ;
11129 PyObject * obj3 = 0 ;
11130 PyObject * obj4 = 0 ;
11131 PyObject * obj5 = 0 ;
11132 char *kwnames[] = {
11133 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11134 };
11135
11136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11138 if (SWIG_arg_fail(1)) SWIG_fail;
11139 {
11140 arg2 = &temp2;
11141 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11142 }
11143 {
11144 arg3 = &temp3;
11145 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11146 }
11147 if (obj3) {
11148 {
11149 arg4 = (int)(SWIG_As_int(obj3));
11150 if (SWIG_arg_fail(4)) SWIG_fail;
11151 }
11152 }
11153 if (obj4) {
11154 {
11155 arg5 = (int)(SWIG_As_int(obj4));
11156 if (SWIG_arg_fail(5)) SWIG_fail;
11157 }
11158 }
11159 if (obj5) {
11160 {
11161 arg6 = (int)(SWIG_As_int(obj5));
11162 if (SWIG_arg_fail(6)) SWIG_fail;
11163 }
11164 }
11165 {
11166 PyThreadState* __tstate = wxPyBeginAllowThreads();
11167 {
11168 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11169 result = (wxImage *) &_result_ref;
11170 }
11171
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11176 return resultobj;
11177 fail:
11178 return NULL;
11179 }
11180
11181
11182 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11183 PyObject *resultobj;
11184 wxImage *arg1 = (wxImage *) 0 ;
11185 int arg2 ;
11186 int arg3 ;
11187 byte arg4 ;
11188 byte arg5 ;
11189 byte arg6 ;
11190 PyObject * obj0 = 0 ;
11191 PyObject * obj1 = 0 ;
11192 PyObject * obj2 = 0 ;
11193 PyObject * obj3 = 0 ;
11194 PyObject * obj4 = 0 ;
11195 PyObject * obj5 = 0 ;
11196 char *kwnames[] = {
11197 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11198 };
11199
11200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11202 if (SWIG_arg_fail(1)) SWIG_fail;
11203 {
11204 arg2 = (int)(SWIG_As_int(obj1));
11205 if (SWIG_arg_fail(2)) SWIG_fail;
11206 }
11207 {
11208 arg3 = (int)(SWIG_As_int(obj2));
11209 if (SWIG_arg_fail(3)) SWIG_fail;
11210 }
11211 {
11212 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11213 if (SWIG_arg_fail(4)) SWIG_fail;
11214 }
11215 {
11216 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11217 if (SWIG_arg_fail(5)) SWIG_fail;
11218 }
11219 {
11220 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11221 if (SWIG_arg_fail(6)) SWIG_fail;
11222 }
11223 {
11224 PyThreadState* __tstate = wxPyBeginAllowThreads();
11225 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11226
11227 wxPyEndAllowThreads(__tstate);
11228 if (PyErr_Occurred()) SWIG_fail;
11229 }
11230 Py_INCREF(Py_None); resultobj = Py_None;
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11238 PyObject *resultobj;
11239 wxImage *arg1 = (wxImage *) 0 ;
11240 wxRect *arg2 = 0 ;
11241 byte arg3 ;
11242 byte arg4 ;
11243 byte arg5 ;
11244 wxRect temp2 ;
11245 PyObject * obj0 = 0 ;
11246 PyObject * obj1 = 0 ;
11247 PyObject * obj2 = 0 ;
11248 PyObject * obj3 = 0 ;
11249 PyObject * obj4 = 0 ;
11250 char *kwnames[] = {
11251 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11252 };
11253
11254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11256 if (SWIG_arg_fail(1)) SWIG_fail;
11257 {
11258 arg2 = &temp2;
11259 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11260 }
11261 {
11262 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11263 if (SWIG_arg_fail(3)) SWIG_fail;
11264 }
11265 {
11266 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11267 if (SWIG_arg_fail(4)) SWIG_fail;
11268 }
11269 {
11270 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11271 if (SWIG_arg_fail(5)) SWIG_fail;
11272 }
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11276
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 Py_INCREF(Py_None); resultobj = Py_None;
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj;
11289 wxImage *arg1 = (wxImage *) 0 ;
11290 int arg2 ;
11291 int arg3 ;
11292 byte result;
11293 PyObject * obj0 = 0 ;
11294 PyObject * obj1 = 0 ;
11295 PyObject * obj2 = 0 ;
11296 char *kwnames[] = {
11297 (char *) "self",(char *) "x",(char *) "y", NULL
11298 };
11299
11300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11302 if (SWIG_arg_fail(1)) SWIG_fail;
11303 {
11304 arg2 = (int)(SWIG_As_int(obj1));
11305 if (SWIG_arg_fail(2)) SWIG_fail;
11306 }
11307 {
11308 arg3 = (int)(SWIG_As_int(obj2));
11309 if (SWIG_arg_fail(3)) SWIG_fail;
11310 }
11311 {
11312 PyThreadState* __tstate = wxPyBeginAllowThreads();
11313 result = (byte)(arg1)->GetRed(arg2,arg3);
11314
11315 wxPyEndAllowThreads(__tstate);
11316 if (PyErr_Occurred()) SWIG_fail;
11317 }
11318 {
11319 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11320 }
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj;
11329 wxImage *arg1 = (wxImage *) 0 ;
11330 int arg2 ;
11331 int arg3 ;
11332 byte result;
11333 PyObject * obj0 = 0 ;
11334 PyObject * obj1 = 0 ;
11335 PyObject * obj2 = 0 ;
11336 char *kwnames[] = {
11337 (char *) "self",(char *) "x",(char *) "y", NULL
11338 };
11339
11340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11342 if (SWIG_arg_fail(1)) SWIG_fail;
11343 {
11344 arg2 = (int)(SWIG_As_int(obj1));
11345 if (SWIG_arg_fail(2)) SWIG_fail;
11346 }
11347 {
11348 arg3 = (int)(SWIG_As_int(obj2));
11349 if (SWIG_arg_fail(3)) SWIG_fail;
11350 }
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 result = (byte)(arg1)->GetGreen(arg2,arg3);
11354
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 {
11359 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11360 }
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj;
11369 wxImage *arg1 = (wxImage *) 0 ;
11370 int arg2 ;
11371 int arg3 ;
11372 byte result;
11373 PyObject * obj0 = 0 ;
11374 PyObject * obj1 = 0 ;
11375 PyObject * obj2 = 0 ;
11376 char *kwnames[] = {
11377 (char *) "self",(char *) "x",(char *) "y", NULL
11378 };
11379
11380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11382 if (SWIG_arg_fail(1)) SWIG_fail;
11383 {
11384 arg2 = (int)(SWIG_As_int(obj1));
11385 if (SWIG_arg_fail(2)) SWIG_fail;
11386 }
11387 {
11388 arg3 = (int)(SWIG_As_int(obj2));
11389 if (SWIG_arg_fail(3)) SWIG_fail;
11390 }
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 result = (byte)(arg1)->GetBlue(arg2,arg3);
11394
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 {
11399 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11400 }
11401 return resultobj;
11402 fail:
11403 return NULL;
11404 }
11405
11406
11407 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj;
11409 wxImage *arg1 = (wxImage *) 0 ;
11410 int arg2 ;
11411 int arg3 ;
11412 byte arg4 ;
11413 PyObject * obj0 = 0 ;
11414 PyObject * obj1 = 0 ;
11415 PyObject * obj2 = 0 ;
11416 PyObject * obj3 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11423 if (SWIG_arg_fail(1)) SWIG_fail;
11424 {
11425 arg2 = (int)(SWIG_As_int(obj1));
11426 if (SWIG_arg_fail(2)) SWIG_fail;
11427 }
11428 {
11429 arg3 = (int)(SWIG_As_int(obj2));
11430 if (SWIG_arg_fail(3)) SWIG_fail;
11431 }
11432 {
11433 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11434 if (SWIG_arg_fail(4)) SWIG_fail;
11435 }
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 (arg1)->SetAlpha(arg2,arg3,arg4);
11439
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 Py_INCREF(Py_None); resultobj = Py_None;
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj;
11452 wxImage *arg1 = (wxImage *) 0 ;
11453 int arg2 ;
11454 int arg3 ;
11455 byte result;
11456 PyObject * obj0 = 0 ;
11457 PyObject * obj1 = 0 ;
11458 PyObject * obj2 = 0 ;
11459 char *kwnames[] = {
11460 (char *) "self",(char *) "x",(char *) "y", NULL
11461 };
11462
11463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11465 if (SWIG_arg_fail(1)) SWIG_fail;
11466 {
11467 arg2 = (int)(SWIG_As_int(obj1));
11468 if (SWIG_arg_fail(2)) SWIG_fail;
11469 }
11470 {
11471 arg3 = (int)(SWIG_As_int(obj2));
11472 if (SWIG_arg_fail(3)) SWIG_fail;
11473 }
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11477
11478 wxPyEndAllowThreads(__tstate);
11479 if (PyErr_Occurred()) SWIG_fail;
11480 }
11481 {
11482 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11483 }
11484 return resultobj;
11485 fail:
11486 return NULL;
11487 }
11488
11489
11490 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11491 PyObject *resultobj;
11492 wxImage *arg1 = (wxImage *) 0 ;
11493 bool result;
11494 PyObject * obj0 = 0 ;
11495 char *kwnames[] = {
11496 (char *) "self", NULL
11497 };
11498
11499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11501 if (SWIG_arg_fail(1)) SWIG_fail;
11502 {
11503 PyThreadState* __tstate = wxPyBeginAllowThreads();
11504 result = (bool)(arg1)->HasAlpha();
11505
11506 wxPyEndAllowThreads(__tstate);
11507 if (PyErr_Occurred()) SWIG_fail;
11508 }
11509 {
11510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11511 }
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj;
11520 wxImage *arg1 = (wxImage *) 0 ;
11521 PyObject * obj0 = 0 ;
11522 char *kwnames[] = {
11523 (char *) "self", NULL
11524 };
11525
11526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11528 if (SWIG_arg_fail(1)) SWIG_fail;
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 (arg1)->InitAlpha();
11532
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 Py_INCREF(Py_None); resultobj = Py_None;
11537 return resultobj;
11538 fail:
11539 return NULL;
11540 }
11541
11542
11543 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11544 PyObject *resultobj;
11545 wxImage *arg1 = (wxImage *) 0 ;
11546 int arg2 ;
11547 int arg3 ;
11548 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11549 bool result;
11550 PyObject * obj0 = 0 ;
11551 PyObject * obj1 = 0 ;
11552 PyObject * obj2 = 0 ;
11553 PyObject * obj3 = 0 ;
11554 char *kwnames[] = {
11555 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11556 };
11557
11558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11560 if (SWIG_arg_fail(1)) SWIG_fail;
11561 {
11562 arg2 = (int)(SWIG_As_int(obj1));
11563 if (SWIG_arg_fail(2)) SWIG_fail;
11564 }
11565 {
11566 arg3 = (int)(SWIG_As_int(obj2));
11567 if (SWIG_arg_fail(3)) SWIG_fail;
11568 }
11569 if (obj3) {
11570 {
11571 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11572 if (SWIG_arg_fail(4)) SWIG_fail;
11573 }
11574 }
11575 {
11576 PyThreadState* __tstate = wxPyBeginAllowThreads();
11577 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11578
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 {
11583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11584 }
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj;
11593 wxImage *arg1 = (wxImage *) 0 ;
11594 byte *arg2 = (byte *) 0 ;
11595 byte *arg3 = (byte *) 0 ;
11596 byte *arg4 = (byte *) 0 ;
11597 byte arg5 = (byte) 0 ;
11598 byte arg6 = (byte) 0 ;
11599 byte arg7 = (byte) 0 ;
11600 bool result;
11601 byte temp2 ;
11602 int res2 = 0 ;
11603 byte temp3 ;
11604 int res3 = 0 ;
11605 byte temp4 ;
11606 int res4 = 0 ;
11607 PyObject * obj0 = 0 ;
11608 PyObject * obj1 = 0 ;
11609 PyObject * obj2 = 0 ;
11610 PyObject * obj3 = 0 ;
11611 char *kwnames[] = {
11612 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11613 };
11614
11615 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11616 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11617 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11620 if (SWIG_arg_fail(1)) SWIG_fail;
11621 if (obj1) {
11622 {
11623 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11624 if (SWIG_arg_fail(5)) SWIG_fail;
11625 }
11626 }
11627 if (obj2) {
11628 {
11629 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11630 if (SWIG_arg_fail(6)) SWIG_fail;
11631 }
11632 }
11633 if (obj3) {
11634 {
11635 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11636 if (SWIG_arg_fail(7)) SWIG_fail;
11637 }
11638 }
11639 {
11640 PyThreadState* __tstate = wxPyBeginAllowThreads();
11641 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11642
11643 wxPyEndAllowThreads(__tstate);
11644 if (PyErr_Occurred()) SWIG_fail;
11645 }
11646 {
11647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11648 }
11649 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11650 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11651 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11652 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11653 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11654 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj;
11663 wxImage *arg1 = (wxImage *) 0 ;
11664 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11665 bool result;
11666 PyObject * obj0 = 0 ;
11667 PyObject * obj1 = 0 ;
11668 char *kwnames[] = {
11669 (char *) "self",(char *) "threshold", NULL
11670 };
11671
11672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11674 if (SWIG_arg_fail(1)) SWIG_fail;
11675 if (obj1) {
11676 {
11677 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11678 if (SWIG_arg_fail(2)) SWIG_fail;
11679 }
11680 }
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11684
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 {
11689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11690 }
11691 return resultobj;
11692 fail:
11693 return NULL;
11694 }
11695
11696
11697 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11698 PyObject *resultobj;
11699 wxImage *arg1 = (wxImage *) 0 ;
11700 byte arg2 ;
11701 byte arg3 ;
11702 byte arg4 ;
11703 bool result;
11704 PyObject * obj0 = 0 ;
11705 PyObject * obj1 = 0 ;
11706 PyObject * obj2 = 0 ;
11707 PyObject * obj3 = 0 ;
11708 char *kwnames[] = {
11709 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11710 };
11711
11712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11714 if (SWIG_arg_fail(1)) SWIG_fail;
11715 {
11716 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11717 if (SWIG_arg_fail(2)) SWIG_fail;
11718 }
11719 {
11720 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11721 if (SWIG_arg_fail(3)) SWIG_fail;
11722 }
11723 {
11724 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11725 if (SWIG_arg_fail(4)) SWIG_fail;
11726 }
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11730
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 {
11735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11736 }
11737 return resultobj;
11738 fail:
11739 return NULL;
11740 }
11741
11742
11743 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11744 PyObject *resultobj;
11745 wxImage *arg1 = (wxImage *) 0 ;
11746 wxImage *arg2 = 0 ;
11747 byte arg3 ;
11748 byte arg4 ;
11749 byte arg5 ;
11750 bool result;
11751 PyObject * obj0 = 0 ;
11752 PyObject * obj1 = 0 ;
11753 PyObject * obj2 = 0 ;
11754 PyObject * obj3 = 0 ;
11755 PyObject * obj4 = 0 ;
11756 char *kwnames[] = {
11757 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11758 };
11759
11760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11762 if (SWIG_arg_fail(1)) SWIG_fail;
11763 {
11764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11765 if (SWIG_arg_fail(2)) SWIG_fail;
11766 if (arg2 == NULL) {
11767 SWIG_null_ref("wxImage");
11768 }
11769 if (SWIG_arg_fail(2)) SWIG_fail;
11770 }
11771 {
11772 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11773 if (SWIG_arg_fail(3)) SWIG_fail;
11774 }
11775 {
11776 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11777 if (SWIG_arg_fail(4)) SWIG_fail;
11778 }
11779 {
11780 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11781 if (SWIG_arg_fail(5)) SWIG_fail;
11782 }
11783 {
11784 PyThreadState* __tstate = wxPyBeginAllowThreads();
11785 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11786
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11792 }
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11800 PyObject *resultobj;
11801 wxString *arg1 = 0 ;
11802 bool result;
11803 bool temp1 = false ;
11804 PyObject * obj0 = 0 ;
11805 char *kwnames[] = {
11806 (char *) "filename", NULL
11807 };
11808
11809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11810 {
11811 arg1 = wxString_in_helper(obj0);
11812 if (arg1 == NULL) SWIG_fail;
11813 temp1 = true;
11814 }
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11818
11819 wxPyEndAllowThreads(__tstate);
11820 if (PyErr_Occurred()) SWIG_fail;
11821 }
11822 {
11823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11824 }
11825 {
11826 if (temp1)
11827 delete arg1;
11828 }
11829 return resultobj;
11830 fail:
11831 {
11832 if (temp1)
11833 delete arg1;
11834 }
11835 return NULL;
11836 }
11837
11838
11839 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11840 PyObject *resultobj;
11841 wxString *arg1 = 0 ;
11842 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11843 int result;
11844 bool temp1 = false ;
11845 PyObject * obj0 = 0 ;
11846 PyObject * obj1 = 0 ;
11847 char *kwnames[] = {
11848 (char *) "filename",(char *) "type", NULL
11849 };
11850
11851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11852 {
11853 arg1 = wxString_in_helper(obj0);
11854 if (arg1 == NULL) SWIG_fail;
11855 temp1 = true;
11856 }
11857 if (obj1) {
11858 {
11859 arg2 = (long)(SWIG_As_long(obj1));
11860 if (SWIG_arg_fail(2)) SWIG_fail;
11861 }
11862 }
11863 {
11864 PyThreadState* __tstate = wxPyBeginAllowThreads();
11865 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11866
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 {
11871 resultobj = SWIG_From_int((int)(result));
11872 }
11873 {
11874 if (temp1)
11875 delete arg1;
11876 }
11877 return resultobj;
11878 fail:
11879 {
11880 if (temp1)
11881 delete arg1;
11882 }
11883 return NULL;
11884 }
11885
11886
11887 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj;
11889 wxImage *arg1 = (wxImage *) 0 ;
11890 wxString *arg2 = 0 ;
11891 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11892 int arg4 = (int) -1 ;
11893 bool result;
11894 bool temp2 = false ;
11895 PyObject * obj0 = 0 ;
11896 PyObject * obj1 = 0 ;
11897 PyObject * obj2 = 0 ;
11898 PyObject * obj3 = 0 ;
11899 char *kwnames[] = {
11900 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11901 };
11902
11903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11905 if (SWIG_arg_fail(1)) SWIG_fail;
11906 {
11907 arg2 = wxString_in_helper(obj1);
11908 if (arg2 == NULL) SWIG_fail;
11909 temp2 = true;
11910 }
11911 if (obj2) {
11912 {
11913 arg3 = (long)(SWIG_As_long(obj2));
11914 if (SWIG_arg_fail(3)) SWIG_fail;
11915 }
11916 }
11917 if (obj3) {
11918 {
11919 arg4 = (int)(SWIG_As_int(obj3));
11920 if (SWIG_arg_fail(4)) SWIG_fail;
11921 }
11922 }
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11926
11927 wxPyEndAllowThreads(__tstate);
11928 if (PyErr_Occurred()) SWIG_fail;
11929 }
11930 {
11931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11932 }
11933 {
11934 if (temp2)
11935 delete arg2;
11936 }
11937 return resultobj;
11938 fail:
11939 {
11940 if (temp2)
11941 delete arg2;
11942 }
11943 return NULL;
11944 }
11945
11946
11947 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj;
11949 wxImage *arg1 = (wxImage *) 0 ;
11950 wxString *arg2 = 0 ;
11951 wxString *arg3 = 0 ;
11952 int arg4 = (int) -1 ;
11953 bool result;
11954 bool temp2 = false ;
11955 bool temp3 = false ;
11956 PyObject * obj0 = 0 ;
11957 PyObject * obj1 = 0 ;
11958 PyObject * obj2 = 0 ;
11959 PyObject * obj3 = 0 ;
11960 char *kwnames[] = {
11961 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11962 };
11963
11964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11966 if (SWIG_arg_fail(1)) SWIG_fail;
11967 {
11968 arg2 = wxString_in_helper(obj1);
11969 if (arg2 == NULL) SWIG_fail;
11970 temp2 = true;
11971 }
11972 {
11973 arg3 = wxString_in_helper(obj2);
11974 if (arg3 == NULL) SWIG_fail;
11975 temp3 = true;
11976 }
11977 if (obj3) {
11978 {
11979 arg4 = (int)(SWIG_As_int(obj3));
11980 if (SWIG_arg_fail(4)) SWIG_fail;
11981 }
11982 }
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11986
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 {
11991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11992 }
11993 {
11994 if (temp2)
11995 delete arg2;
11996 }
11997 {
11998 if (temp3)
11999 delete arg3;
12000 }
12001 return resultobj;
12002 fail:
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 {
12008 if (temp3)
12009 delete arg3;
12010 }
12011 return NULL;
12012 }
12013
12014
12015 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj;
12017 wxImage *arg1 = (wxImage *) 0 ;
12018 wxString *arg2 = 0 ;
12019 int arg3 ;
12020 bool result;
12021 bool temp2 = false ;
12022 PyObject * obj0 = 0 ;
12023 PyObject * obj1 = 0 ;
12024 PyObject * obj2 = 0 ;
12025 char *kwnames[] = {
12026 (char *) "self",(char *) "name",(char *) "type", NULL
12027 };
12028
12029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12031 if (SWIG_arg_fail(1)) SWIG_fail;
12032 {
12033 arg2 = wxString_in_helper(obj1);
12034 if (arg2 == NULL) SWIG_fail;
12035 temp2 = true;
12036 }
12037 {
12038 arg3 = (int)(SWIG_As_int(obj2));
12039 if (SWIG_arg_fail(3)) SWIG_fail;
12040 }
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12044
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 {
12049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12050 }
12051 {
12052 if (temp2)
12053 delete arg2;
12054 }
12055 return resultobj;
12056 fail:
12057 {
12058 if (temp2)
12059 delete arg2;
12060 }
12061 return NULL;
12062 }
12063
12064
12065 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12066 PyObject *resultobj;
12067 wxImage *arg1 = (wxImage *) 0 ;
12068 wxString *arg2 = 0 ;
12069 wxString *arg3 = 0 ;
12070 bool result;
12071 bool temp2 = false ;
12072 bool temp3 = false ;
12073 PyObject * obj0 = 0 ;
12074 PyObject * obj1 = 0 ;
12075 PyObject * obj2 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 arg2 = wxString_in_helper(obj1);
12085 if (arg2 == NULL) SWIG_fail;
12086 temp2 = true;
12087 }
12088 {
12089 arg3 = wxString_in_helper(obj2);
12090 if (arg3 == NULL) SWIG_fail;
12091 temp3 = true;
12092 }
12093 {
12094 PyThreadState* __tstate = wxPyBeginAllowThreads();
12095 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12096
12097 wxPyEndAllowThreads(__tstate);
12098 if (PyErr_Occurred()) SWIG_fail;
12099 }
12100 {
12101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12102 }
12103 {
12104 if (temp2)
12105 delete arg2;
12106 }
12107 {
12108 if (temp3)
12109 delete arg3;
12110 }
12111 return resultobj;
12112 fail:
12113 {
12114 if (temp2)
12115 delete arg2;
12116 }
12117 {
12118 if (temp3)
12119 delete arg3;
12120 }
12121 return NULL;
12122 }
12123
12124
12125 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12126 PyObject *resultobj;
12127 wxInputStream *arg1 = 0 ;
12128 bool result;
12129 wxPyInputStream *temp1 ;
12130 bool created1 ;
12131 PyObject * obj0 = 0 ;
12132 char *kwnames[] = {
12133 (char *) "stream", NULL
12134 };
12135
12136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12137 {
12138 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12139 arg1 = temp1->m_wxis;
12140 created1 = false;
12141 } else {
12142 PyErr_Clear(); // clear the failure of the wxPyConvert above
12143 arg1 = wxPyCBInputStream_create(obj0, false);
12144 if (arg1 == NULL) {
12145 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12146 SWIG_fail;
12147 }
12148 created1 = true;
12149 }
12150 }
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 result = (bool)wxImage::CanRead(*arg1);
12154
12155 wxPyEndAllowThreads(__tstate);
12156 if (PyErr_Occurred()) SWIG_fail;
12157 }
12158 {
12159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12160 }
12161 {
12162 if (created1) delete arg1;
12163 }
12164 return resultobj;
12165 fail:
12166 {
12167 if (created1) delete arg1;
12168 }
12169 return NULL;
12170 }
12171
12172
12173 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12174 PyObject *resultobj;
12175 wxImage *arg1 = (wxImage *) 0 ;
12176 wxInputStream *arg2 = 0 ;
12177 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12178 int arg4 = (int) -1 ;
12179 bool result;
12180 wxPyInputStream *temp2 ;
12181 bool created2 ;
12182 PyObject * obj0 = 0 ;
12183 PyObject * obj1 = 0 ;
12184 PyObject * obj2 = 0 ;
12185 PyObject * obj3 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12188 };
12189
12190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 {
12194 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12195 arg2 = temp2->m_wxis;
12196 created2 = false;
12197 } else {
12198 PyErr_Clear(); // clear the failure of the wxPyConvert above
12199 arg2 = wxPyCBInputStream_create(obj1, false);
12200 if (arg2 == NULL) {
12201 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12202 SWIG_fail;
12203 }
12204 created2 = true;
12205 }
12206 }
12207 if (obj2) {
12208 {
12209 arg3 = (long)(SWIG_As_long(obj2));
12210 if (SWIG_arg_fail(3)) SWIG_fail;
12211 }
12212 }
12213 if (obj3) {
12214 {
12215 arg4 = (int)(SWIG_As_int(obj3));
12216 if (SWIG_arg_fail(4)) SWIG_fail;
12217 }
12218 }
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12222
12223 wxPyEndAllowThreads(__tstate);
12224 if (PyErr_Occurred()) SWIG_fail;
12225 }
12226 {
12227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12228 }
12229 {
12230 if (created2) delete arg2;
12231 }
12232 return resultobj;
12233 fail:
12234 {
12235 if (created2) delete arg2;
12236 }
12237 return NULL;
12238 }
12239
12240
12241 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12242 PyObject *resultobj;
12243 wxImage *arg1 = (wxImage *) 0 ;
12244 wxInputStream *arg2 = 0 ;
12245 wxString *arg3 = 0 ;
12246 int arg4 = (int) -1 ;
12247 bool result;
12248 wxPyInputStream *temp2 ;
12249 bool created2 ;
12250 bool temp3 = false ;
12251 PyObject * obj0 = 0 ;
12252 PyObject * obj1 = 0 ;
12253 PyObject * obj2 = 0 ;
12254 PyObject * obj3 = 0 ;
12255 char *kwnames[] = {
12256 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12257 };
12258
12259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12261 if (SWIG_arg_fail(1)) SWIG_fail;
12262 {
12263 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12264 arg2 = temp2->m_wxis;
12265 created2 = false;
12266 } else {
12267 PyErr_Clear(); // clear the failure of the wxPyConvert above
12268 arg2 = wxPyCBInputStream_create(obj1, false);
12269 if (arg2 == NULL) {
12270 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12271 SWIG_fail;
12272 }
12273 created2 = true;
12274 }
12275 }
12276 {
12277 arg3 = wxString_in_helper(obj2);
12278 if (arg3 == NULL) SWIG_fail;
12279 temp3 = true;
12280 }
12281 if (obj3) {
12282 {
12283 arg4 = (int)(SWIG_As_int(obj3));
12284 if (SWIG_arg_fail(4)) SWIG_fail;
12285 }
12286 }
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12290
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 {
12295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12296 }
12297 {
12298 if (created2) delete arg2;
12299 }
12300 {
12301 if (temp3)
12302 delete arg3;
12303 }
12304 return resultobj;
12305 fail:
12306 {
12307 if (created2) delete arg2;
12308 }
12309 {
12310 if (temp3)
12311 delete arg3;
12312 }
12313 return NULL;
12314 }
12315
12316
12317 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12318 PyObject *resultobj;
12319 wxImage *arg1 = (wxImage *) 0 ;
12320 bool result;
12321 PyObject * obj0 = 0 ;
12322 char *kwnames[] = {
12323 (char *) "self", NULL
12324 };
12325
12326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12328 if (SWIG_arg_fail(1)) SWIG_fail;
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 result = (bool)(arg1)->Ok();
12332
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 {
12337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12338 }
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12346 PyObject *resultobj;
12347 wxImage *arg1 = (wxImage *) 0 ;
12348 int result;
12349 PyObject * obj0 = 0 ;
12350 char *kwnames[] = {
12351 (char *) "self", NULL
12352 };
12353
12354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12356 if (SWIG_arg_fail(1)) SWIG_fail;
12357 {
12358 PyThreadState* __tstate = wxPyBeginAllowThreads();
12359 result = (int)(arg1)->GetWidth();
12360
12361 wxPyEndAllowThreads(__tstate);
12362 if (PyErr_Occurred()) SWIG_fail;
12363 }
12364 {
12365 resultobj = SWIG_From_int((int)(result));
12366 }
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12374 PyObject *resultobj;
12375 wxImage *arg1 = (wxImage *) 0 ;
12376 int result;
12377 PyObject * obj0 = 0 ;
12378 char *kwnames[] = {
12379 (char *) "self", NULL
12380 };
12381
12382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12384 if (SWIG_arg_fail(1)) SWIG_fail;
12385 {
12386 PyThreadState* __tstate = wxPyBeginAllowThreads();
12387 result = (int)(arg1)->GetHeight();
12388
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 {
12393 resultobj = SWIG_From_int((int)(result));
12394 }
12395 return resultobj;
12396 fail:
12397 return NULL;
12398 }
12399
12400
12401 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12402 PyObject *resultobj;
12403 wxImage *arg1 = (wxImage *) 0 ;
12404 wxSize result;
12405 PyObject * obj0 = 0 ;
12406 char *kwnames[] = {
12407 (char *) "self", NULL
12408 };
12409
12410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12412 if (SWIG_arg_fail(1)) SWIG_fail;
12413 {
12414 PyThreadState* __tstate = wxPyBeginAllowThreads();
12415 result = wxImage_GetSize(arg1);
12416
12417 wxPyEndAllowThreads(__tstate);
12418 if (PyErr_Occurred()) SWIG_fail;
12419 }
12420 {
12421 wxSize * resultptr;
12422 resultptr = new wxSize((wxSize &)(result));
12423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12424 }
12425 return resultobj;
12426 fail:
12427 return NULL;
12428 }
12429
12430
12431 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12432 PyObject *resultobj;
12433 wxImage *arg1 = (wxImage *) 0 ;
12434 wxRect *arg2 = 0 ;
12435 SwigValueWrapper<wxImage > result;
12436 wxRect temp2 ;
12437 PyObject * obj0 = 0 ;
12438 PyObject * obj1 = 0 ;
12439 char *kwnames[] = {
12440 (char *) "self",(char *) "rect", NULL
12441 };
12442
12443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12445 if (SWIG_arg_fail(1)) SWIG_fail;
12446 {
12447 arg2 = &temp2;
12448 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12449 }
12450 {
12451 PyThreadState* __tstate = wxPyBeginAllowThreads();
12452 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12453
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 {
12458 wxImage * resultptr;
12459 resultptr = new wxImage((wxImage &)(result));
12460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12461 }
12462 return resultobj;
12463 fail:
12464 return NULL;
12465 }
12466
12467
12468 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12469 PyObject *resultobj;
12470 wxImage *arg1 = (wxImage *) 0 ;
12471 wxSize *arg2 = 0 ;
12472 wxPoint *arg3 = 0 ;
12473 int arg4 = (int) -1 ;
12474 int arg5 = (int) -1 ;
12475 int arg6 = (int) -1 ;
12476 SwigValueWrapper<wxImage > result;
12477 wxSize temp2 ;
12478 wxPoint temp3 ;
12479 PyObject * obj0 = 0 ;
12480 PyObject * obj1 = 0 ;
12481 PyObject * obj2 = 0 ;
12482 PyObject * obj3 = 0 ;
12483 PyObject * obj4 = 0 ;
12484 PyObject * obj5 = 0 ;
12485 char *kwnames[] = {
12486 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12487 };
12488
12489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12491 if (SWIG_arg_fail(1)) SWIG_fail;
12492 {
12493 arg2 = &temp2;
12494 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12495 }
12496 {
12497 arg3 = &temp3;
12498 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12499 }
12500 if (obj3) {
12501 {
12502 arg4 = (int)(SWIG_As_int(obj3));
12503 if (SWIG_arg_fail(4)) SWIG_fail;
12504 }
12505 }
12506 if (obj4) {
12507 {
12508 arg5 = (int)(SWIG_As_int(obj4));
12509 if (SWIG_arg_fail(5)) SWIG_fail;
12510 }
12511 }
12512 if (obj5) {
12513 {
12514 arg6 = (int)(SWIG_As_int(obj5));
12515 if (SWIG_arg_fail(6)) SWIG_fail;
12516 }
12517 }
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12521
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 {
12526 wxImage * resultptr;
12527 resultptr = new wxImage((wxImage &)(result));
12528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12529 }
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj;
12538 wxImage *arg1 = (wxImage *) 0 ;
12539 SwigValueWrapper<wxImage > result;
12540 PyObject * obj0 = 0 ;
12541 char *kwnames[] = {
12542 (char *) "self", NULL
12543 };
12544
12545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12547 if (SWIG_arg_fail(1)) SWIG_fail;
12548 {
12549 PyThreadState* __tstate = wxPyBeginAllowThreads();
12550 result = (arg1)->Copy();
12551
12552 wxPyEndAllowThreads(__tstate);
12553 if (PyErr_Occurred()) SWIG_fail;
12554 }
12555 {
12556 wxImage * resultptr;
12557 resultptr = new wxImage((wxImage &)(result));
12558 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12559 }
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12567 PyObject *resultobj;
12568 wxImage *arg1 = (wxImage *) 0 ;
12569 wxImage *arg2 = 0 ;
12570 int arg3 ;
12571 int arg4 ;
12572 PyObject * obj0 = 0 ;
12573 PyObject * obj1 = 0 ;
12574 PyObject * obj2 = 0 ;
12575 PyObject * obj3 = 0 ;
12576 char *kwnames[] = {
12577 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12578 };
12579
12580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12582 if (SWIG_arg_fail(1)) SWIG_fail;
12583 {
12584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12585 if (SWIG_arg_fail(2)) SWIG_fail;
12586 if (arg2 == NULL) {
12587 SWIG_null_ref("wxImage");
12588 }
12589 if (SWIG_arg_fail(2)) SWIG_fail;
12590 }
12591 {
12592 arg3 = (int)(SWIG_As_int(obj2));
12593 if (SWIG_arg_fail(3)) SWIG_fail;
12594 }
12595 {
12596 arg4 = (int)(SWIG_As_int(obj3));
12597 if (SWIG_arg_fail(4)) SWIG_fail;
12598 }
12599 {
12600 PyThreadState* __tstate = wxPyBeginAllowThreads();
12601 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12602
12603 wxPyEndAllowThreads(__tstate);
12604 if (PyErr_Occurred()) SWIG_fail;
12605 }
12606 Py_INCREF(Py_None); resultobj = Py_None;
12607 return resultobj;
12608 fail:
12609 return NULL;
12610 }
12611
12612
12613 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12614 PyObject *resultobj;
12615 wxImage *arg1 = (wxImage *) 0 ;
12616 PyObject *result;
12617 PyObject * obj0 = 0 ;
12618 char *kwnames[] = {
12619 (char *) "self", NULL
12620 };
12621
12622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12624 if (SWIG_arg_fail(1)) SWIG_fail;
12625 {
12626 PyThreadState* __tstate = wxPyBeginAllowThreads();
12627 result = (PyObject *)wxImage_GetData(arg1);
12628
12629 wxPyEndAllowThreads(__tstate);
12630 if (PyErr_Occurred()) SWIG_fail;
12631 }
12632 resultobj = result;
12633 return resultobj;
12634 fail:
12635 return NULL;
12636 }
12637
12638
12639 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj;
12641 wxImage *arg1 = (wxImage *) 0 ;
12642 buffer arg2 ;
12643 int arg3 ;
12644 PyObject * obj0 = 0 ;
12645 PyObject * obj1 = 0 ;
12646 char *kwnames[] = {
12647 (char *) "self",(char *) "data", NULL
12648 };
12649
12650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12652 if (SWIG_arg_fail(1)) SWIG_fail;
12653 {
12654 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12655 }
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 wxImage_SetData(arg1,arg2,arg3);
12659
12660 wxPyEndAllowThreads(__tstate);
12661 if (PyErr_Occurred()) SWIG_fail;
12662 }
12663 Py_INCREF(Py_None); resultobj = Py_None;
12664 return resultobj;
12665 fail:
12666 return NULL;
12667 }
12668
12669
12670 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12671 PyObject *resultobj;
12672 wxImage *arg1 = (wxImage *) 0 ;
12673 PyObject *result;
12674 PyObject * obj0 = 0 ;
12675 char *kwnames[] = {
12676 (char *) "self", NULL
12677 };
12678
12679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12681 if (SWIG_arg_fail(1)) SWIG_fail;
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12685
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 resultobj = result;
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj;
12698 wxImage *arg1 = (wxImage *) 0 ;
12699 buffer arg2 ;
12700 int arg3 ;
12701 PyObject * obj0 = 0 ;
12702 PyObject * obj1 = 0 ;
12703 char *kwnames[] = {
12704 (char *) "self",(char *) "data", NULL
12705 };
12706
12707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12709 if (SWIG_arg_fail(1)) SWIG_fail;
12710 {
12711 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12712 }
12713 {
12714 PyThreadState* __tstate = wxPyBeginAllowThreads();
12715 wxImage_SetDataBuffer(arg1,arg2,arg3);
12716
12717 wxPyEndAllowThreads(__tstate);
12718 if (PyErr_Occurred()) SWIG_fail;
12719 }
12720 Py_INCREF(Py_None); resultobj = Py_None;
12721 return resultobj;
12722 fail:
12723 return NULL;
12724 }
12725
12726
12727 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12728 PyObject *resultobj;
12729 wxImage *arg1 = (wxImage *) 0 ;
12730 PyObject *result;
12731 PyObject * obj0 = 0 ;
12732 char *kwnames[] = {
12733 (char *) "self", NULL
12734 };
12735
12736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12738 if (SWIG_arg_fail(1)) SWIG_fail;
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 result = (PyObject *)wxImage_GetAlphaData(arg1);
12742
12743 wxPyEndAllowThreads(__tstate);
12744 if (PyErr_Occurred()) SWIG_fail;
12745 }
12746 resultobj = result;
12747 return resultobj;
12748 fail:
12749 return NULL;
12750 }
12751
12752
12753 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12754 PyObject *resultobj;
12755 wxImage *arg1 = (wxImage *) 0 ;
12756 buffer arg2 ;
12757 int arg3 ;
12758 PyObject * obj0 = 0 ;
12759 PyObject * obj1 = 0 ;
12760 char *kwnames[] = {
12761 (char *) "self",(char *) "alpha", NULL
12762 };
12763
12764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12766 if (SWIG_arg_fail(1)) SWIG_fail;
12767 {
12768 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12769 }
12770 {
12771 PyThreadState* __tstate = wxPyBeginAllowThreads();
12772 wxImage_SetAlphaData(arg1,arg2,arg3);
12773
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 Py_INCREF(Py_None); resultobj = Py_None;
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12785 PyObject *resultobj;
12786 wxImage *arg1 = (wxImage *) 0 ;
12787 PyObject *result;
12788 PyObject * obj0 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "self", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 {
12797 PyThreadState* __tstate = wxPyBeginAllowThreads();
12798 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12799
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 resultobj = result;
12804 return resultobj;
12805 fail:
12806 return NULL;
12807 }
12808
12809
12810 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12811 PyObject *resultobj;
12812 wxImage *arg1 = (wxImage *) 0 ;
12813 buffer arg2 ;
12814 int arg3 ;
12815 PyObject * obj0 = 0 ;
12816 PyObject * obj1 = 0 ;
12817 char *kwnames[] = {
12818 (char *) "self",(char *) "alpha", NULL
12819 };
12820
12821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 {
12825 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12826 }
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12830
12831 wxPyEndAllowThreads(__tstate);
12832 if (PyErr_Occurred()) SWIG_fail;
12833 }
12834 Py_INCREF(Py_None); resultobj = Py_None;
12835 return resultobj;
12836 fail:
12837 return NULL;
12838 }
12839
12840
12841 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12842 PyObject *resultobj;
12843 wxImage *arg1 = (wxImage *) 0 ;
12844 byte arg2 ;
12845 byte arg3 ;
12846 byte arg4 ;
12847 PyObject * obj0 = 0 ;
12848 PyObject * obj1 = 0 ;
12849 PyObject * obj2 = 0 ;
12850 PyObject * obj3 = 0 ;
12851 char *kwnames[] = {
12852 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12853 };
12854
12855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12857 if (SWIG_arg_fail(1)) SWIG_fail;
12858 {
12859 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12860 if (SWIG_arg_fail(2)) SWIG_fail;
12861 }
12862 {
12863 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12864 if (SWIG_arg_fail(3)) SWIG_fail;
12865 }
12866 {
12867 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12868 if (SWIG_arg_fail(4)) SWIG_fail;
12869 }
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 (arg1)->SetMaskColour(arg2,arg3,arg4);
12873
12874 wxPyEndAllowThreads(__tstate);
12875 if (PyErr_Occurred()) SWIG_fail;
12876 }
12877 Py_INCREF(Py_None); resultobj = Py_None;
12878 return resultobj;
12879 fail:
12880 return NULL;
12881 }
12882
12883
12884 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12885 PyObject *resultobj;
12886 wxImage *arg1 = (wxImage *) 0 ;
12887 byte *arg2 = (byte *) 0 ;
12888 byte *arg3 = (byte *) 0 ;
12889 byte *arg4 = (byte *) 0 ;
12890 byte temp2 ;
12891 int res2 = 0 ;
12892 byte temp3 ;
12893 int res3 = 0 ;
12894 byte temp4 ;
12895 int res4 = 0 ;
12896 PyObject * obj0 = 0 ;
12897 char *kwnames[] = {
12898 (char *) "self", NULL
12899 };
12900
12901 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12902 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12903 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12906 if (SWIG_arg_fail(1)) SWIG_fail;
12907 {
12908 PyThreadState* __tstate = wxPyBeginAllowThreads();
12909 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12910
12911 wxPyEndAllowThreads(__tstate);
12912 if (PyErr_Occurred()) SWIG_fail;
12913 }
12914 Py_INCREF(Py_None); resultobj = Py_None;
12915 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12916 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12917 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12918 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12919 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12920 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj;
12929 wxImage *arg1 = (wxImage *) 0 ;
12930 byte result;
12931 PyObject * obj0 = 0 ;
12932 char *kwnames[] = {
12933 (char *) "self", NULL
12934 };
12935
12936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12938 if (SWIG_arg_fail(1)) SWIG_fail;
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (byte)(arg1)->GetMaskRed();
12942
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12948 }
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj;
12957 wxImage *arg1 = (wxImage *) 0 ;
12958 byte result;
12959 PyObject * obj0 = 0 ;
12960 char *kwnames[] = {
12961 (char *) "self", NULL
12962 };
12963
12964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12966 if (SWIG_arg_fail(1)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (byte)(arg1)->GetMaskGreen();
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12976 }
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj;
12985 wxImage *arg1 = (wxImage *) 0 ;
12986 byte result;
12987 PyObject * obj0 = 0 ;
12988 char *kwnames[] = {
12989 (char *) "self", NULL
12990 };
12991
12992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 result = (byte)(arg1)->GetMaskBlue();
12998
12999 wxPyEndAllowThreads(__tstate);
13000 if (PyErr_Occurred()) SWIG_fail;
13001 }
13002 {
13003 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13004 }
13005 return resultobj;
13006 fail:
13007 return NULL;
13008 }
13009
13010
13011 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13012 PyObject *resultobj;
13013 wxImage *arg1 = (wxImage *) 0 ;
13014 bool arg2 = (bool) true ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 char *kwnames[] = {
13018 (char *) "self",(char *) "mask", NULL
13019 };
13020
13021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13023 if (SWIG_arg_fail(1)) SWIG_fail;
13024 if (obj1) {
13025 {
13026 arg2 = (bool)(SWIG_As_bool(obj1));
13027 if (SWIG_arg_fail(2)) SWIG_fail;
13028 }
13029 }
13030 {
13031 PyThreadState* __tstate = wxPyBeginAllowThreads();
13032 (arg1)->SetMask(arg2);
13033
13034 wxPyEndAllowThreads(__tstate);
13035 if (PyErr_Occurred()) SWIG_fail;
13036 }
13037 Py_INCREF(Py_None); resultobj = Py_None;
13038 return resultobj;
13039 fail:
13040 return NULL;
13041 }
13042
13043
13044 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13045 PyObject *resultobj;
13046 wxImage *arg1 = (wxImage *) 0 ;
13047 bool result;
13048 PyObject * obj0 = 0 ;
13049 char *kwnames[] = {
13050 (char *) "self", NULL
13051 };
13052
13053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13055 if (SWIG_arg_fail(1)) SWIG_fail;
13056 {
13057 PyThreadState* __tstate = wxPyBeginAllowThreads();
13058 result = (bool)(arg1)->HasMask();
13059
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 {
13064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13065 }
13066 return resultobj;
13067 fail:
13068 return NULL;
13069 }
13070
13071
13072 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13073 PyObject *resultobj;
13074 wxImage *arg1 = (wxImage *) 0 ;
13075 double arg2 ;
13076 wxPoint *arg3 = 0 ;
13077 bool arg4 = (bool) true ;
13078 wxPoint *arg5 = (wxPoint *) NULL ;
13079 SwigValueWrapper<wxImage > result;
13080 wxPoint temp3 ;
13081 PyObject * obj0 = 0 ;
13082 PyObject * obj1 = 0 ;
13083 PyObject * obj2 = 0 ;
13084 PyObject * obj3 = 0 ;
13085 PyObject * obj4 = 0 ;
13086 char *kwnames[] = {
13087 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13088 };
13089
13090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13092 if (SWIG_arg_fail(1)) SWIG_fail;
13093 {
13094 arg2 = (double)(SWIG_As_double(obj1));
13095 if (SWIG_arg_fail(2)) SWIG_fail;
13096 }
13097 {
13098 arg3 = &temp3;
13099 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13100 }
13101 if (obj3) {
13102 {
13103 arg4 = (bool)(SWIG_As_bool(obj3));
13104 if (SWIG_arg_fail(4)) SWIG_fail;
13105 }
13106 }
13107 if (obj4) {
13108 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13109 if (SWIG_arg_fail(5)) SWIG_fail;
13110 }
13111 {
13112 PyThreadState* __tstate = wxPyBeginAllowThreads();
13113 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13114
13115 wxPyEndAllowThreads(__tstate);
13116 if (PyErr_Occurred()) SWIG_fail;
13117 }
13118 {
13119 wxImage * resultptr;
13120 resultptr = new wxImage((wxImage &)(result));
13121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13122 }
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13130 PyObject *resultobj;
13131 wxImage *arg1 = (wxImage *) 0 ;
13132 bool arg2 = (bool) true ;
13133 SwigValueWrapper<wxImage > result;
13134 PyObject * obj0 = 0 ;
13135 PyObject * obj1 = 0 ;
13136 char *kwnames[] = {
13137 (char *) "self",(char *) "clockwise", NULL
13138 };
13139
13140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13142 if (SWIG_arg_fail(1)) SWIG_fail;
13143 if (obj1) {
13144 {
13145 arg2 = (bool)(SWIG_As_bool(obj1));
13146 if (SWIG_arg_fail(2)) SWIG_fail;
13147 }
13148 }
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 result = (arg1)->Rotate90(arg2);
13152
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 {
13157 wxImage * resultptr;
13158 resultptr = new wxImage((wxImage &)(result));
13159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13160 }
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj;
13169 wxImage *arg1 = (wxImage *) 0 ;
13170 bool arg2 = (bool) true ;
13171 SwigValueWrapper<wxImage > result;
13172 PyObject * obj0 = 0 ;
13173 PyObject * obj1 = 0 ;
13174 char *kwnames[] = {
13175 (char *) "self",(char *) "horizontally", NULL
13176 };
13177
13178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13180 if (SWIG_arg_fail(1)) SWIG_fail;
13181 if (obj1) {
13182 {
13183 arg2 = (bool)(SWIG_As_bool(obj1));
13184 if (SWIG_arg_fail(2)) SWIG_fail;
13185 }
13186 }
13187 {
13188 PyThreadState* __tstate = wxPyBeginAllowThreads();
13189 result = (arg1)->Mirror(arg2);
13190
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 {
13195 wxImage * resultptr;
13196 resultptr = new wxImage((wxImage &)(result));
13197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13198 }
13199 return resultobj;
13200 fail:
13201 return NULL;
13202 }
13203
13204
13205 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13206 PyObject *resultobj;
13207 wxImage *arg1 = (wxImage *) 0 ;
13208 byte arg2 ;
13209 byte arg3 ;
13210 byte arg4 ;
13211 byte arg5 ;
13212 byte arg6 ;
13213 byte arg7 ;
13214 PyObject * obj0 = 0 ;
13215 PyObject * obj1 = 0 ;
13216 PyObject * obj2 = 0 ;
13217 PyObject * obj3 = 0 ;
13218 PyObject * obj4 = 0 ;
13219 PyObject * obj5 = 0 ;
13220 PyObject * obj6 = 0 ;
13221 char *kwnames[] = {
13222 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13223 };
13224
13225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13227 if (SWIG_arg_fail(1)) SWIG_fail;
13228 {
13229 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13230 if (SWIG_arg_fail(2)) SWIG_fail;
13231 }
13232 {
13233 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13234 if (SWIG_arg_fail(3)) SWIG_fail;
13235 }
13236 {
13237 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13238 if (SWIG_arg_fail(4)) SWIG_fail;
13239 }
13240 {
13241 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13242 if (SWIG_arg_fail(5)) SWIG_fail;
13243 }
13244 {
13245 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13246 if (SWIG_arg_fail(6)) SWIG_fail;
13247 }
13248 {
13249 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13250 if (SWIG_arg_fail(7)) SWIG_fail;
13251 }
13252 {
13253 PyThreadState* __tstate = wxPyBeginAllowThreads();
13254 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13255
13256 wxPyEndAllowThreads(__tstate);
13257 if (PyErr_Occurred()) SWIG_fail;
13258 }
13259 Py_INCREF(Py_None); resultobj = Py_None;
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj;
13268 wxImage *arg1 = (wxImage *) 0 ;
13269 byte arg2 ;
13270 byte arg3 ;
13271 byte arg4 ;
13272 SwigValueWrapper<wxImage > result;
13273 PyObject * obj0 = 0 ;
13274 PyObject * obj1 = 0 ;
13275 PyObject * obj2 = 0 ;
13276 PyObject * obj3 = 0 ;
13277 char *kwnames[] = {
13278 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13279 };
13280
13281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13283 if (SWIG_arg_fail(1)) SWIG_fail;
13284 {
13285 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13286 if (SWIG_arg_fail(2)) SWIG_fail;
13287 }
13288 {
13289 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13290 if (SWIG_arg_fail(3)) SWIG_fail;
13291 }
13292 {
13293 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13294 if (SWIG_arg_fail(4)) SWIG_fail;
13295 }
13296 {
13297 PyThreadState* __tstate = wxPyBeginAllowThreads();
13298 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13299
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 {
13304 wxImage * resultptr;
13305 resultptr = new wxImage((wxImage &)(result));
13306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13307 }
13308 return resultobj;
13309 fail:
13310 return NULL;
13311 }
13312
13313
13314 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13315 PyObject *resultobj;
13316 wxImage *arg1 = (wxImage *) 0 ;
13317 wxString *arg2 = 0 ;
13318 wxString *arg3 = 0 ;
13319 bool temp2 = false ;
13320 bool temp3 = false ;
13321 PyObject * obj0 = 0 ;
13322 PyObject * obj1 = 0 ;
13323 PyObject * obj2 = 0 ;
13324 char *kwnames[] = {
13325 (char *) "self",(char *) "name",(char *) "value", NULL
13326 };
13327
13328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13330 if (SWIG_arg_fail(1)) SWIG_fail;
13331 {
13332 arg2 = wxString_in_helper(obj1);
13333 if (arg2 == NULL) SWIG_fail;
13334 temp2 = true;
13335 }
13336 {
13337 arg3 = wxString_in_helper(obj2);
13338 if (arg3 == NULL) SWIG_fail;
13339 temp3 = true;
13340 }
13341 {
13342 PyThreadState* __tstate = wxPyBeginAllowThreads();
13343 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13344
13345 wxPyEndAllowThreads(__tstate);
13346 if (PyErr_Occurred()) SWIG_fail;
13347 }
13348 Py_INCREF(Py_None); resultobj = Py_None;
13349 {
13350 if (temp2)
13351 delete arg2;
13352 }
13353 {
13354 if (temp3)
13355 delete arg3;
13356 }
13357 return resultobj;
13358 fail:
13359 {
13360 if (temp2)
13361 delete arg2;
13362 }
13363 {
13364 if (temp3)
13365 delete arg3;
13366 }
13367 return NULL;
13368 }
13369
13370
13371 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj;
13373 wxImage *arg1 = (wxImage *) 0 ;
13374 wxString *arg2 = 0 ;
13375 int arg3 ;
13376 bool temp2 = false ;
13377 PyObject * obj0 = 0 ;
13378 PyObject * obj1 = 0 ;
13379 PyObject * obj2 = 0 ;
13380 char *kwnames[] = {
13381 (char *) "self",(char *) "name",(char *) "value", NULL
13382 };
13383
13384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13386 if (SWIG_arg_fail(1)) SWIG_fail;
13387 {
13388 arg2 = wxString_in_helper(obj1);
13389 if (arg2 == NULL) SWIG_fail;
13390 temp2 = true;
13391 }
13392 {
13393 arg3 = (int)(SWIG_As_int(obj2));
13394 if (SWIG_arg_fail(3)) SWIG_fail;
13395 }
13396 {
13397 PyThreadState* __tstate = wxPyBeginAllowThreads();
13398 (arg1)->SetOption((wxString const &)*arg2,arg3);
13399
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 Py_INCREF(Py_None); resultobj = Py_None;
13404 {
13405 if (temp2)
13406 delete arg2;
13407 }
13408 return resultobj;
13409 fail:
13410 {
13411 if (temp2)
13412 delete arg2;
13413 }
13414 return NULL;
13415 }
13416
13417
13418 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13419 PyObject *resultobj;
13420 wxImage *arg1 = (wxImage *) 0 ;
13421 wxString *arg2 = 0 ;
13422 wxString result;
13423 bool temp2 = false ;
13424 PyObject * obj0 = 0 ;
13425 PyObject * obj1 = 0 ;
13426 char *kwnames[] = {
13427 (char *) "self",(char *) "name", NULL
13428 };
13429
13430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13432 if (SWIG_arg_fail(1)) SWIG_fail;
13433 {
13434 arg2 = wxString_in_helper(obj1);
13435 if (arg2 == NULL) SWIG_fail;
13436 temp2 = true;
13437 }
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13441
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 {
13446 #if wxUSE_UNICODE
13447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13448 #else
13449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13450 #endif
13451 }
13452 {
13453 if (temp2)
13454 delete arg2;
13455 }
13456 return resultobj;
13457 fail:
13458 {
13459 if (temp2)
13460 delete arg2;
13461 }
13462 return NULL;
13463 }
13464
13465
13466 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj;
13468 wxImage *arg1 = (wxImage *) 0 ;
13469 wxString *arg2 = 0 ;
13470 int result;
13471 bool temp2 = false ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 char *kwnames[] = {
13475 (char *) "self",(char *) "name", NULL
13476 };
13477
13478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13480 if (SWIG_arg_fail(1)) SWIG_fail;
13481 {
13482 arg2 = wxString_in_helper(obj1);
13483 if (arg2 == NULL) SWIG_fail;
13484 temp2 = true;
13485 }
13486 {
13487 PyThreadState* __tstate = wxPyBeginAllowThreads();
13488 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13489
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 {
13494 resultobj = SWIG_From_int((int)(result));
13495 }
13496 {
13497 if (temp2)
13498 delete arg2;
13499 }
13500 return resultobj;
13501 fail:
13502 {
13503 if (temp2)
13504 delete arg2;
13505 }
13506 return NULL;
13507 }
13508
13509
13510 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj;
13512 wxImage *arg1 = (wxImage *) 0 ;
13513 wxString *arg2 = 0 ;
13514 bool result;
13515 bool temp2 = false ;
13516 PyObject * obj0 = 0 ;
13517 PyObject * obj1 = 0 ;
13518 char *kwnames[] = {
13519 (char *) "self",(char *) "name", NULL
13520 };
13521
13522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13524 if (SWIG_arg_fail(1)) SWIG_fail;
13525 {
13526 arg2 = wxString_in_helper(obj1);
13527 if (arg2 == NULL) SWIG_fail;
13528 temp2 = true;
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13533
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 {
13538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13539 }
13540 {
13541 if (temp2)
13542 delete arg2;
13543 }
13544 return resultobj;
13545 fail:
13546 {
13547 if (temp2)
13548 delete arg2;
13549 }
13550 return NULL;
13551 }
13552
13553
13554 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj;
13556 wxImage *arg1 = (wxImage *) 0 ;
13557 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13558 unsigned long result;
13559 PyObject * obj0 = 0 ;
13560 PyObject * obj1 = 0 ;
13561 char *kwnames[] = {
13562 (char *) "self",(char *) "stopafter", NULL
13563 };
13564
13565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13567 if (SWIG_arg_fail(1)) SWIG_fail;
13568 if (obj1) {
13569 {
13570 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13571 if (SWIG_arg_fail(2)) SWIG_fail;
13572 }
13573 }
13574 {
13575 PyThreadState* __tstate = wxPyBeginAllowThreads();
13576 result = (unsigned long)(arg1)->CountColours(arg2);
13577
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 {
13582 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13583 }
13584 return resultobj;
13585 fail:
13586 return NULL;
13587 }
13588
13589
13590 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13591 PyObject *resultobj;
13592 wxImage *arg1 = (wxImage *) 0 ;
13593 wxImageHistogram *arg2 = 0 ;
13594 unsigned long result;
13595 PyObject * obj0 = 0 ;
13596 PyObject * obj1 = 0 ;
13597 char *kwnames[] = {
13598 (char *) "self",(char *) "h", NULL
13599 };
13600
13601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13603 if (SWIG_arg_fail(1)) SWIG_fail;
13604 {
13605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13606 if (SWIG_arg_fail(2)) SWIG_fail;
13607 if (arg2 == NULL) {
13608 SWIG_null_ref("wxImageHistogram");
13609 }
13610 if (SWIG_arg_fail(2)) SWIG_fail;
13611 }
13612 {
13613 PyThreadState* __tstate = wxPyBeginAllowThreads();
13614 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13615
13616 wxPyEndAllowThreads(__tstate);
13617 if (PyErr_Occurred()) SWIG_fail;
13618 }
13619 {
13620 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13621 }
13622 return resultobj;
13623 fail:
13624 return NULL;
13625 }
13626
13627
13628 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13629 PyObject *resultobj;
13630 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13631 PyObject * obj0 = 0 ;
13632 char *kwnames[] = {
13633 (char *) "handler", NULL
13634 };
13635
13636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13638 if (SWIG_arg_fail(1)) SWIG_fail;
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 wxImage::AddHandler(arg1);
13642
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 Py_INCREF(Py_None); resultobj = Py_None;
13647 return resultobj;
13648 fail:
13649 return NULL;
13650 }
13651
13652
13653 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj;
13655 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13656 PyObject * obj0 = 0 ;
13657 char *kwnames[] = {
13658 (char *) "handler", NULL
13659 };
13660
13661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13663 if (SWIG_arg_fail(1)) SWIG_fail;
13664 {
13665 PyThreadState* __tstate = wxPyBeginAllowThreads();
13666 wxImage::InsertHandler(arg1);
13667
13668 wxPyEndAllowThreads(__tstate);
13669 if (PyErr_Occurred()) SWIG_fail;
13670 }
13671 Py_INCREF(Py_None); resultobj = Py_None;
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13679 PyObject *resultobj;
13680 wxString *arg1 = 0 ;
13681 bool result;
13682 bool temp1 = false ;
13683 PyObject * obj0 = 0 ;
13684 char *kwnames[] = {
13685 (char *) "name", NULL
13686 };
13687
13688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13689 {
13690 arg1 = wxString_in_helper(obj0);
13691 if (arg1 == NULL) SWIG_fail;
13692 temp1 = true;
13693 }
13694 {
13695 PyThreadState* __tstate = wxPyBeginAllowThreads();
13696 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13697
13698 wxPyEndAllowThreads(__tstate);
13699 if (PyErr_Occurred()) SWIG_fail;
13700 }
13701 {
13702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13703 }
13704 {
13705 if (temp1)
13706 delete arg1;
13707 }
13708 return resultobj;
13709 fail:
13710 {
13711 if (temp1)
13712 delete arg1;
13713 }
13714 return NULL;
13715 }
13716
13717
13718 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj;
13720 wxString result;
13721 char *kwnames[] = {
13722 NULL
13723 };
13724
13725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13726 {
13727 PyThreadState* __tstate = wxPyBeginAllowThreads();
13728 result = wxImage::GetImageExtWildcard();
13729
13730 wxPyEndAllowThreads(__tstate);
13731 if (PyErr_Occurred()) SWIG_fail;
13732 }
13733 {
13734 #if wxUSE_UNICODE
13735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13736 #else
13737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13738 #endif
13739 }
13740 return resultobj;
13741 fail:
13742 return NULL;
13743 }
13744
13745
13746 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13747 PyObject *resultobj;
13748 wxImage *arg1 = (wxImage *) 0 ;
13749 int arg2 = (int) -1 ;
13750 wxBitmap result;
13751 PyObject * obj0 = 0 ;
13752 PyObject * obj1 = 0 ;
13753 char *kwnames[] = {
13754 (char *) "self",(char *) "depth", NULL
13755 };
13756
13757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13759 if (SWIG_arg_fail(1)) SWIG_fail;
13760 if (obj1) {
13761 {
13762 arg2 = (int)(SWIG_As_int(obj1));
13763 if (SWIG_arg_fail(2)) SWIG_fail;
13764 }
13765 }
13766 {
13767 if (!wxPyCheckForApp()) SWIG_fail;
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = wxImage_ConvertToBitmap(arg1,arg2);
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 {
13775 wxBitmap * resultptr;
13776 resultptr = new wxBitmap((wxBitmap &)(result));
13777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13778 }
13779 return resultobj;
13780 fail:
13781 return NULL;
13782 }
13783
13784
13785 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13786 PyObject *resultobj;
13787 wxImage *arg1 = (wxImage *) 0 ;
13788 byte arg2 ;
13789 byte arg3 ;
13790 byte arg4 ;
13791 wxBitmap result;
13792 PyObject * obj0 = 0 ;
13793 PyObject * obj1 = 0 ;
13794 PyObject * obj2 = 0 ;
13795 PyObject * obj3 = 0 ;
13796 char *kwnames[] = {
13797 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13798 };
13799
13800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13802 if (SWIG_arg_fail(1)) SWIG_fail;
13803 {
13804 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13805 if (SWIG_arg_fail(2)) SWIG_fail;
13806 }
13807 {
13808 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13809 if (SWIG_arg_fail(3)) SWIG_fail;
13810 }
13811 {
13812 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13813 if (SWIG_arg_fail(4)) SWIG_fail;
13814 }
13815 {
13816 if (!wxPyCheckForApp()) SWIG_fail;
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13819
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 {
13824 wxBitmap * resultptr;
13825 resultptr = new wxBitmap((wxBitmap &)(result));
13826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13827 }
13828 return resultobj;
13829 fail:
13830 return NULL;
13831 }
13832
13833
13834 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13835 PyObject *obj;
13836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13837 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13838 Py_INCREF(obj);
13839 return Py_BuildValue((char *)"");
13840 }
13841 static int _wrap_NullImage_set(PyObject *) {
13842 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13843 return 1;
13844 }
13845
13846
13847 static PyObject *_wrap_NullImage_get(void) {
13848 PyObject *pyobj;
13849
13850 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13851 return pyobj;
13852 }
13853
13854
13855 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13856 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13857 return 1;
13858 }
13859
13860
13861 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13862 PyObject *pyobj;
13863
13864 {
13865 #if wxUSE_UNICODE
13866 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13867 #else
13868 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13869 #endif
13870 }
13871 return pyobj;
13872 }
13873
13874
13875 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13876 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13877 return 1;
13878 }
13879
13880
13881 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13882 PyObject *pyobj;
13883
13884 {
13885 #if wxUSE_UNICODE
13886 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13887 #else
13888 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13889 #endif
13890 }
13891 return pyobj;
13892 }
13893
13894
13895 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13896 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13897 return 1;
13898 }
13899
13900
13901 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13902 PyObject *pyobj;
13903
13904 {
13905 #if wxUSE_UNICODE
13906 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13907 #else
13908 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13909 #endif
13910 }
13911 return pyobj;
13912 }
13913
13914
13915 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13916 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13917 return 1;
13918 }
13919
13920
13921 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13922 PyObject *pyobj;
13923
13924 {
13925 #if wxUSE_UNICODE
13926 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13927 #else
13928 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13929 #endif
13930 }
13931 return pyobj;
13932 }
13933
13934
13935 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13936 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13937 return 1;
13938 }
13939
13940
13941 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13942 PyObject *pyobj;
13943
13944 {
13945 #if wxUSE_UNICODE
13946 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13947 #else
13948 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13949 #endif
13950 }
13951 return pyobj;
13952 }
13953
13954
13955 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13956 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13957 return 1;
13958 }
13959
13960
13961 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13962 PyObject *pyobj;
13963
13964 {
13965 #if wxUSE_UNICODE
13966 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13967 #else
13968 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13969 #endif
13970 }
13971 return pyobj;
13972 }
13973
13974
13975 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13976 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13977 return 1;
13978 }
13979
13980
13981 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13982 PyObject *pyobj;
13983
13984 {
13985 #if wxUSE_UNICODE
13986 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13987 #else
13988 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13989 #endif
13990 }
13991 return pyobj;
13992 }
13993
13994
13995 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13996 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13997 return 1;
13998 }
13999
14000
14001 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14002 PyObject *pyobj;
14003
14004 {
14005 #if wxUSE_UNICODE
14006 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14007 #else
14008 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14009 #endif
14010 }
14011 return pyobj;
14012 }
14013
14014
14015 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14016 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14017 return 1;
14018 }
14019
14020
14021 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14022 PyObject *pyobj;
14023
14024 {
14025 #if wxUSE_UNICODE
14026 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14027 #else
14028 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14029 #endif
14030 }
14031 return pyobj;
14032 }
14033
14034
14035 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14036 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14037 return 1;
14038 }
14039
14040
14041 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14042 PyObject *pyobj;
14043
14044 {
14045 #if wxUSE_UNICODE
14046 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14047 #else
14048 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14049 #endif
14050 }
14051 return pyobj;
14052 }
14053
14054
14055 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14056 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14057 return 1;
14058 }
14059
14060
14061 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14062 PyObject *pyobj;
14063
14064 {
14065 #if wxUSE_UNICODE
14066 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14067 #else
14068 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14069 #endif
14070 }
14071 return pyobj;
14072 }
14073
14074
14075 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14076 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14077 return 1;
14078 }
14079
14080
14081 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14082 PyObject *pyobj;
14083
14084 {
14085 #if wxUSE_UNICODE
14086 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14087 #else
14088 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14089 #endif
14090 }
14091 return pyobj;
14092 }
14093
14094
14095 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14096 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14097 return 1;
14098 }
14099
14100
14101 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14102 PyObject *pyobj;
14103
14104 {
14105 #if wxUSE_UNICODE
14106 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14107 #else
14108 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14109 #endif
14110 }
14111 return pyobj;
14112 }
14113
14114
14115 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14116 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14117 return 1;
14118 }
14119
14120
14121 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14122 PyObject *pyobj;
14123
14124 {
14125 #if wxUSE_UNICODE
14126 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14127 #else
14128 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14129 #endif
14130 }
14131 return pyobj;
14132 }
14133
14134
14135 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14136 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14137 return 1;
14138 }
14139
14140
14141 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14142 PyObject *pyobj;
14143
14144 {
14145 #if wxUSE_UNICODE
14146 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14147 #else
14148 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14149 #endif
14150 }
14151 return pyobj;
14152 }
14153
14154
14155 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14156 PyObject *resultobj;
14157 wxBMPHandler *result;
14158 char *kwnames[] = {
14159 NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14163 {
14164 PyThreadState* __tstate = wxPyBeginAllowThreads();
14165 result = (wxBMPHandler *)new wxBMPHandler();
14166
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14178 PyObject *obj;
14179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14180 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14181 Py_INCREF(obj);
14182 return Py_BuildValue((char *)"");
14183 }
14184 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxICOHandler *result;
14187 char *kwnames[] = {
14188 NULL
14189 };
14190
14191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = (wxICOHandler *)new wxICOHandler();
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14200 return resultobj;
14201 fail:
14202 return NULL;
14203 }
14204
14205
14206 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14207 PyObject *obj;
14208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14209 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14210 Py_INCREF(obj);
14211 return Py_BuildValue((char *)"");
14212 }
14213 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14214 PyObject *resultobj;
14215 wxCURHandler *result;
14216 char *kwnames[] = {
14217 NULL
14218 };
14219
14220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14221 {
14222 PyThreadState* __tstate = wxPyBeginAllowThreads();
14223 result = (wxCURHandler *)new wxCURHandler();
14224
14225 wxPyEndAllowThreads(__tstate);
14226 if (PyErr_Occurred()) SWIG_fail;
14227 }
14228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14236 PyObject *obj;
14237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14238 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14239 Py_INCREF(obj);
14240 return Py_BuildValue((char *)"");
14241 }
14242 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj;
14244 wxANIHandler *result;
14245 char *kwnames[] = {
14246 NULL
14247 };
14248
14249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14250 {
14251 PyThreadState* __tstate = wxPyBeginAllowThreads();
14252 result = (wxANIHandler *)new wxANIHandler();
14253
14254 wxPyEndAllowThreads(__tstate);
14255 if (PyErr_Occurred()) SWIG_fail;
14256 }
14257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14258 return resultobj;
14259 fail:
14260 return NULL;
14261 }
14262
14263
14264 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14265 PyObject *obj;
14266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14267 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14268 Py_INCREF(obj);
14269 return Py_BuildValue((char *)"");
14270 }
14271 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14272 PyObject *resultobj;
14273 wxPNGHandler *result;
14274 char *kwnames[] = {
14275 NULL
14276 };
14277
14278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14279 {
14280 PyThreadState* __tstate = wxPyBeginAllowThreads();
14281 result = (wxPNGHandler *)new wxPNGHandler();
14282
14283 wxPyEndAllowThreads(__tstate);
14284 if (PyErr_Occurred()) SWIG_fail;
14285 }
14286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14287 return resultobj;
14288 fail:
14289 return NULL;
14290 }
14291
14292
14293 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14294 PyObject *obj;
14295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14296 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14297 Py_INCREF(obj);
14298 return Py_BuildValue((char *)"");
14299 }
14300 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14301 PyObject *resultobj;
14302 wxGIFHandler *result;
14303 char *kwnames[] = {
14304 NULL
14305 };
14306
14307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 result = (wxGIFHandler *)new wxGIFHandler();
14311
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14323 PyObject *obj;
14324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14325 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14326 Py_INCREF(obj);
14327 return Py_BuildValue((char *)"");
14328 }
14329 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14330 PyObject *resultobj;
14331 wxPCXHandler *result;
14332 char *kwnames[] = {
14333 NULL
14334 };
14335
14336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 result = (wxPCXHandler *)new wxPCXHandler();
14340
14341 wxPyEndAllowThreads(__tstate);
14342 if (PyErr_Occurred()) SWIG_fail;
14343 }
14344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14352 PyObject *obj;
14353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14354 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14355 Py_INCREF(obj);
14356 return Py_BuildValue((char *)"");
14357 }
14358 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj;
14360 wxJPEGHandler *result;
14361 char *kwnames[] = {
14362 NULL
14363 };
14364
14365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = (wxJPEGHandler *)new wxJPEGHandler();
14369
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14381 PyObject *obj;
14382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14383 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14384 Py_INCREF(obj);
14385 return Py_BuildValue((char *)"");
14386 }
14387 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj;
14389 wxPNMHandler *result;
14390 char *kwnames[] = {
14391 NULL
14392 };
14393
14394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (wxPNMHandler *)new wxPNMHandler();
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14410 PyObject *obj;
14411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14412 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14413 Py_INCREF(obj);
14414 return Py_BuildValue((char *)"");
14415 }
14416 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj;
14418 wxXPMHandler *result;
14419 char *kwnames[] = {
14420 NULL
14421 };
14422
14423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (wxXPMHandler *)new wxXPMHandler();
14427
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14439 PyObject *obj;
14440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14441 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14442 Py_INCREF(obj);
14443 return Py_BuildValue((char *)"");
14444 }
14445 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj;
14447 wxTIFFHandler *result;
14448 char *kwnames[] = {
14449 NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14453 {
14454 PyThreadState* __tstate = wxPyBeginAllowThreads();
14455 result = (wxTIFFHandler *)new wxTIFFHandler();
14456
14457 wxPyEndAllowThreads(__tstate);
14458 if (PyErr_Occurred()) SWIG_fail;
14459 }
14460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14461 return resultobj;
14462 fail:
14463 return NULL;
14464 }
14465
14466
14467 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14468 PyObject *obj;
14469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14470 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14471 Py_INCREF(obj);
14472 return Py_BuildValue((char *)"");
14473 }
14474 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj;
14476 wxImage *arg1 = 0 ;
14477 wxImage *arg2 = 0 ;
14478 int arg3 = (int) 236 ;
14479 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14480 bool result;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 PyObject * obj2 = 0 ;
14484 PyObject * obj3 = 0 ;
14485 char *kwnames[] = {
14486 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14487 };
14488
14489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14490 {
14491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14492 if (SWIG_arg_fail(1)) SWIG_fail;
14493 if (arg1 == NULL) {
14494 SWIG_null_ref("wxImage");
14495 }
14496 if (SWIG_arg_fail(1)) SWIG_fail;
14497 }
14498 {
14499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14500 if (SWIG_arg_fail(2)) SWIG_fail;
14501 if (arg2 == NULL) {
14502 SWIG_null_ref("wxImage");
14503 }
14504 if (SWIG_arg_fail(2)) SWIG_fail;
14505 }
14506 if (obj2) {
14507 {
14508 arg3 = (int)(SWIG_As_int(obj2));
14509 if (SWIG_arg_fail(3)) SWIG_fail;
14510 }
14511 }
14512 if (obj3) {
14513 {
14514 arg4 = (int)(SWIG_As_int(obj3));
14515 if (SWIG_arg_fail(4)) SWIG_fail;
14516 }
14517 }
14518 {
14519 PyThreadState* __tstate = wxPyBeginAllowThreads();
14520 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14521
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 {
14526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14527 }
14528 return resultobj;
14529 fail:
14530 return NULL;
14531 }
14532
14533
14534 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14535 PyObject *obj;
14536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14537 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14538 Py_INCREF(obj);
14539 return Py_BuildValue((char *)"");
14540 }
14541 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14542 PyObject *resultobj;
14543 wxEvtHandler *result;
14544 char *kwnames[] = {
14545 NULL
14546 };
14547
14548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14549 {
14550 PyThreadState* __tstate = wxPyBeginAllowThreads();
14551 result = (wxEvtHandler *)new wxEvtHandler();
14552
14553 wxPyEndAllowThreads(__tstate);
14554 if (PyErr_Occurred()) SWIG_fail;
14555 }
14556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14557 return resultobj;
14558 fail:
14559 return NULL;
14560 }
14561
14562
14563 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14564 PyObject *resultobj;
14565 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14566 wxEvtHandler *result;
14567 PyObject * obj0 = 0 ;
14568 char *kwnames[] = {
14569 (char *) "self", NULL
14570 };
14571
14572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14574 if (SWIG_arg_fail(1)) SWIG_fail;
14575 {
14576 PyThreadState* __tstate = wxPyBeginAllowThreads();
14577 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14578
14579 wxPyEndAllowThreads(__tstate);
14580 if (PyErr_Occurred()) SWIG_fail;
14581 }
14582 {
14583 resultobj = wxPyMake_wxObject(result, 0);
14584 }
14585 return resultobj;
14586 fail:
14587 return NULL;
14588 }
14589
14590
14591 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14592 PyObject *resultobj;
14593 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14594 wxEvtHandler *result;
14595 PyObject * obj0 = 0 ;
14596 char *kwnames[] = {
14597 (char *) "self", NULL
14598 };
14599
14600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14602 if (SWIG_arg_fail(1)) SWIG_fail;
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14606
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 {
14611 resultobj = wxPyMake_wxObject(result, 0);
14612 }
14613 return resultobj;
14614 fail:
14615 return NULL;
14616 }
14617
14618
14619 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj;
14621 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14622 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14623 PyObject * obj0 = 0 ;
14624 PyObject * obj1 = 0 ;
14625 char *kwnames[] = {
14626 (char *) "self",(char *) "handler", NULL
14627 };
14628
14629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14631 if (SWIG_arg_fail(1)) SWIG_fail;
14632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14633 if (SWIG_arg_fail(2)) SWIG_fail;
14634 {
14635 PyThreadState* __tstate = wxPyBeginAllowThreads();
14636 (arg1)->SetNextHandler(arg2);
14637
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 Py_INCREF(Py_None); resultobj = Py_None;
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14649 PyObject *resultobj;
14650 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14651 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14652 PyObject * obj0 = 0 ;
14653 PyObject * obj1 = 0 ;
14654 char *kwnames[] = {
14655 (char *) "self",(char *) "handler", NULL
14656 };
14657
14658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14660 if (SWIG_arg_fail(1)) SWIG_fail;
14661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14662 if (SWIG_arg_fail(2)) SWIG_fail;
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 (arg1)->SetPreviousHandler(arg2);
14666
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 Py_INCREF(Py_None); resultobj = Py_None;
14671 return resultobj;
14672 fail:
14673 return NULL;
14674 }
14675
14676
14677 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14678 PyObject *resultobj;
14679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14680 bool result;
14681 PyObject * obj0 = 0 ;
14682 char *kwnames[] = {
14683 (char *) "self", NULL
14684 };
14685
14686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14688 if (SWIG_arg_fail(1)) SWIG_fail;
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 result = (bool)(arg1)->GetEvtHandlerEnabled();
14692
14693 wxPyEndAllowThreads(__tstate);
14694 if (PyErr_Occurred()) SWIG_fail;
14695 }
14696 {
14697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14698 }
14699 return resultobj;
14700 fail:
14701 return NULL;
14702 }
14703
14704
14705 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14706 PyObject *resultobj;
14707 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14708 bool arg2 ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 char *kwnames[] = {
14712 (char *) "self",(char *) "enabled", NULL
14713 };
14714
14715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14717 if (SWIG_arg_fail(1)) SWIG_fail;
14718 {
14719 arg2 = (bool)(SWIG_As_bool(obj1));
14720 if (SWIG_arg_fail(2)) SWIG_fail;
14721 }
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 (arg1)->SetEvtHandlerEnabled(arg2);
14725
14726 wxPyEndAllowThreads(__tstate);
14727 if (PyErr_Occurred()) SWIG_fail;
14728 }
14729 Py_INCREF(Py_None); resultobj = Py_None;
14730 return resultobj;
14731 fail:
14732 return NULL;
14733 }
14734
14735
14736 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14737 PyObject *resultobj;
14738 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14739 wxEvent *arg2 = 0 ;
14740 bool result;
14741 PyObject * obj0 = 0 ;
14742 PyObject * obj1 = 0 ;
14743 char *kwnames[] = {
14744 (char *) "self",(char *) "event", NULL
14745 };
14746
14747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14749 if (SWIG_arg_fail(1)) SWIG_fail;
14750 {
14751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14752 if (SWIG_arg_fail(2)) SWIG_fail;
14753 if (arg2 == NULL) {
14754 SWIG_null_ref("wxEvent");
14755 }
14756 if (SWIG_arg_fail(2)) SWIG_fail;
14757 }
14758 {
14759 PyThreadState* __tstate = wxPyBeginAllowThreads();
14760 result = (bool)(arg1)->ProcessEvent(*arg2);
14761
14762 wxPyEndAllowThreads(__tstate);
14763 if (PyErr_Occurred()) SWIG_fail;
14764 }
14765 {
14766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14767 }
14768 return resultobj;
14769 fail:
14770 return NULL;
14771 }
14772
14773
14774 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14775 PyObject *resultobj;
14776 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14777 wxEvent *arg2 = 0 ;
14778 PyObject * obj0 = 0 ;
14779 PyObject * obj1 = 0 ;
14780 char *kwnames[] = {
14781 (char *) "self",(char *) "event", NULL
14782 };
14783
14784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14786 if (SWIG_arg_fail(1)) SWIG_fail;
14787 {
14788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14789 if (SWIG_arg_fail(2)) SWIG_fail;
14790 if (arg2 == NULL) {
14791 SWIG_null_ref("wxEvent");
14792 }
14793 if (SWIG_arg_fail(2)) SWIG_fail;
14794 }
14795 {
14796 PyThreadState* __tstate = wxPyBeginAllowThreads();
14797 (arg1)->AddPendingEvent(*arg2);
14798
14799 wxPyEndAllowThreads(__tstate);
14800 if (PyErr_Occurred()) SWIG_fail;
14801 }
14802 Py_INCREF(Py_None); resultobj = Py_None;
14803 return resultobj;
14804 fail:
14805 return NULL;
14806 }
14807
14808
14809 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14810 PyObject *resultobj;
14811 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14812 PyObject * obj0 = 0 ;
14813 char *kwnames[] = {
14814 (char *) "self", NULL
14815 };
14816
14817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14819 if (SWIG_arg_fail(1)) SWIG_fail;
14820 {
14821 PyThreadState* __tstate = wxPyBeginAllowThreads();
14822 (arg1)->ProcessPendingEvents();
14823
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 Py_INCREF(Py_None); resultobj = Py_None;
14828 return resultobj;
14829 fail:
14830 return NULL;
14831 }
14832
14833
14834 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14835 PyObject *resultobj;
14836 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14837 int arg2 ;
14838 int arg3 ;
14839 int arg4 ;
14840 PyObject *arg5 = (PyObject *) 0 ;
14841 PyObject * obj0 = 0 ;
14842 PyObject * obj1 = 0 ;
14843 PyObject * obj2 = 0 ;
14844 PyObject * obj3 = 0 ;
14845 PyObject * obj4 = 0 ;
14846 char *kwnames[] = {
14847 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14848 };
14849
14850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14852 if (SWIG_arg_fail(1)) SWIG_fail;
14853 {
14854 arg2 = (int)(SWIG_As_int(obj1));
14855 if (SWIG_arg_fail(2)) SWIG_fail;
14856 }
14857 {
14858 arg3 = (int)(SWIG_As_int(obj2));
14859 if (SWIG_arg_fail(3)) SWIG_fail;
14860 }
14861 {
14862 arg4 = (int)(SWIG_As_int(obj3));
14863 if (SWIG_arg_fail(4)) SWIG_fail;
14864 }
14865 arg5 = obj4;
14866 {
14867 PyThreadState* __tstate = wxPyBeginAllowThreads();
14868 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14869
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 Py_INCREF(Py_None); resultobj = Py_None;
14874 return resultobj;
14875 fail:
14876 return NULL;
14877 }
14878
14879
14880 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14881 PyObject *resultobj;
14882 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14883 int arg2 ;
14884 int arg3 = (int) -1 ;
14885 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14886 bool result;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 PyObject * obj2 = 0 ;
14890 PyObject * obj3 = 0 ;
14891 char *kwnames[] = {
14892 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14893 };
14894
14895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14897 if (SWIG_arg_fail(1)) SWIG_fail;
14898 {
14899 arg2 = (int)(SWIG_As_int(obj1));
14900 if (SWIG_arg_fail(2)) SWIG_fail;
14901 }
14902 if (obj2) {
14903 {
14904 arg3 = (int)(SWIG_As_int(obj2));
14905 if (SWIG_arg_fail(3)) SWIG_fail;
14906 }
14907 }
14908 if (obj3) {
14909 {
14910 arg4 = (wxEventType)(SWIG_As_int(obj3));
14911 if (SWIG_arg_fail(4)) SWIG_fail;
14912 }
14913 }
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 {
14922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14923 }
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14931 PyObject *resultobj;
14932 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14933 PyObject *arg2 = (PyObject *) 0 ;
14934 bool arg3 = (bool) true ;
14935 PyObject * obj0 = 0 ;
14936 PyObject * obj1 = 0 ;
14937 PyObject * obj2 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self",(char *) "_self",(char *) "incref", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 arg2 = obj1;
14946 if (obj2) {
14947 {
14948 arg3 = (bool)(SWIG_As_bool(obj2));
14949 if (SWIG_arg_fail(3)) SWIG_fail;
14950 }
14951 }
14952 {
14953 PyThreadState* __tstate = wxPyBeginAllowThreads();
14954 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14955
14956 wxPyEndAllowThreads(__tstate);
14957 if (PyErr_Occurred()) SWIG_fail;
14958 }
14959 Py_INCREF(Py_None); resultobj = Py_None;
14960 return resultobj;
14961 fail:
14962 return NULL;
14963 }
14964
14965
14966 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14967 PyObject *obj;
14968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14969 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14970 Py_INCREF(obj);
14971 return Py_BuildValue((char *)"");
14972 }
14973 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14974 PyObject *resultobj;
14975 wxEventType result;
14976 char *kwnames[] = {
14977 NULL
14978 };
14979
14980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (wxEventType)wxNewEventType();
14984
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 {
14989 resultobj = SWIG_From_int((int)(result));
14990 }
14991 return resultobj;
14992 fail:
14993 return NULL;
14994 }
14995
14996
14997 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj;
14999 wxEvent *arg1 = (wxEvent *) 0 ;
15000 PyObject * obj0 = 0 ;
15001 char *kwnames[] = {
15002 (char *) "self", NULL
15003 };
15004
15005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15007 if (SWIG_arg_fail(1)) SWIG_fail;
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 delete arg1;
15011
15012 wxPyEndAllowThreads(__tstate);
15013 if (PyErr_Occurred()) SWIG_fail;
15014 }
15015 Py_INCREF(Py_None); resultobj = Py_None;
15016 return resultobj;
15017 fail:
15018 return NULL;
15019 }
15020
15021
15022 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj;
15024 wxEvent *arg1 = (wxEvent *) 0 ;
15025 wxEventType arg2 ;
15026 PyObject * obj0 = 0 ;
15027 PyObject * obj1 = 0 ;
15028 char *kwnames[] = {
15029 (char *) "self",(char *) "typ", NULL
15030 };
15031
15032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15034 if (SWIG_arg_fail(1)) SWIG_fail;
15035 {
15036 arg2 = (wxEventType)(SWIG_As_int(obj1));
15037 if (SWIG_arg_fail(2)) SWIG_fail;
15038 }
15039 {
15040 PyThreadState* __tstate = wxPyBeginAllowThreads();
15041 (arg1)->SetEventType(arg2);
15042
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 Py_INCREF(Py_None); resultobj = Py_None;
15047 return resultobj;
15048 fail:
15049 return NULL;
15050 }
15051
15052
15053 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15054 PyObject *resultobj;
15055 wxEvent *arg1 = (wxEvent *) 0 ;
15056 wxEventType result;
15057 PyObject * obj0 = 0 ;
15058 char *kwnames[] = {
15059 (char *) "self", NULL
15060 };
15061
15062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15064 if (SWIG_arg_fail(1)) SWIG_fail;
15065 {
15066 PyThreadState* __tstate = wxPyBeginAllowThreads();
15067 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15068
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 {
15073 resultobj = SWIG_From_int((int)(result));
15074 }
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15082 PyObject *resultobj;
15083 wxEvent *arg1 = (wxEvent *) 0 ;
15084 wxObject *result;
15085 PyObject * obj0 = 0 ;
15086 char *kwnames[] = {
15087 (char *) "self", NULL
15088 };
15089
15090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(1)) SWIG_fail;
15093 {
15094 PyThreadState* __tstate = wxPyBeginAllowThreads();
15095 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15096
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 {
15101 resultobj = wxPyMake_wxObject(result, 0);
15102 }
15103 return resultobj;
15104 fail:
15105 return NULL;
15106 }
15107
15108
15109 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj;
15111 wxEvent *arg1 = (wxEvent *) 0 ;
15112 wxObject *arg2 = (wxObject *) 0 ;
15113 PyObject * obj0 = 0 ;
15114 PyObject * obj1 = 0 ;
15115 char *kwnames[] = {
15116 (char *) "self",(char *) "obj", NULL
15117 };
15118
15119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15121 if (SWIG_arg_fail(1)) SWIG_fail;
15122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15123 if (SWIG_arg_fail(2)) SWIG_fail;
15124 {
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 (arg1)->SetEventObject(arg2);
15127
15128 wxPyEndAllowThreads(__tstate);
15129 if (PyErr_Occurred()) SWIG_fail;
15130 }
15131 Py_INCREF(Py_None); resultobj = Py_None;
15132 return resultobj;
15133 fail:
15134 return NULL;
15135 }
15136
15137
15138 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15139 PyObject *resultobj;
15140 wxEvent *arg1 = (wxEvent *) 0 ;
15141 long result;
15142 PyObject * obj0 = 0 ;
15143 char *kwnames[] = {
15144 (char *) "self", NULL
15145 };
15146
15147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15149 if (SWIG_arg_fail(1)) SWIG_fail;
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15153
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 {
15158 resultobj = SWIG_From_long((long)(result));
15159 }
15160 return resultobj;
15161 fail:
15162 return NULL;
15163 }
15164
15165
15166 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15167 PyObject *resultobj;
15168 wxEvent *arg1 = (wxEvent *) 0 ;
15169 long arg2 = (long) 0 ;
15170 PyObject * obj0 = 0 ;
15171 PyObject * obj1 = 0 ;
15172 char *kwnames[] = {
15173 (char *) "self",(char *) "ts", NULL
15174 };
15175
15176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15178 if (SWIG_arg_fail(1)) SWIG_fail;
15179 if (obj1) {
15180 {
15181 arg2 = (long)(SWIG_As_long(obj1));
15182 if (SWIG_arg_fail(2)) SWIG_fail;
15183 }
15184 }
15185 {
15186 PyThreadState* __tstate = wxPyBeginAllowThreads();
15187 (arg1)->SetTimestamp(arg2);
15188
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 Py_INCREF(Py_None); resultobj = Py_None;
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15200 PyObject *resultobj;
15201 wxEvent *arg1 = (wxEvent *) 0 ;
15202 int result;
15203 PyObject * obj0 = 0 ;
15204 char *kwnames[] = {
15205 (char *) "self", NULL
15206 };
15207
15208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15210 if (SWIG_arg_fail(1)) SWIG_fail;
15211 {
15212 PyThreadState* __tstate = wxPyBeginAllowThreads();
15213 result = (int)((wxEvent const *)arg1)->GetId();
15214
15215 wxPyEndAllowThreads(__tstate);
15216 if (PyErr_Occurred()) SWIG_fail;
15217 }
15218 {
15219 resultobj = SWIG_From_int((int)(result));
15220 }
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15228 PyObject *resultobj;
15229 wxEvent *arg1 = (wxEvent *) 0 ;
15230 int arg2 ;
15231 PyObject * obj0 = 0 ;
15232 PyObject * obj1 = 0 ;
15233 char *kwnames[] = {
15234 (char *) "self",(char *) "Id", NULL
15235 };
15236
15237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15239 if (SWIG_arg_fail(1)) SWIG_fail;
15240 {
15241 arg2 = (int)(SWIG_As_int(obj1));
15242 if (SWIG_arg_fail(2)) SWIG_fail;
15243 }
15244 {
15245 PyThreadState* __tstate = wxPyBeginAllowThreads();
15246 (arg1)->SetId(arg2);
15247
15248 wxPyEndAllowThreads(__tstate);
15249 if (PyErr_Occurred()) SWIG_fail;
15250 }
15251 Py_INCREF(Py_None); resultobj = Py_None;
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj;
15260 wxEvent *arg1 = (wxEvent *) 0 ;
15261 bool result;
15262 PyObject * obj0 = 0 ;
15263 char *kwnames[] = {
15264 (char *) "self", NULL
15265 };
15266
15267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15269 if (SWIG_arg_fail(1)) SWIG_fail;
15270 {
15271 PyThreadState* __tstate = wxPyBeginAllowThreads();
15272 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15273
15274 wxPyEndAllowThreads(__tstate);
15275 if (PyErr_Occurred()) SWIG_fail;
15276 }
15277 {
15278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15279 }
15280 return resultobj;
15281 fail:
15282 return NULL;
15283 }
15284
15285
15286 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15287 PyObject *resultobj;
15288 wxEvent *arg1 = (wxEvent *) 0 ;
15289 bool arg2 = (bool) true ;
15290 PyObject * obj0 = 0 ;
15291 PyObject * obj1 = 0 ;
15292 char *kwnames[] = {
15293 (char *) "self",(char *) "skip", NULL
15294 };
15295
15296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15298 if (SWIG_arg_fail(1)) SWIG_fail;
15299 if (obj1) {
15300 {
15301 arg2 = (bool)(SWIG_As_bool(obj1));
15302 if (SWIG_arg_fail(2)) SWIG_fail;
15303 }
15304 }
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 (arg1)->Skip(arg2);
15308
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 Py_INCREF(Py_None); resultobj = Py_None;
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15320 PyObject *resultobj;
15321 wxEvent *arg1 = (wxEvent *) 0 ;
15322 bool result;
15323 PyObject * obj0 = 0 ;
15324 char *kwnames[] = {
15325 (char *) "self", NULL
15326 };
15327
15328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15330 if (SWIG_arg_fail(1)) SWIG_fail;
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15334
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 {
15339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15340 }
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15348 PyObject *resultobj;
15349 wxEvent *arg1 = (wxEvent *) 0 ;
15350 bool result;
15351 PyObject * obj0 = 0 ;
15352 char *kwnames[] = {
15353 (char *) "self", NULL
15354 };
15355
15356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15358 if (SWIG_arg_fail(1)) SWIG_fail;
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15362
15363 wxPyEndAllowThreads(__tstate);
15364 if (PyErr_Occurred()) SWIG_fail;
15365 }
15366 {
15367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15368 }
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15376 PyObject *resultobj;
15377 wxEvent *arg1 = (wxEvent *) 0 ;
15378 int result;
15379 PyObject * obj0 = 0 ;
15380 char *kwnames[] = {
15381 (char *) "self", NULL
15382 };
15383
15384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15386 if (SWIG_arg_fail(1)) SWIG_fail;
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 result = (int)(arg1)->StopPropagation();
15390
15391 wxPyEndAllowThreads(__tstate);
15392 if (PyErr_Occurred()) SWIG_fail;
15393 }
15394 {
15395 resultobj = SWIG_From_int((int)(result));
15396 }
15397 return resultobj;
15398 fail:
15399 return NULL;
15400 }
15401
15402
15403 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15404 PyObject *resultobj;
15405 wxEvent *arg1 = (wxEvent *) 0 ;
15406 int arg2 ;
15407 PyObject * obj0 = 0 ;
15408 PyObject * obj1 = 0 ;
15409 char *kwnames[] = {
15410 (char *) "self",(char *) "propagationLevel", NULL
15411 };
15412
15413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15415 if (SWIG_arg_fail(1)) SWIG_fail;
15416 {
15417 arg2 = (int)(SWIG_As_int(obj1));
15418 if (SWIG_arg_fail(2)) SWIG_fail;
15419 }
15420 {
15421 PyThreadState* __tstate = wxPyBeginAllowThreads();
15422 (arg1)->ResumePropagation(arg2);
15423
15424 wxPyEndAllowThreads(__tstate);
15425 if (PyErr_Occurred()) SWIG_fail;
15426 }
15427 Py_INCREF(Py_None); resultobj = Py_None;
15428 return resultobj;
15429 fail:
15430 return NULL;
15431 }
15432
15433
15434 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15435 PyObject *resultobj;
15436 wxEvent *arg1 = (wxEvent *) 0 ;
15437 wxEvent *result;
15438 PyObject * obj0 = 0 ;
15439 char *kwnames[] = {
15440 (char *) "self", NULL
15441 };
15442
15443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15445 if (SWIG_arg_fail(1)) SWIG_fail;
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 result = (wxEvent *)(arg1)->Clone();
15449
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15461 PyObject *obj;
15462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15463 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15464 Py_INCREF(obj);
15465 return Py_BuildValue((char *)"");
15466 }
15467 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15468 PyObject *resultobj;
15469 wxEvent *arg1 = 0 ;
15470 wxPropagationDisabler *result;
15471 PyObject * obj0 = 0 ;
15472 char *kwnames[] = {
15473 (char *) "event", NULL
15474 };
15475
15476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15477 {
15478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15479 if (SWIG_arg_fail(1)) SWIG_fail;
15480 if (arg1 == NULL) {
15481 SWIG_null_ref("wxEvent");
15482 }
15483 if (SWIG_arg_fail(1)) SWIG_fail;
15484 }
15485 {
15486 PyThreadState* __tstate = wxPyBeginAllowThreads();
15487 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15488
15489 wxPyEndAllowThreads(__tstate);
15490 if (PyErr_Occurred()) SWIG_fail;
15491 }
15492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15493 return resultobj;
15494 fail:
15495 return NULL;
15496 }
15497
15498
15499 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15500 PyObject *resultobj;
15501 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15502 PyObject * obj0 = 0 ;
15503 char *kwnames[] = {
15504 (char *) "self", NULL
15505 };
15506
15507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15509 if (SWIG_arg_fail(1)) SWIG_fail;
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 delete arg1;
15513
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 Py_INCREF(Py_None); resultobj = Py_None;
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15525 PyObject *obj;
15526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15527 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15528 Py_INCREF(obj);
15529 return Py_BuildValue((char *)"");
15530 }
15531 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15532 PyObject *resultobj;
15533 wxEvent *arg1 = 0 ;
15534 wxPropagateOnce *result;
15535 PyObject * obj0 = 0 ;
15536 char *kwnames[] = {
15537 (char *) "event", NULL
15538 };
15539
15540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15541 {
15542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15543 if (SWIG_arg_fail(1)) SWIG_fail;
15544 if (arg1 == NULL) {
15545 SWIG_null_ref("wxEvent");
15546 }
15547 if (SWIG_arg_fail(1)) SWIG_fail;
15548 }
15549 {
15550 PyThreadState* __tstate = wxPyBeginAllowThreads();
15551 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15552
15553 wxPyEndAllowThreads(__tstate);
15554 if (PyErr_Occurred()) SWIG_fail;
15555 }
15556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15557 return resultobj;
15558 fail:
15559 return NULL;
15560 }
15561
15562
15563 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15564 PyObject *resultobj;
15565 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15566 PyObject * obj0 = 0 ;
15567 char *kwnames[] = {
15568 (char *) "self", NULL
15569 };
15570
15571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15573 if (SWIG_arg_fail(1)) SWIG_fail;
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 delete arg1;
15577
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 Py_INCREF(Py_None); resultobj = Py_None;
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15589 PyObject *obj;
15590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15591 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15592 Py_INCREF(obj);
15593 return Py_BuildValue((char *)"");
15594 }
15595 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15596 PyObject *resultobj;
15597 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15598 int arg2 = (int) 0 ;
15599 wxCommandEvent *result;
15600 PyObject * obj0 = 0 ;
15601 PyObject * obj1 = 0 ;
15602 char *kwnames[] = {
15603 (char *) "commandType",(char *) "winid", NULL
15604 };
15605
15606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15607 if (obj0) {
15608 {
15609 arg1 = (wxEventType)(SWIG_As_int(obj0));
15610 if (SWIG_arg_fail(1)) SWIG_fail;
15611 }
15612 }
15613 if (obj1) {
15614 {
15615 arg2 = (int)(SWIG_As_int(obj1));
15616 if (SWIG_arg_fail(2)) SWIG_fail;
15617 }
15618 }
15619 {
15620 PyThreadState* __tstate = wxPyBeginAllowThreads();
15621 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15622
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15627 return resultobj;
15628 fail:
15629 return NULL;
15630 }
15631
15632
15633 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15634 PyObject *resultobj;
15635 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15636 int result;
15637 PyObject * obj0 = 0 ;
15638 char *kwnames[] = {
15639 (char *) "self", NULL
15640 };
15641
15642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15644 if (SWIG_arg_fail(1)) SWIG_fail;
15645 {
15646 PyThreadState* __tstate = wxPyBeginAllowThreads();
15647 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15648
15649 wxPyEndAllowThreads(__tstate);
15650 if (PyErr_Occurred()) SWIG_fail;
15651 }
15652 {
15653 resultobj = SWIG_From_int((int)(result));
15654 }
15655 return resultobj;
15656 fail:
15657 return NULL;
15658 }
15659
15660
15661 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15662 PyObject *resultobj;
15663 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15664 wxString *arg2 = 0 ;
15665 bool temp2 = false ;
15666 PyObject * obj0 = 0 ;
15667 PyObject * obj1 = 0 ;
15668 char *kwnames[] = {
15669 (char *) "self",(char *) "s", NULL
15670 };
15671
15672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15674 if (SWIG_arg_fail(1)) SWIG_fail;
15675 {
15676 arg2 = wxString_in_helper(obj1);
15677 if (arg2 == NULL) SWIG_fail;
15678 temp2 = true;
15679 }
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 (arg1)->SetString((wxString const &)*arg2);
15683
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 Py_INCREF(Py_None); resultobj = Py_None;
15688 {
15689 if (temp2)
15690 delete arg2;
15691 }
15692 return resultobj;
15693 fail:
15694 {
15695 if (temp2)
15696 delete arg2;
15697 }
15698 return NULL;
15699 }
15700
15701
15702 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15703 PyObject *resultobj;
15704 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15705 wxString result;
15706 PyObject * obj0 = 0 ;
15707 char *kwnames[] = {
15708 (char *) "self", NULL
15709 };
15710
15711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15713 if (SWIG_arg_fail(1)) SWIG_fail;
15714 {
15715 PyThreadState* __tstate = wxPyBeginAllowThreads();
15716 result = ((wxCommandEvent const *)arg1)->GetString();
15717
15718 wxPyEndAllowThreads(__tstate);
15719 if (PyErr_Occurred()) SWIG_fail;
15720 }
15721 {
15722 #if wxUSE_UNICODE
15723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15724 #else
15725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15726 #endif
15727 }
15728 return resultobj;
15729 fail:
15730 return NULL;
15731 }
15732
15733
15734 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15735 PyObject *resultobj;
15736 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15737 bool result;
15738 PyObject * obj0 = 0 ;
15739 char *kwnames[] = {
15740 (char *) "self", NULL
15741 };
15742
15743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15745 if (SWIG_arg_fail(1)) SWIG_fail;
15746 {
15747 PyThreadState* __tstate = wxPyBeginAllowThreads();
15748 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15749
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 {
15754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15755 }
15756 return resultobj;
15757 fail:
15758 return NULL;
15759 }
15760
15761
15762 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15763 PyObject *resultobj;
15764 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15765 bool result;
15766 PyObject * obj0 = 0 ;
15767 char *kwnames[] = {
15768 (char *) "self", NULL
15769 };
15770
15771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15773 if (SWIG_arg_fail(1)) SWIG_fail;
15774 {
15775 PyThreadState* __tstate = wxPyBeginAllowThreads();
15776 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15777
15778 wxPyEndAllowThreads(__tstate);
15779 if (PyErr_Occurred()) SWIG_fail;
15780 }
15781 {
15782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15783 }
15784 return resultobj;
15785 fail:
15786 return NULL;
15787 }
15788
15789
15790 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15791 PyObject *resultobj;
15792 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15793 long arg2 ;
15794 PyObject * obj0 = 0 ;
15795 PyObject * obj1 = 0 ;
15796 char *kwnames[] = {
15797 (char *) "self",(char *) "extraLong", NULL
15798 };
15799
15800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15802 if (SWIG_arg_fail(1)) SWIG_fail;
15803 {
15804 arg2 = (long)(SWIG_As_long(obj1));
15805 if (SWIG_arg_fail(2)) SWIG_fail;
15806 }
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 (arg1)->SetExtraLong(arg2);
15810
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 Py_INCREF(Py_None); resultobj = Py_None;
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15822 PyObject *resultobj;
15823 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15824 long result;
15825 PyObject * obj0 = 0 ;
15826 char *kwnames[] = {
15827 (char *) "self", NULL
15828 };
15829
15830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15832 if (SWIG_arg_fail(1)) SWIG_fail;
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15836
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 {
15841 resultobj = SWIG_From_long((long)(result));
15842 }
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15850 PyObject *resultobj;
15851 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15852 int arg2 ;
15853 PyObject * obj0 = 0 ;
15854 PyObject * obj1 = 0 ;
15855 char *kwnames[] = {
15856 (char *) "self",(char *) "i", NULL
15857 };
15858
15859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15861 if (SWIG_arg_fail(1)) SWIG_fail;
15862 {
15863 arg2 = (int)(SWIG_As_int(obj1));
15864 if (SWIG_arg_fail(2)) SWIG_fail;
15865 }
15866 {
15867 PyThreadState* __tstate = wxPyBeginAllowThreads();
15868 (arg1)->SetInt(arg2);
15869
15870 wxPyEndAllowThreads(__tstate);
15871 if (PyErr_Occurred()) SWIG_fail;
15872 }
15873 Py_INCREF(Py_None); resultobj = Py_None;
15874 return resultobj;
15875 fail:
15876 return NULL;
15877 }
15878
15879
15880 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15881 PyObject *resultobj;
15882 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15883 long result;
15884 PyObject * obj0 = 0 ;
15885 char *kwnames[] = {
15886 (char *) "self", NULL
15887 };
15888
15889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15891 if (SWIG_arg_fail(1)) SWIG_fail;
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15895
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 {
15900 resultobj = SWIG_From_long((long)(result));
15901 }
15902 return resultobj;
15903 fail:
15904 return NULL;
15905 }
15906
15907
15908 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15909 PyObject *resultobj;
15910 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15911 wxEvent *result;
15912 PyObject * obj0 = 0 ;
15913 char *kwnames[] = {
15914 (char *) "self", NULL
15915 };
15916
15917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15919 if (SWIG_arg_fail(1)) SWIG_fail;
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15923
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15935 PyObject *obj;
15936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15937 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15938 Py_INCREF(obj);
15939 return Py_BuildValue((char *)"");
15940 }
15941 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15942 PyObject *resultobj;
15943 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15944 int arg2 = (int) 0 ;
15945 wxNotifyEvent *result;
15946 PyObject * obj0 = 0 ;
15947 PyObject * obj1 = 0 ;
15948 char *kwnames[] = {
15949 (char *) "commandType",(char *) "winid", NULL
15950 };
15951
15952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15953 if (obj0) {
15954 {
15955 arg1 = (wxEventType)(SWIG_As_int(obj0));
15956 if (SWIG_arg_fail(1)) SWIG_fail;
15957 }
15958 }
15959 if (obj1) {
15960 {
15961 arg2 = (int)(SWIG_As_int(obj1));
15962 if (SWIG_arg_fail(2)) SWIG_fail;
15963 }
15964 }
15965 {
15966 PyThreadState* __tstate = wxPyBeginAllowThreads();
15967 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15968
15969 wxPyEndAllowThreads(__tstate);
15970 if (PyErr_Occurred()) SWIG_fail;
15971 }
15972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15973 return resultobj;
15974 fail:
15975 return NULL;
15976 }
15977
15978
15979 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15980 PyObject *resultobj;
15981 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15982 PyObject * obj0 = 0 ;
15983 char *kwnames[] = {
15984 (char *) "self", NULL
15985 };
15986
15987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15989 if (SWIG_arg_fail(1)) SWIG_fail;
15990 {
15991 PyThreadState* __tstate = wxPyBeginAllowThreads();
15992 (arg1)->Veto();
15993
15994 wxPyEndAllowThreads(__tstate);
15995 if (PyErr_Occurred()) SWIG_fail;
15996 }
15997 Py_INCREF(Py_None); resultobj = Py_None;
15998 return resultobj;
15999 fail:
16000 return NULL;
16001 }
16002
16003
16004 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16005 PyObject *resultobj;
16006 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16007 PyObject * obj0 = 0 ;
16008 char *kwnames[] = {
16009 (char *) "self", NULL
16010 };
16011
16012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16014 if (SWIG_arg_fail(1)) SWIG_fail;
16015 {
16016 PyThreadState* __tstate = wxPyBeginAllowThreads();
16017 (arg1)->Allow();
16018
16019 wxPyEndAllowThreads(__tstate);
16020 if (PyErr_Occurred()) SWIG_fail;
16021 }
16022 Py_INCREF(Py_None); resultobj = Py_None;
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16030 PyObject *resultobj;
16031 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16032 bool result;
16033 PyObject * obj0 = 0 ;
16034 char *kwnames[] = {
16035 (char *) "self", NULL
16036 };
16037
16038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16040 if (SWIG_arg_fail(1)) SWIG_fail;
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (bool)(arg1)->IsAllowed();
16044
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 {
16049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16050 }
16051 return resultobj;
16052 fail:
16053 return NULL;
16054 }
16055
16056
16057 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16058 PyObject *obj;
16059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16060 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16061 Py_INCREF(obj);
16062 return Py_BuildValue((char *)"");
16063 }
16064 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj;
16066 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16067 int arg2 = (int) 0 ;
16068 int arg3 = (int) 0 ;
16069 int arg4 = (int) 0 ;
16070 wxScrollEvent *result;
16071 PyObject * obj0 = 0 ;
16072 PyObject * obj1 = 0 ;
16073 PyObject * obj2 = 0 ;
16074 PyObject * obj3 = 0 ;
16075 char *kwnames[] = {
16076 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16077 };
16078
16079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16080 if (obj0) {
16081 {
16082 arg1 = (wxEventType)(SWIG_As_int(obj0));
16083 if (SWIG_arg_fail(1)) SWIG_fail;
16084 }
16085 }
16086 if (obj1) {
16087 {
16088 arg2 = (int)(SWIG_As_int(obj1));
16089 if (SWIG_arg_fail(2)) SWIG_fail;
16090 }
16091 }
16092 if (obj2) {
16093 {
16094 arg3 = (int)(SWIG_As_int(obj2));
16095 if (SWIG_arg_fail(3)) SWIG_fail;
16096 }
16097 }
16098 if (obj3) {
16099 {
16100 arg4 = (int)(SWIG_As_int(obj3));
16101 if (SWIG_arg_fail(4)) SWIG_fail;
16102 }
16103 }
16104 {
16105 PyThreadState* __tstate = wxPyBeginAllowThreads();
16106 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16107
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16112 return resultobj;
16113 fail:
16114 return NULL;
16115 }
16116
16117
16118 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16119 PyObject *resultobj;
16120 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16121 int result;
16122 PyObject * obj0 = 0 ;
16123 char *kwnames[] = {
16124 (char *) "self", NULL
16125 };
16126
16127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16129 if (SWIG_arg_fail(1)) SWIG_fail;
16130 {
16131 PyThreadState* __tstate = wxPyBeginAllowThreads();
16132 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16133
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 {
16138 resultobj = SWIG_From_int((int)(result));
16139 }
16140 return resultobj;
16141 fail:
16142 return NULL;
16143 }
16144
16145
16146 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16147 PyObject *resultobj;
16148 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16149 int result;
16150 PyObject * obj0 = 0 ;
16151 char *kwnames[] = {
16152 (char *) "self", NULL
16153 };
16154
16155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16157 if (SWIG_arg_fail(1)) SWIG_fail;
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16161
16162 wxPyEndAllowThreads(__tstate);
16163 if (PyErr_Occurred()) SWIG_fail;
16164 }
16165 {
16166 resultobj = SWIG_From_int((int)(result));
16167 }
16168 return resultobj;
16169 fail:
16170 return NULL;
16171 }
16172
16173
16174 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16175 PyObject *resultobj;
16176 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16177 int arg2 ;
16178 PyObject * obj0 = 0 ;
16179 PyObject * obj1 = 0 ;
16180 char *kwnames[] = {
16181 (char *) "self",(char *) "orient", NULL
16182 };
16183
16184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16186 if (SWIG_arg_fail(1)) SWIG_fail;
16187 {
16188 arg2 = (int)(SWIG_As_int(obj1));
16189 if (SWIG_arg_fail(2)) SWIG_fail;
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 (arg1)->SetOrientation(arg2);
16194
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 Py_INCREF(Py_None); resultobj = Py_None;
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj;
16207 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16208 int arg2 ;
16209 PyObject * obj0 = 0 ;
16210 PyObject * obj1 = 0 ;
16211 char *kwnames[] = {
16212 (char *) "self",(char *) "pos", NULL
16213 };
16214
16215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16217 if (SWIG_arg_fail(1)) SWIG_fail;
16218 {
16219 arg2 = (int)(SWIG_As_int(obj1));
16220 if (SWIG_arg_fail(2)) SWIG_fail;
16221 }
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 (arg1)->SetPosition(arg2);
16225
16226 wxPyEndAllowThreads(__tstate);
16227 if (PyErr_Occurred()) SWIG_fail;
16228 }
16229 Py_INCREF(Py_None); resultobj = Py_None;
16230 return resultobj;
16231 fail:
16232 return NULL;
16233 }
16234
16235
16236 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16237 PyObject *obj;
16238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16239 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16240 Py_INCREF(obj);
16241 return Py_BuildValue((char *)"");
16242 }
16243 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj;
16245 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16246 int arg2 = (int) 0 ;
16247 int arg3 = (int) 0 ;
16248 wxScrollWinEvent *result;
16249 PyObject * obj0 = 0 ;
16250 PyObject * obj1 = 0 ;
16251 PyObject * obj2 = 0 ;
16252 char *kwnames[] = {
16253 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16254 };
16255
16256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16257 if (obj0) {
16258 {
16259 arg1 = (wxEventType)(SWIG_As_int(obj0));
16260 if (SWIG_arg_fail(1)) SWIG_fail;
16261 }
16262 }
16263 if (obj1) {
16264 {
16265 arg2 = (int)(SWIG_As_int(obj1));
16266 if (SWIG_arg_fail(2)) SWIG_fail;
16267 }
16268 }
16269 if (obj2) {
16270 {
16271 arg3 = (int)(SWIG_As_int(obj2));
16272 if (SWIG_arg_fail(3)) SWIG_fail;
16273 }
16274 }
16275 {
16276 PyThreadState* __tstate = wxPyBeginAllowThreads();
16277 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16278
16279 wxPyEndAllowThreads(__tstate);
16280 if (PyErr_Occurred()) SWIG_fail;
16281 }
16282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj;
16291 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16292 int result;
16293 PyObject * obj0 = 0 ;
16294 char *kwnames[] = {
16295 (char *) "self", NULL
16296 };
16297
16298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16300 if (SWIG_arg_fail(1)) SWIG_fail;
16301 {
16302 PyThreadState* __tstate = wxPyBeginAllowThreads();
16303 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16304
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 {
16309 resultobj = SWIG_From_int((int)(result));
16310 }
16311 return resultobj;
16312 fail:
16313 return NULL;
16314 }
16315
16316
16317 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj;
16319 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16320 int result;
16321 PyObject * obj0 = 0 ;
16322 char *kwnames[] = {
16323 (char *) "self", NULL
16324 };
16325
16326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16328 if (SWIG_arg_fail(1)) SWIG_fail;
16329 {
16330 PyThreadState* __tstate = wxPyBeginAllowThreads();
16331 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16332
16333 wxPyEndAllowThreads(__tstate);
16334 if (PyErr_Occurred()) SWIG_fail;
16335 }
16336 {
16337 resultobj = SWIG_From_int((int)(result));
16338 }
16339 return resultobj;
16340 fail:
16341 return NULL;
16342 }
16343
16344
16345 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16346 PyObject *resultobj;
16347 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16348 int arg2 ;
16349 PyObject * obj0 = 0 ;
16350 PyObject * obj1 = 0 ;
16351 char *kwnames[] = {
16352 (char *) "self",(char *) "orient", NULL
16353 };
16354
16355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16357 if (SWIG_arg_fail(1)) SWIG_fail;
16358 {
16359 arg2 = (int)(SWIG_As_int(obj1));
16360 if (SWIG_arg_fail(2)) SWIG_fail;
16361 }
16362 {
16363 PyThreadState* __tstate = wxPyBeginAllowThreads();
16364 (arg1)->SetOrientation(arg2);
16365
16366 wxPyEndAllowThreads(__tstate);
16367 if (PyErr_Occurred()) SWIG_fail;
16368 }
16369 Py_INCREF(Py_None); resultobj = Py_None;
16370 return resultobj;
16371 fail:
16372 return NULL;
16373 }
16374
16375
16376 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16377 PyObject *resultobj;
16378 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16379 int arg2 ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 char *kwnames[] = {
16383 (char *) "self",(char *) "pos", NULL
16384 };
16385
16386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16388 if (SWIG_arg_fail(1)) SWIG_fail;
16389 {
16390 arg2 = (int)(SWIG_As_int(obj1));
16391 if (SWIG_arg_fail(2)) SWIG_fail;
16392 }
16393 {
16394 PyThreadState* __tstate = wxPyBeginAllowThreads();
16395 (arg1)->SetPosition(arg2);
16396
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 Py_INCREF(Py_None); resultobj = Py_None;
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16408 PyObject *obj;
16409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16410 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16411 Py_INCREF(obj);
16412 return Py_BuildValue((char *)"");
16413 }
16414 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16415 PyObject *resultobj;
16416 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16417 wxMouseEvent *result;
16418 PyObject * obj0 = 0 ;
16419 char *kwnames[] = {
16420 (char *) "mouseType", NULL
16421 };
16422
16423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16424 if (obj0) {
16425 {
16426 arg1 = (wxEventType)(SWIG_As_int(obj0));
16427 if (SWIG_arg_fail(1)) SWIG_fail;
16428 }
16429 }
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16433
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 {
16438 resultobj = wxPyMake_wxObject(result, 1);
16439 }
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj;
16448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16449 bool result;
16450 PyObject * obj0 = 0 ;
16451 char *kwnames[] = {
16452 (char *) "self", NULL
16453 };
16454
16455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16457 if (SWIG_arg_fail(1)) SWIG_fail;
16458 {
16459 PyThreadState* __tstate = wxPyBeginAllowThreads();
16460 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16461
16462 wxPyEndAllowThreads(__tstate);
16463 if (PyErr_Occurred()) SWIG_fail;
16464 }
16465 {
16466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16467 }
16468 return resultobj;
16469 fail:
16470 return NULL;
16471 }
16472
16473
16474 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16475 PyObject *resultobj;
16476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16477 int arg2 = (int) wxMOUSE_BTN_ANY ;
16478 bool result;
16479 PyObject * obj0 = 0 ;
16480 PyObject * obj1 = 0 ;
16481 char *kwnames[] = {
16482 (char *) "self",(char *) "but", NULL
16483 };
16484
16485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16487 if (SWIG_arg_fail(1)) SWIG_fail;
16488 if (obj1) {
16489 {
16490 arg2 = (int)(SWIG_As_int(obj1));
16491 if (SWIG_arg_fail(2)) SWIG_fail;
16492 }
16493 }
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16497
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 {
16502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16503 }
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj;
16512 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16513 int arg2 = (int) wxMOUSE_BTN_ANY ;
16514 bool result;
16515 PyObject * obj0 = 0 ;
16516 PyObject * obj1 = 0 ;
16517 char *kwnames[] = {
16518 (char *) "self",(char *) "but", NULL
16519 };
16520
16521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16523 if (SWIG_arg_fail(1)) SWIG_fail;
16524 if (obj1) {
16525 {
16526 arg2 = (int)(SWIG_As_int(obj1));
16527 if (SWIG_arg_fail(2)) SWIG_fail;
16528 }
16529 }
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16533
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 {
16538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16539 }
16540 return resultobj;
16541 fail:
16542 return NULL;
16543 }
16544
16545
16546 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16547 PyObject *resultobj;
16548 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16549 int arg2 = (int) wxMOUSE_BTN_ANY ;
16550 bool result;
16551 PyObject * obj0 = 0 ;
16552 PyObject * obj1 = 0 ;
16553 char *kwnames[] = {
16554 (char *) "self",(char *) "but", NULL
16555 };
16556
16557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16559 if (SWIG_arg_fail(1)) SWIG_fail;
16560 if (obj1) {
16561 {
16562 arg2 = (int)(SWIG_As_int(obj1));
16563 if (SWIG_arg_fail(2)) SWIG_fail;
16564 }
16565 }
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16569
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 {
16574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16575 }
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16583 PyObject *resultobj;
16584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16585 int arg2 ;
16586 bool result;
16587 PyObject * obj0 = 0 ;
16588 PyObject * obj1 = 0 ;
16589 char *kwnames[] = {
16590 (char *) "self",(char *) "button", NULL
16591 };
16592
16593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16595 if (SWIG_arg_fail(1)) SWIG_fail;
16596 {
16597 arg2 = (int)(SWIG_As_int(obj1));
16598 if (SWIG_arg_fail(2)) SWIG_fail;
16599 }
16600 {
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16603
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 {
16608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16609 }
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16617 PyObject *resultobj;
16618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16619 int arg2 ;
16620 bool result;
16621 PyObject * obj0 = 0 ;
16622 PyObject * obj1 = 0 ;
16623 char *kwnames[] = {
16624 (char *) "self",(char *) "but", NULL
16625 };
16626
16627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16629 if (SWIG_arg_fail(1)) SWIG_fail;
16630 {
16631 arg2 = (int)(SWIG_As_int(obj1));
16632 if (SWIG_arg_fail(2)) SWIG_fail;
16633 }
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16643 }
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj;
16652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16653 int result;
16654 PyObject * obj0 = 0 ;
16655 char *kwnames[] = {
16656 (char *) "self", NULL
16657 };
16658
16659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16661 if (SWIG_arg_fail(1)) SWIG_fail;
16662 {
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16665
16666 wxPyEndAllowThreads(__tstate);
16667 if (PyErr_Occurred()) SWIG_fail;
16668 }
16669 {
16670 resultobj = SWIG_From_int((int)(result));
16671 }
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16679 PyObject *resultobj;
16680 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16681 bool result;
16682 PyObject * obj0 = 0 ;
16683 char *kwnames[] = {
16684 (char *) "self", NULL
16685 };
16686
16687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16689 if (SWIG_arg_fail(1)) SWIG_fail;
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 {
16698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16699 }
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16707 PyObject *resultobj;
16708 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16709 bool result;
16710 PyObject * obj0 = 0 ;
16711 char *kwnames[] = {
16712 (char *) "self", NULL
16713 };
16714
16715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16717 if (SWIG_arg_fail(1)) SWIG_fail;
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16721
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 {
16726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16727 }
16728 return resultobj;
16729 fail:
16730 return NULL;
16731 }
16732
16733
16734 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16735 PyObject *resultobj;
16736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16737 bool result;
16738 PyObject * obj0 = 0 ;
16739 char *kwnames[] = {
16740 (char *) "self", NULL
16741 };
16742
16743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16745 if (SWIG_arg_fail(1)) SWIG_fail;
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16749
16750 wxPyEndAllowThreads(__tstate);
16751 if (PyErr_Occurred()) SWIG_fail;
16752 }
16753 {
16754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16755 }
16756 return resultobj;
16757 fail:
16758 return NULL;
16759 }
16760
16761
16762 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj;
16764 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16765 bool result;
16766 PyObject * obj0 = 0 ;
16767 char *kwnames[] = {
16768 (char *) "self", NULL
16769 };
16770
16771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16773 if (SWIG_arg_fail(1)) SWIG_fail;
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16777
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 {
16782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16783 }
16784 return resultobj;
16785 fail:
16786 return NULL;
16787 }
16788
16789
16790 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16791 PyObject *resultobj;
16792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16793 bool result;
16794 PyObject * obj0 = 0 ;
16795 char *kwnames[] = {
16796 (char *) "self", NULL
16797 };
16798
16799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16801 if (SWIG_arg_fail(1)) SWIG_fail;
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16805
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 {
16810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16811 }
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj;
16820 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16821 bool result;
16822 PyObject * obj0 = 0 ;
16823 char *kwnames[] = {
16824 (char *) "self", NULL
16825 };
16826
16827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16829 if (SWIG_arg_fail(1)) SWIG_fail;
16830 {
16831 PyThreadState* __tstate = wxPyBeginAllowThreads();
16832 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16833
16834 wxPyEndAllowThreads(__tstate);
16835 if (PyErr_Occurred()) SWIG_fail;
16836 }
16837 {
16838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16839 }
16840 return resultobj;
16841 fail:
16842 return NULL;
16843 }
16844
16845
16846 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16847 PyObject *resultobj;
16848 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16849 bool result;
16850 PyObject * obj0 = 0 ;
16851 char *kwnames[] = {
16852 (char *) "self", NULL
16853 };
16854
16855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16857 if (SWIG_arg_fail(1)) SWIG_fail;
16858 {
16859 PyThreadState* __tstate = wxPyBeginAllowThreads();
16860 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16861
16862 wxPyEndAllowThreads(__tstate);
16863 if (PyErr_Occurred()) SWIG_fail;
16864 }
16865 {
16866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16867 }
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj;
16876 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16877 bool result;
16878 PyObject * obj0 = 0 ;
16879 char *kwnames[] = {
16880 (char *) "self", NULL
16881 };
16882
16883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16885 if (SWIG_arg_fail(1)) SWIG_fail;
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16889
16890 wxPyEndAllowThreads(__tstate);
16891 if (PyErr_Occurred()) SWIG_fail;
16892 }
16893 {
16894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16895 }
16896 return resultobj;
16897 fail:
16898 return NULL;
16899 }
16900
16901
16902 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16903 PyObject *resultobj;
16904 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16905 bool result;
16906 PyObject * obj0 = 0 ;
16907 char *kwnames[] = {
16908 (char *) "self", NULL
16909 };
16910
16911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16913 if (SWIG_arg_fail(1)) SWIG_fail;
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16917
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 {
16922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16923 }
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj;
16932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16933 bool result;
16934 PyObject * obj0 = 0 ;
16935 char *kwnames[] = {
16936 (char *) "self", NULL
16937 };
16938
16939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16941 if (SWIG_arg_fail(1)) SWIG_fail;
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16945
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 {
16950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16951 }
16952 return resultobj;
16953 fail:
16954 return NULL;
16955 }
16956
16957
16958 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16959 PyObject *resultobj;
16960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16961 bool result;
16962 PyObject * obj0 = 0 ;
16963 char *kwnames[] = {
16964 (char *) "self", NULL
16965 };
16966
16967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16969 if (SWIG_arg_fail(1)) SWIG_fail;
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16973
16974 wxPyEndAllowThreads(__tstate);
16975 if (PyErr_Occurred()) SWIG_fail;
16976 }
16977 {
16978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16979 }
16980 return resultobj;
16981 fail:
16982 return NULL;
16983 }
16984
16985
16986 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16987 PyObject *resultobj;
16988 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16989 bool result;
16990 PyObject * obj0 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17001
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17007 }
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17017 bool result;
17018 PyObject * obj0 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17029
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 {
17034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17035 }
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17045 bool result;
17046 PyObject * obj0 = 0 ;
17047 char *kwnames[] = {
17048 (char *) "self", NULL
17049 };
17050
17051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17053 if (SWIG_arg_fail(1)) SWIG_fail;
17054 {
17055 PyThreadState* __tstate = wxPyBeginAllowThreads();
17056 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17057
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 {
17062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17063 }
17064 return resultobj;
17065 fail:
17066 return NULL;
17067 }
17068
17069
17070 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj;
17072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17073 bool result;
17074 PyObject * obj0 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self", NULL
17077 };
17078
17079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17081 if (SWIG_arg_fail(1)) SWIG_fail;
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 result = (bool)(arg1)->LeftIsDown();
17085
17086 wxPyEndAllowThreads(__tstate);
17087 if (PyErr_Occurred()) SWIG_fail;
17088 }
17089 {
17090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17091 }
17092 return resultobj;
17093 fail:
17094 return NULL;
17095 }
17096
17097
17098 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17099 PyObject *resultobj;
17100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17101 bool result;
17102 PyObject * obj0 = 0 ;
17103 char *kwnames[] = {
17104 (char *) "self", NULL
17105 };
17106
17107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17109 if (SWIG_arg_fail(1)) SWIG_fail;
17110 {
17111 PyThreadState* __tstate = wxPyBeginAllowThreads();
17112 result = (bool)(arg1)->MiddleIsDown();
17113
17114 wxPyEndAllowThreads(__tstate);
17115 if (PyErr_Occurred()) SWIG_fail;
17116 }
17117 {
17118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17119 }
17120 return resultobj;
17121 fail:
17122 return NULL;
17123 }
17124
17125
17126 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17127 PyObject *resultobj;
17128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17129 bool result;
17130 PyObject * obj0 = 0 ;
17131 char *kwnames[] = {
17132 (char *) "self", NULL
17133 };
17134
17135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17137 if (SWIG_arg_fail(1)) SWIG_fail;
17138 {
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (bool)(arg1)->RightIsDown();
17141
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 {
17146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17147 }
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj;
17156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17157 bool result;
17158 PyObject * obj0 = 0 ;
17159 char *kwnames[] = {
17160 (char *) "self", NULL
17161 };
17162
17163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17165 if (SWIG_arg_fail(1)) SWIG_fail;
17166 {
17167 PyThreadState* __tstate = wxPyBeginAllowThreads();
17168 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17169
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 {
17174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17175 }
17176 return resultobj;
17177 fail:
17178 return NULL;
17179 }
17180
17181
17182 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj;
17184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17185 bool result;
17186 PyObject * obj0 = 0 ;
17187 char *kwnames[] = {
17188 (char *) "self", NULL
17189 };
17190
17191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17193 if (SWIG_arg_fail(1)) SWIG_fail;
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17197
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 {
17202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17203 }
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj;
17212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17213 bool result;
17214 PyObject * obj0 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17225
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 {
17230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17231 }
17232 return resultobj;
17233 fail:
17234 return NULL;
17235 }
17236
17237
17238 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj;
17240 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17241 bool result;
17242 PyObject * obj0 = 0 ;
17243 char *kwnames[] = {
17244 (char *) "self", NULL
17245 };
17246
17247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17249 if (SWIG_arg_fail(1)) SWIG_fail;
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17253
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 {
17258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17259 }
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj;
17268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17269 wxPoint result;
17270 PyObject * obj0 = 0 ;
17271 char *kwnames[] = {
17272 (char *) "self", NULL
17273 };
17274
17275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17277 if (SWIG_arg_fail(1)) SWIG_fail;
17278 {
17279 PyThreadState* __tstate = wxPyBeginAllowThreads();
17280 result = (arg1)->GetPosition();
17281
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 {
17286 wxPoint * resultptr;
17287 resultptr = new wxPoint((wxPoint &)(result));
17288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17289 }
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17297 PyObject *resultobj;
17298 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17299 long *arg2 = (long *) 0 ;
17300 long *arg3 = (long *) 0 ;
17301 long temp2 ;
17302 int res2 = 0 ;
17303 long temp3 ;
17304 int res3 = 0 ;
17305 PyObject * obj0 = 0 ;
17306 char *kwnames[] = {
17307 (char *) "self", NULL
17308 };
17309
17310 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17311 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 {
17316 PyThreadState* __tstate = wxPyBeginAllowThreads();
17317 (arg1)->GetPosition(arg2,arg3);
17318
17319 wxPyEndAllowThreads(__tstate);
17320 if (PyErr_Occurred()) SWIG_fail;
17321 }
17322 Py_INCREF(Py_None); resultobj = Py_None;
17323 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17324 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17325 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17326 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17327 return resultobj;
17328 fail:
17329 return NULL;
17330 }
17331
17332
17333 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17334 PyObject *resultobj;
17335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17336 wxDC *arg2 = 0 ;
17337 wxPoint result;
17338 PyObject * obj0 = 0 ;
17339 PyObject * obj1 = 0 ;
17340 char *kwnames[] = {
17341 (char *) "self",(char *) "dc", NULL
17342 };
17343
17344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17346 if (SWIG_arg_fail(1)) SWIG_fail;
17347 {
17348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17349 if (SWIG_arg_fail(2)) SWIG_fail;
17350 if (arg2 == NULL) {
17351 SWIG_null_ref("wxDC");
17352 }
17353 if (SWIG_arg_fail(2)) SWIG_fail;
17354 }
17355 {
17356 PyThreadState* __tstate = wxPyBeginAllowThreads();
17357 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17358
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 {
17363 wxPoint * resultptr;
17364 resultptr = new wxPoint((wxPoint &)(result));
17365 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17366 }
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj;
17375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17376 int result;
17377 PyObject * obj0 = 0 ;
17378 char *kwnames[] = {
17379 (char *) "self", NULL
17380 };
17381
17382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17384 if (SWIG_arg_fail(1)) SWIG_fail;
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (int)((wxMouseEvent const *)arg1)->GetX();
17388
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 {
17393 resultobj = SWIG_From_int((int)(result));
17394 }
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (int)((wxMouseEvent const *)arg1)->GetY();
17416
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 {
17421 resultobj = SWIG_From_int((int)(result));
17422 }
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17432 int result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 PyThreadState* __tstate = wxPyBeginAllowThreads();
17443 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17444
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 {
17449 resultobj = SWIG_From_int((int)(result));
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17460 int result;
17461 PyObject * obj0 = 0 ;
17462 char *kwnames[] = {
17463 (char *) "self", NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17468 if (SWIG_arg_fail(1)) SWIG_fail;
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17472
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = SWIG_From_int((int)(result));
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj;
17487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17488 int result;
17489 PyObject * obj0 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17500
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 {
17505 resultobj = SWIG_From_int((int)(result));
17506 }
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj;
17515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17516 bool result;
17517 PyObject * obj0 = 0 ;
17518 char *kwnames[] = {
17519 (char *) "self", NULL
17520 };
17521
17522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17524 if (SWIG_arg_fail(1)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17528
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 {
17533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17534 }
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj;
17543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17544 int arg2 ;
17545 PyObject * obj0 = 0 ;
17546 PyObject * obj1 = 0 ;
17547 char *kwnames[] = {
17548 (char *) "self",(char *) "m_x", NULL
17549 };
17550
17551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17553 if (SWIG_arg_fail(1)) SWIG_fail;
17554 {
17555 arg2 = (int)(SWIG_As_int(obj1));
17556 if (SWIG_arg_fail(2)) SWIG_fail;
17557 }
17558 if (arg1) (arg1)->m_x = arg2;
17559
17560 Py_INCREF(Py_None); resultobj = Py_None;
17561 return resultobj;
17562 fail:
17563 return NULL;
17564 }
17565
17566
17567 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17568 PyObject *resultobj;
17569 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17570 int result;
17571 PyObject * obj0 = 0 ;
17572 char *kwnames[] = {
17573 (char *) "self", NULL
17574 };
17575
17576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17578 if (SWIG_arg_fail(1)) SWIG_fail;
17579 result = (int) ((arg1)->m_x);
17580
17581 {
17582 resultobj = SWIG_From_int((int)(result));
17583 }
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj;
17592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17593 int arg2 ;
17594 PyObject * obj0 = 0 ;
17595 PyObject * obj1 = 0 ;
17596 char *kwnames[] = {
17597 (char *) "self",(char *) "m_y", NULL
17598 };
17599
17600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17602 if (SWIG_arg_fail(1)) SWIG_fail;
17603 {
17604 arg2 = (int)(SWIG_As_int(obj1));
17605 if (SWIG_arg_fail(2)) SWIG_fail;
17606 }
17607 if (arg1) (arg1)->m_y = arg2;
17608
17609 Py_INCREF(Py_None); resultobj = Py_None;
17610 return resultobj;
17611 fail:
17612 return NULL;
17613 }
17614
17615
17616 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17617 PyObject *resultobj;
17618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17619 int result;
17620 PyObject * obj0 = 0 ;
17621 char *kwnames[] = {
17622 (char *) "self", NULL
17623 };
17624
17625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17627 if (SWIG_arg_fail(1)) SWIG_fail;
17628 result = (int) ((arg1)->m_y);
17629
17630 {
17631 resultobj = SWIG_From_int((int)(result));
17632 }
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj;
17641 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17642 bool arg2 ;
17643 PyObject * obj0 = 0 ;
17644 PyObject * obj1 = 0 ;
17645 char *kwnames[] = {
17646 (char *) "self",(char *) "m_leftDown", NULL
17647 };
17648
17649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17651 if (SWIG_arg_fail(1)) SWIG_fail;
17652 {
17653 arg2 = (bool)(SWIG_As_bool(obj1));
17654 if (SWIG_arg_fail(2)) SWIG_fail;
17655 }
17656 if (arg1) (arg1)->m_leftDown = arg2;
17657
17658 Py_INCREF(Py_None); resultobj = Py_None;
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj;
17667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17668 bool result;
17669 PyObject * obj0 = 0 ;
17670 char *kwnames[] = {
17671 (char *) "self", NULL
17672 };
17673
17674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17676 if (SWIG_arg_fail(1)) SWIG_fail;
17677 result = (bool) ((arg1)->m_leftDown);
17678
17679 {
17680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17681 }
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17689 PyObject *resultobj;
17690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17691 bool arg2 ;
17692 PyObject * obj0 = 0 ;
17693 PyObject * obj1 = 0 ;
17694 char *kwnames[] = {
17695 (char *) "self",(char *) "m_middleDown", NULL
17696 };
17697
17698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17700 if (SWIG_arg_fail(1)) SWIG_fail;
17701 {
17702 arg2 = (bool)(SWIG_As_bool(obj1));
17703 if (SWIG_arg_fail(2)) SWIG_fail;
17704 }
17705 if (arg1) (arg1)->m_middleDown = arg2;
17706
17707 Py_INCREF(Py_None); resultobj = Py_None;
17708 return resultobj;
17709 fail:
17710 return NULL;
17711 }
17712
17713
17714 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj;
17716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17717 bool result;
17718 PyObject * obj0 = 0 ;
17719 char *kwnames[] = {
17720 (char *) "self", NULL
17721 };
17722
17723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17725 if (SWIG_arg_fail(1)) SWIG_fail;
17726 result = (bool) ((arg1)->m_middleDown);
17727
17728 {
17729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17730 }
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17738 PyObject *resultobj;
17739 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17740 bool arg2 ;
17741 PyObject * obj0 = 0 ;
17742 PyObject * obj1 = 0 ;
17743 char *kwnames[] = {
17744 (char *) "self",(char *) "m_rightDown", NULL
17745 };
17746
17747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17749 if (SWIG_arg_fail(1)) SWIG_fail;
17750 {
17751 arg2 = (bool)(SWIG_As_bool(obj1));
17752 if (SWIG_arg_fail(2)) SWIG_fail;
17753 }
17754 if (arg1) (arg1)->m_rightDown = arg2;
17755
17756 Py_INCREF(Py_None); resultobj = Py_None;
17757 return resultobj;
17758 fail:
17759 return NULL;
17760 }
17761
17762
17763 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj;
17765 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17766 bool result;
17767 PyObject * obj0 = 0 ;
17768 char *kwnames[] = {
17769 (char *) "self", NULL
17770 };
17771
17772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17774 if (SWIG_arg_fail(1)) SWIG_fail;
17775 result = (bool) ((arg1)->m_rightDown);
17776
17777 {
17778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17779 }
17780 return resultobj;
17781 fail:
17782 return NULL;
17783 }
17784
17785
17786 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17787 PyObject *resultobj;
17788 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17789 bool arg2 ;
17790 PyObject * obj0 = 0 ;
17791 PyObject * obj1 = 0 ;
17792 char *kwnames[] = {
17793 (char *) "self",(char *) "m_controlDown", NULL
17794 };
17795
17796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17798 if (SWIG_arg_fail(1)) SWIG_fail;
17799 {
17800 arg2 = (bool)(SWIG_As_bool(obj1));
17801 if (SWIG_arg_fail(2)) SWIG_fail;
17802 }
17803 if (arg1) (arg1)->m_controlDown = arg2;
17804
17805 Py_INCREF(Py_None); resultobj = Py_None;
17806 return resultobj;
17807 fail:
17808 return NULL;
17809 }
17810
17811
17812 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17813 PyObject *resultobj;
17814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17815 bool result;
17816 PyObject * obj0 = 0 ;
17817 char *kwnames[] = {
17818 (char *) "self", NULL
17819 };
17820
17821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17823 if (SWIG_arg_fail(1)) SWIG_fail;
17824 result = (bool) ((arg1)->m_controlDown);
17825
17826 {
17827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17828 }
17829 return resultobj;
17830 fail:
17831 return NULL;
17832 }
17833
17834
17835 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj;
17837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17838 bool arg2 ;
17839 PyObject * obj0 = 0 ;
17840 PyObject * obj1 = 0 ;
17841 char *kwnames[] = {
17842 (char *) "self",(char *) "m_shiftDown", NULL
17843 };
17844
17845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17847 if (SWIG_arg_fail(1)) SWIG_fail;
17848 {
17849 arg2 = (bool)(SWIG_As_bool(obj1));
17850 if (SWIG_arg_fail(2)) SWIG_fail;
17851 }
17852 if (arg1) (arg1)->m_shiftDown = arg2;
17853
17854 Py_INCREF(Py_None); resultobj = Py_None;
17855 return resultobj;
17856 fail:
17857 return NULL;
17858 }
17859
17860
17861 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17862 PyObject *resultobj;
17863 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17864 bool result;
17865 PyObject * obj0 = 0 ;
17866 char *kwnames[] = {
17867 (char *) "self", NULL
17868 };
17869
17870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17872 if (SWIG_arg_fail(1)) SWIG_fail;
17873 result = (bool) ((arg1)->m_shiftDown);
17874
17875 {
17876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17877 }
17878 return resultobj;
17879 fail:
17880 return NULL;
17881 }
17882
17883
17884 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17885 PyObject *resultobj;
17886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17887 bool arg2 ;
17888 PyObject * obj0 = 0 ;
17889 PyObject * obj1 = 0 ;
17890 char *kwnames[] = {
17891 (char *) "self",(char *) "m_altDown", NULL
17892 };
17893
17894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17896 if (SWIG_arg_fail(1)) SWIG_fail;
17897 {
17898 arg2 = (bool)(SWIG_As_bool(obj1));
17899 if (SWIG_arg_fail(2)) SWIG_fail;
17900 }
17901 if (arg1) (arg1)->m_altDown = arg2;
17902
17903 Py_INCREF(Py_None); resultobj = Py_None;
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj;
17912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17913 bool result;
17914 PyObject * obj0 = 0 ;
17915 char *kwnames[] = {
17916 (char *) "self", NULL
17917 };
17918
17919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17921 if (SWIG_arg_fail(1)) SWIG_fail;
17922 result = (bool) ((arg1)->m_altDown);
17923
17924 {
17925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17926 }
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj;
17935 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17936 bool arg2 ;
17937 PyObject * obj0 = 0 ;
17938 PyObject * obj1 = 0 ;
17939 char *kwnames[] = {
17940 (char *) "self",(char *) "m_metaDown", NULL
17941 };
17942
17943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17945 if (SWIG_arg_fail(1)) SWIG_fail;
17946 {
17947 arg2 = (bool)(SWIG_As_bool(obj1));
17948 if (SWIG_arg_fail(2)) SWIG_fail;
17949 }
17950 if (arg1) (arg1)->m_metaDown = arg2;
17951
17952 Py_INCREF(Py_None); resultobj = Py_None;
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj;
17961 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17962 bool result;
17963 PyObject * obj0 = 0 ;
17964 char *kwnames[] = {
17965 (char *) "self", NULL
17966 };
17967
17968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17970 if (SWIG_arg_fail(1)) SWIG_fail;
17971 result = (bool) ((arg1)->m_metaDown);
17972
17973 {
17974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17975 }
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17983 PyObject *resultobj;
17984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17985 int arg2 ;
17986 PyObject * obj0 = 0 ;
17987 PyObject * obj1 = 0 ;
17988 char *kwnames[] = {
17989 (char *) "self",(char *) "m_wheelRotation", NULL
17990 };
17991
17992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17994 if (SWIG_arg_fail(1)) SWIG_fail;
17995 {
17996 arg2 = (int)(SWIG_As_int(obj1));
17997 if (SWIG_arg_fail(2)) SWIG_fail;
17998 }
17999 if (arg1) (arg1)->m_wheelRotation = arg2;
18000
18001 Py_INCREF(Py_None); resultobj = Py_None;
18002 return resultobj;
18003 fail:
18004 return NULL;
18005 }
18006
18007
18008 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18009 PyObject *resultobj;
18010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18011 int result;
18012 PyObject * obj0 = 0 ;
18013 char *kwnames[] = {
18014 (char *) "self", NULL
18015 };
18016
18017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18019 if (SWIG_arg_fail(1)) SWIG_fail;
18020 result = (int) ((arg1)->m_wheelRotation);
18021
18022 {
18023 resultobj = SWIG_From_int((int)(result));
18024 }
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj;
18033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18034 int arg2 ;
18035 PyObject * obj0 = 0 ;
18036 PyObject * obj1 = 0 ;
18037 char *kwnames[] = {
18038 (char *) "self",(char *) "m_wheelDelta", NULL
18039 };
18040
18041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18043 if (SWIG_arg_fail(1)) SWIG_fail;
18044 {
18045 arg2 = (int)(SWIG_As_int(obj1));
18046 if (SWIG_arg_fail(2)) SWIG_fail;
18047 }
18048 if (arg1) (arg1)->m_wheelDelta = arg2;
18049
18050 Py_INCREF(Py_None); resultobj = Py_None;
18051 return resultobj;
18052 fail:
18053 return NULL;
18054 }
18055
18056
18057 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18058 PyObject *resultobj;
18059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18060 int result;
18061 PyObject * obj0 = 0 ;
18062 char *kwnames[] = {
18063 (char *) "self", NULL
18064 };
18065
18066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18068 if (SWIG_arg_fail(1)) SWIG_fail;
18069 result = (int) ((arg1)->m_wheelDelta);
18070
18071 {
18072 resultobj = SWIG_From_int((int)(result));
18073 }
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18081 PyObject *resultobj;
18082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18083 int arg2 ;
18084 PyObject * obj0 = 0 ;
18085 PyObject * obj1 = 0 ;
18086 char *kwnames[] = {
18087 (char *) "self",(char *) "m_linesPerAction", NULL
18088 };
18089
18090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18092 if (SWIG_arg_fail(1)) SWIG_fail;
18093 {
18094 arg2 = (int)(SWIG_As_int(obj1));
18095 if (SWIG_arg_fail(2)) SWIG_fail;
18096 }
18097 if (arg1) (arg1)->m_linesPerAction = arg2;
18098
18099 Py_INCREF(Py_None); resultobj = Py_None;
18100 return resultobj;
18101 fail:
18102 return NULL;
18103 }
18104
18105
18106 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18107 PyObject *resultobj;
18108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18109 int result;
18110 PyObject * obj0 = 0 ;
18111 char *kwnames[] = {
18112 (char *) "self", NULL
18113 };
18114
18115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18117 if (SWIG_arg_fail(1)) SWIG_fail;
18118 result = (int) ((arg1)->m_linesPerAction);
18119
18120 {
18121 resultobj = SWIG_From_int((int)(result));
18122 }
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18130 PyObject *obj;
18131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18132 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18133 Py_INCREF(obj);
18134 return Py_BuildValue((char *)"");
18135 }
18136 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18137 PyObject *resultobj;
18138 int arg1 = (int) 0 ;
18139 int arg2 = (int) 0 ;
18140 wxSetCursorEvent *result;
18141 PyObject * obj0 = 0 ;
18142 PyObject * obj1 = 0 ;
18143 char *kwnames[] = {
18144 (char *) "x",(char *) "y", NULL
18145 };
18146
18147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18148 if (obj0) {
18149 {
18150 arg1 = (int)(SWIG_As_int(obj0));
18151 if (SWIG_arg_fail(1)) SWIG_fail;
18152 }
18153 }
18154 if (obj1) {
18155 {
18156 arg2 = (int)(SWIG_As_int(obj1));
18157 if (SWIG_arg_fail(2)) SWIG_fail;
18158 }
18159 }
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18163
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj;
18176 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18177 int result;
18178 PyObject * obj0 = 0 ;
18179 char *kwnames[] = {
18180 (char *) "self", NULL
18181 };
18182
18183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18185 if (SWIG_arg_fail(1)) SWIG_fail;
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18189
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 {
18194 resultobj = SWIG_From_int((int)(result));
18195 }
18196 return resultobj;
18197 fail:
18198 return NULL;
18199 }
18200
18201
18202 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18203 PyObject *resultobj;
18204 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18205 int result;
18206 PyObject * obj0 = 0 ;
18207 char *kwnames[] = {
18208 (char *) "self", NULL
18209 };
18210
18211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18213 if (SWIG_arg_fail(1)) SWIG_fail;
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18217
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 {
18222 resultobj = SWIG_From_int((int)(result));
18223 }
18224 return resultobj;
18225 fail:
18226 return NULL;
18227 }
18228
18229
18230 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18231 PyObject *resultobj;
18232 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18233 wxCursor *arg2 = 0 ;
18234 PyObject * obj0 = 0 ;
18235 PyObject * obj1 = 0 ;
18236 char *kwnames[] = {
18237 (char *) "self",(char *) "cursor", NULL
18238 };
18239
18240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(1)) SWIG_fail;
18243 {
18244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18245 if (SWIG_arg_fail(2)) SWIG_fail;
18246 if (arg2 == NULL) {
18247 SWIG_null_ref("wxCursor");
18248 }
18249 if (SWIG_arg_fail(2)) SWIG_fail;
18250 }
18251 {
18252 PyThreadState* __tstate = wxPyBeginAllowThreads();
18253 (arg1)->SetCursor((wxCursor const &)*arg2);
18254
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 Py_INCREF(Py_None); resultobj = Py_None;
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj;
18267 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18268 wxCursor *result;
18269 PyObject * obj0 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "self", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18276 if (SWIG_arg_fail(1)) SWIG_fail;
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 {
18280 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18281 result = (wxCursor *) &_result_ref;
18282 }
18283
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 {
18288 wxCursor* resultptr = new wxCursor(*result);
18289 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18290 }
18291 return resultobj;
18292 fail:
18293 return NULL;
18294 }
18295
18296
18297 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18298 PyObject *resultobj;
18299 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18300 bool result;
18301 PyObject * obj0 = 0 ;
18302 char *kwnames[] = {
18303 (char *) "self", NULL
18304 };
18305
18306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18308 if (SWIG_arg_fail(1)) SWIG_fail;
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18312
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 {
18317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18318 }
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18326 PyObject *obj;
18327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18328 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18329 Py_INCREF(obj);
18330 return Py_BuildValue((char *)"");
18331 }
18332 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18333 PyObject *resultobj;
18334 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18335 wxKeyEvent *result;
18336 PyObject * obj0 = 0 ;
18337 char *kwnames[] = {
18338 (char *) "eventType", NULL
18339 };
18340
18341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18342 if (obj0) {
18343 {
18344 arg1 = (wxEventType)(SWIG_As_int(obj0));
18345 if (SWIG_arg_fail(1)) SWIG_fail;
18346 }
18347 }
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18351
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18363 PyObject *resultobj;
18364 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18365 bool result;
18366 PyObject * obj0 = 0 ;
18367 char *kwnames[] = {
18368 (char *) "self", NULL
18369 };
18370
18371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18373 if (SWIG_arg_fail(1)) SWIG_fail;
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18377
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 {
18382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj;
18392 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18393 bool result;
18394 PyObject * obj0 = 0 ;
18395 char *kwnames[] = {
18396 (char *) "self", NULL
18397 };
18398
18399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18401 if (SWIG_arg_fail(1)) SWIG_fail;
18402 {
18403 PyThreadState* __tstate = wxPyBeginAllowThreads();
18404 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18405
18406 wxPyEndAllowThreads(__tstate);
18407 if (PyErr_Occurred()) SWIG_fail;
18408 }
18409 {
18410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18411 }
18412 return resultobj;
18413 fail:
18414 return NULL;
18415 }
18416
18417
18418 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj;
18420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18421 bool result;
18422 PyObject * obj0 = 0 ;
18423 char *kwnames[] = {
18424 (char *) "self", NULL
18425 };
18426
18427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18429 if (SWIG_arg_fail(1)) SWIG_fail;
18430 {
18431 PyThreadState* __tstate = wxPyBeginAllowThreads();
18432 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18433
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 {
18438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18439 }
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18447 PyObject *resultobj;
18448 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18449 bool result;
18450 PyObject * obj0 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18461
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 {
18466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18467 }
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj;
18476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18477 bool result;
18478 PyObject * obj0 = 0 ;
18479 char *kwnames[] = {
18480 (char *) "self", NULL
18481 };
18482
18483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18485 if (SWIG_arg_fail(1)) SWIG_fail;
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18489
18490 wxPyEndAllowThreads(__tstate);
18491 if (PyErr_Occurred()) SWIG_fail;
18492 }
18493 {
18494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18495 }
18496 return resultobj;
18497 fail:
18498 return NULL;
18499 }
18500
18501
18502 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18503 PyObject *resultobj;
18504 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18505 bool result;
18506 PyObject * obj0 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18517
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 {
18522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18523 }
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj;
18532 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18533 int result;
18534 PyObject * obj0 = 0 ;
18535 char *kwnames[] = {
18536 (char *) "self", NULL
18537 };
18538
18539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18541 if (SWIG_arg_fail(1)) SWIG_fail;
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18545
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 {
18550 resultobj = SWIG_From_int((int)(result));
18551 }
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj;
18560 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18561 int result;
18562 PyObject * obj0 = 0 ;
18563 char *kwnames[] = {
18564 (char *) "self", NULL
18565 };
18566
18567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18569 if (SWIG_arg_fail(1)) SWIG_fail;
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18573
18574 wxPyEndAllowThreads(__tstate);
18575 if (PyErr_Occurred()) SWIG_fail;
18576 }
18577 {
18578 resultobj = SWIG_From_int((int)(result));
18579 }
18580 return resultobj;
18581 fail:
18582 return NULL;
18583 }
18584
18585
18586 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18587 PyObject *resultobj;
18588 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18589 unsigned int result;
18590 PyObject * obj0 = 0 ;
18591 char *kwnames[] = {
18592 (char *) "self", NULL
18593 };
18594
18595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18597 if (SWIG_arg_fail(1)) SWIG_fail;
18598 {
18599 PyThreadState* __tstate = wxPyBeginAllowThreads();
18600 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18601
18602 wxPyEndAllowThreads(__tstate);
18603 if (PyErr_Occurred()) SWIG_fail;
18604 }
18605 {
18606 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18607 }
18608 return resultobj;
18609 fail:
18610 return NULL;
18611 }
18612
18613
18614 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18615 PyObject *resultobj;
18616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18617 unsigned int result;
18618 PyObject * obj0 = 0 ;
18619 char *kwnames[] = {
18620 (char *) "self", NULL
18621 };
18622
18623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18625 if (SWIG_arg_fail(1)) SWIG_fail;
18626 {
18627 PyThreadState* __tstate = wxPyBeginAllowThreads();
18628 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18629
18630 wxPyEndAllowThreads(__tstate);
18631 if (PyErr_Occurred()) SWIG_fail;
18632 }
18633 {
18634 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18635 }
18636 return resultobj;
18637 fail:
18638 return NULL;
18639 }
18640
18641
18642 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18643 PyObject *resultobj;
18644 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18645 wxPoint result;
18646 PyObject * obj0 = 0 ;
18647 char *kwnames[] = {
18648 (char *) "self", NULL
18649 };
18650
18651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 result = (arg1)->GetPosition();
18657
18658 wxPyEndAllowThreads(__tstate);
18659 if (PyErr_Occurred()) SWIG_fail;
18660 }
18661 {
18662 wxPoint * resultptr;
18663 resultptr = new wxPoint((wxPoint &)(result));
18664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18665 }
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj;
18674 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18675 long *arg2 = (long *) 0 ;
18676 long *arg3 = (long *) 0 ;
18677 long temp2 ;
18678 int res2 = 0 ;
18679 long temp3 ;
18680 int res3 = 0 ;
18681 PyObject * obj0 = 0 ;
18682 char *kwnames[] = {
18683 (char *) "self", NULL
18684 };
18685
18686 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18687 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18690 if (SWIG_arg_fail(1)) SWIG_fail;
18691 {
18692 PyThreadState* __tstate = wxPyBeginAllowThreads();
18693 (arg1)->GetPosition(arg2,arg3);
18694
18695 wxPyEndAllowThreads(__tstate);
18696 if (PyErr_Occurred()) SWIG_fail;
18697 }
18698 Py_INCREF(Py_None); resultobj = Py_None;
18699 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18700 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18701 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18702 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18710 PyObject *resultobj;
18711 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18712 int result;
18713 PyObject * obj0 = 0 ;
18714 char *kwnames[] = {
18715 (char *) "self", NULL
18716 };
18717
18718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18720 if (SWIG_arg_fail(1)) SWIG_fail;
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 result = (int)((wxKeyEvent const *)arg1)->GetX();
18724
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 {
18729 resultobj = SWIG_From_int((int)(result));
18730 }
18731 return resultobj;
18732 fail:
18733 return NULL;
18734 }
18735
18736
18737 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18738 PyObject *resultobj;
18739 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18740 int result;
18741 PyObject * obj0 = 0 ;
18742 char *kwnames[] = {
18743 (char *) "self", NULL
18744 };
18745
18746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18748 if (SWIG_arg_fail(1)) SWIG_fail;
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 result = (int)((wxKeyEvent const *)arg1)->GetY();
18752
18753 wxPyEndAllowThreads(__tstate);
18754 if (PyErr_Occurred()) SWIG_fail;
18755 }
18756 {
18757 resultobj = SWIG_From_int((int)(result));
18758 }
18759 return resultobj;
18760 fail:
18761 return NULL;
18762 }
18763
18764
18765 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18766 PyObject *resultobj;
18767 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18768 int arg2 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char *kwnames[] = {
18772 (char *) "self",(char *) "m_x", NULL
18773 };
18774
18775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18777 if (SWIG_arg_fail(1)) SWIG_fail;
18778 {
18779 arg2 = (int)(SWIG_As_int(obj1));
18780 if (SWIG_arg_fail(2)) SWIG_fail;
18781 }
18782 if (arg1) (arg1)->m_x = arg2;
18783
18784 Py_INCREF(Py_None); resultobj = Py_None;
18785 return resultobj;
18786 fail:
18787 return NULL;
18788 }
18789
18790
18791 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18792 PyObject *resultobj;
18793 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18794 int result;
18795 PyObject * obj0 = 0 ;
18796 char *kwnames[] = {
18797 (char *) "self", NULL
18798 };
18799
18800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18802 if (SWIG_arg_fail(1)) SWIG_fail;
18803 result = (int) ((arg1)->m_x);
18804
18805 {
18806 resultobj = SWIG_From_int((int)(result));
18807 }
18808 return resultobj;
18809 fail:
18810 return NULL;
18811 }
18812
18813
18814 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18815 PyObject *resultobj;
18816 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18817 int arg2 ;
18818 PyObject * obj0 = 0 ;
18819 PyObject * obj1 = 0 ;
18820 char *kwnames[] = {
18821 (char *) "self",(char *) "m_y", NULL
18822 };
18823
18824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18826 if (SWIG_arg_fail(1)) SWIG_fail;
18827 {
18828 arg2 = (int)(SWIG_As_int(obj1));
18829 if (SWIG_arg_fail(2)) SWIG_fail;
18830 }
18831 if (arg1) (arg1)->m_y = arg2;
18832
18833 Py_INCREF(Py_None); resultobj = Py_None;
18834 return resultobj;
18835 fail:
18836 return NULL;
18837 }
18838
18839
18840 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18841 PyObject *resultobj;
18842 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18843 int result;
18844 PyObject * obj0 = 0 ;
18845 char *kwnames[] = {
18846 (char *) "self", NULL
18847 };
18848
18849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18851 if (SWIG_arg_fail(1)) SWIG_fail;
18852 result = (int) ((arg1)->m_y);
18853
18854 {
18855 resultobj = SWIG_From_int((int)(result));
18856 }
18857 return resultobj;
18858 fail:
18859 return NULL;
18860 }
18861
18862
18863 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18864 PyObject *resultobj;
18865 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18866 long arg2 ;
18867 PyObject * obj0 = 0 ;
18868 PyObject * obj1 = 0 ;
18869 char *kwnames[] = {
18870 (char *) "self",(char *) "m_keyCode", NULL
18871 };
18872
18873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18875 if (SWIG_arg_fail(1)) SWIG_fail;
18876 {
18877 arg2 = (long)(SWIG_As_long(obj1));
18878 if (SWIG_arg_fail(2)) SWIG_fail;
18879 }
18880 if (arg1) (arg1)->m_keyCode = arg2;
18881
18882 Py_INCREF(Py_None); resultobj = Py_None;
18883 return resultobj;
18884 fail:
18885 return NULL;
18886 }
18887
18888
18889 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18890 PyObject *resultobj;
18891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18892 long result;
18893 PyObject * obj0 = 0 ;
18894 char *kwnames[] = {
18895 (char *) "self", NULL
18896 };
18897
18898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18900 if (SWIG_arg_fail(1)) SWIG_fail;
18901 result = (long) ((arg1)->m_keyCode);
18902
18903 {
18904 resultobj = SWIG_From_long((long)(result));
18905 }
18906 return resultobj;
18907 fail:
18908 return NULL;
18909 }
18910
18911
18912 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18913 PyObject *resultobj;
18914 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18915 bool arg2 ;
18916 PyObject * obj0 = 0 ;
18917 PyObject * obj1 = 0 ;
18918 char *kwnames[] = {
18919 (char *) "self",(char *) "m_controlDown", NULL
18920 };
18921
18922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18924 if (SWIG_arg_fail(1)) SWIG_fail;
18925 {
18926 arg2 = (bool)(SWIG_As_bool(obj1));
18927 if (SWIG_arg_fail(2)) SWIG_fail;
18928 }
18929 if (arg1) (arg1)->m_controlDown = arg2;
18930
18931 Py_INCREF(Py_None); resultobj = Py_None;
18932 return resultobj;
18933 fail:
18934 return NULL;
18935 }
18936
18937
18938 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18939 PyObject *resultobj;
18940 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18941 bool result;
18942 PyObject * obj0 = 0 ;
18943 char *kwnames[] = {
18944 (char *) "self", NULL
18945 };
18946
18947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18949 if (SWIG_arg_fail(1)) SWIG_fail;
18950 result = (bool) ((arg1)->m_controlDown);
18951
18952 {
18953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18954 }
18955 return resultobj;
18956 fail:
18957 return NULL;
18958 }
18959
18960
18961 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18962 PyObject *resultobj;
18963 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18964 bool arg2 ;
18965 PyObject * obj0 = 0 ;
18966 PyObject * obj1 = 0 ;
18967 char *kwnames[] = {
18968 (char *) "self",(char *) "m_shiftDown", NULL
18969 };
18970
18971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18973 if (SWIG_arg_fail(1)) SWIG_fail;
18974 {
18975 arg2 = (bool)(SWIG_As_bool(obj1));
18976 if (SWIG_arg_fail(2)) SWIG_fail;
18977 }
18978 if (arg1) (arg1)->m_shiftDown = arg2;
18979
18980 Py_INCREF(Py_None); resultobj = Py_None;
18981 return resultobj;
18982 fail:
18983 return NULL;
18984 }
18985
18986
18987 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18988 PyObject *resultobj;
18989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18990 bool result;
18991 PyObject * obj0 = 0 ;
18992 char *kwnames[] = {
18993 (char *) "self", NULL
18994 };
18995
18996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18998 if (SWIG_arg_fail(1)) SWIG_fail;
18999 result = (bool) ((arg1)->m_shiftDown);
19000
19001 {
19002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19003 }
19004 return resultobj;
19005 fail:
19006 return NULL;
19007 }
19008
19009
19010 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19011 PyObject *resultobj;
19012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19013 bool arg2 ;
19014 PyObject * obj0 = 0 ;
19015 PyObject * obj1 = 0 ;
19016 char *kwnames[] = {
19017 (char *) "self",(char *) "m_altDown", NULL
19018 };
19019
19020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19022 if (SWIG_arg_fail(1)) SWIG_fail;
19023 {
19024 arg2 = (bool)(SWIG_As_bool(obj1));
19025 if (SWIG_arg_fail(2)) SWIG_fail;
19026 }
19027 if (arg1) (arg1)->m_altDown = arg2;
19028
19029 Py_INCREF(Py_None); resultobj = Py_None;
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19037 PyObject *resultobj;
19038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19039 bool result;
19040 PyObject * obj0 = 0 ;
19041 char *kwnames[] = {
19042 (char *) "self", NULL
19043 };
19044
19045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19047 if (SWIG_arg_fail(1)) SWIG_fail;
19048 result = (bool) ((arg1)->m_altDown);
19049
19050 {
19051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19052 }
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj;
19061 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19062 bool arg2 ;
19063 PyObject * obj0 = 0 ;
19064 PyObject * obj1 = 0 ;
19065 char *kwnames[] = {
19066 (char *) "self",(char *) "m_metaDown", NULL
19067 };
19068
19069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19071 if (SWIG_arg_fail(1)) SWIG_fail;
19072 {
19073 arg2 = (bool)(SWIG_As_bool(obj1));
19074 if (SWIG_arg_fail(2)) SWIG_fail;
19075 }
19076 if (arg1) (arg1)->m_metaDown = arg2;
19077
19078 Py_INCREF(Py_None); resultobj = Py_None;
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj;
19087 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19088 bool result;
19089 PyObject * obj0 = 0 ;
19090 char *kwnames[] = {
19091 (char *) "self", NULL
19092 };
19093
19094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19096 if (SWIG_arg_fail(1)) SWIG_fail;
19097 result = (bool) ((arg1)->m_metaDown);
19098
19099 {
19100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19101 }
19102 return resultobj;
19103 fail:
19104 return NULL;
19105 }
19106
19107
19108 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19109 PyObject *resultobj;
19110 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19111 bool arg2 ;
19112 PyObject * obj0 = 0 ;
19113 PyObject * obj1 = 0 ;
19114 char *kwnames[] = {
19115 (char *) "self",(char *) "m_scanCode", NULL
19116 };
19117
19118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19120 if (SWIG_arg_fail(1)) SWIG_fail;
19121 {
19122 arg2 = (bool)(SWIG_As_bool(obj1));
19123 if (SWIG_arg_fail(2)) SWIG_fail;
19124 }
19125 if (arg1) (arg1)->m_scanCode = arg2;
19126
19127 Py_INCREF(Py_None); resultobj = Py_None;
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19135 PyObject *resultobj;
19136 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19137 bool result;
19138 PyObject * obj0 = 0 ;
19139 char *kwnames[] = {
19140 (char *) "self", NULL
19141 };
19142
19143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19145 if (SWIG_arg_fail(1)) SWIG_fail;
19146 result = (bool) ((arg1)->m_scanCode);
19147
19148 {
19149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19150 }
19151 return resultobj;
19152 fail:
19153 return NULL;
19154 }
19155
19156
19157 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19158 PyObject *resultobj;
19159 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19160 unsigned int arg2 ;
19161 PyObject * obj0 = 0 ;
19162 PyObject * obj1 = 0 ;
19163 char *kwnames[] = {
19164 (char *) "self",(char *) "m_rawCode", NULL
19165 };
19166
19167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19169 if (SWIG_arg_fail(1)) SWIG_fail;
19170 {
19171 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19172 if (SWIG_arg_fail(2)) SWIG_fail;
19173 }
19174 if (arg1) (arg1)->m_rawCode = arg2;
19175
19176 Py_INCREF(Py_None); resultobj = Py_None;
19177 return resultobj;
19178 fail:
19179 return NULL;
19180 }
19181
19182
19183 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19184 PyObject *resultobj;
19185 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19186 unsigned int result;
19187 PyObject * obj0 = 0 ;
19188 char *kwnames[] = {
19189 (char *) "self", NULL
19190 };
19191
19192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19194 if (SWIG_arg_fail(1)) SWIG_fail;
19195 result = (unsigned int) ((arg1)->m_rawCode);
19196
19197 {
19198 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19199 }
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19207 PyObject *resultobj;
19208 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19209 unsigned int arg2 ;
19210 PyObject * obj0 = 0 ;
19211 PyObject * obj1 = 0 ;
19212 char *kwnames[] = {
19213 (char *) "self",(char *) "m_rawFlags", NULL
19214 };
19215
19216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19218 if (SWIG_arg_fail(1)) SWIG_fail;
19219 {
19220 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19221 if (SWIG_arg_fail(2)) SWIG_fail;
19222 }
19223 if (arg1) (arg1)->m_rawFlags = arg2;
19224
19225 Py_INCREF(Py_None); resultobj = Py_None;
19226 return resultobj;
19227 fail:
19228 return NULL;
19229 }
19230
19231
19232 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19233 PyObject *resultobj;
19234 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19235 unsigned int result;
19236 PyObject * obj0 = 0 ;
19237 char *kwnames[] = {
19238 (char *) "self", NULL
19239 };
19240
19241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19243 if (SWIG_arg_fail(1)) SWIG_fail;
19244 result = (unsigned int) ((arg1)->m_rawFlags);
19245
19246 {
19247 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19248 }
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19256 PyObject *obj;
19257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19258 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19259 Py_INCREF(obj);
19260 return Py_BuildValue((char *)"");
19261 }
19262 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19263 PyObject *resultobj;
19264 wxSize const &arg1_defvalue = wxDefaultSize ;
19265 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19266 int arg2 = (int) 0 ;
19267 wxSizeEvent *result;
19268 wxSize temp1 ;
19269 PyObject * obj0 = 0 ;
19270 PyObject * obj1 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "sz",(char *) "winid", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19276 if (obj0) {
19277 {
19278 arg1 = &temp1;
19279 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19280 }
19281 }
19282 if (obj1) {
19283 {
19284 arg2 = (int)(SWIG_As_int(obj1));
19285 if (SWIG_arg_fail(2)) SWIG_fail;
19286 }
19287 }
19288 {
19289 PyThreadState* __tstate = wxPyBeginAllowThreads();
19290 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19291
19292 wxPyEndAllowThreads(__tstate);
19293 if (PyErr_Occurred()) SWIG_fail;
19294 }
19295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj;
19304 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19305 wxSize result;
19306 PyObject * obj0 = 0 ;
19307 char *kwnames[] = {
19308 (char *) "self", NULL
19309 };
19310
19311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19313 if (SWIG_arg_fail(1)) SWIG_fail;
19314 {
19315 PyThreadState* __tstate = wxPyBeginAllowThreads();
19316 result = ((wxSizeEvent const *)arg1)->GetSize();
19317
19318 wxPyEndAllowThreads(__tstate);
19319 if (PyErr_Occurred()) SWIG_fail;
19320 }
19321 {
19322 wxSize * resultptr;
19323 resultptr = new wxSize((wxSize &)(result));
19324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19325 }
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19333 PyObject *resultobj;
19334 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19335 wxRect result;
19336 PyObject * obj0 = 0 ;
19337 char *kwnames[] = {
19338 (char *) "self", NULL
19339 };
19340
19341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19343 if (SWIG_arg_fail(1)) SWIG_fail;
19344 {
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 result = ((wxSizeEvent const *)arg1)->GetRect();
19347
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 {
19352 wxRect * resultptr;
19353 resultptr = new wxRect((wxRect &)(result));
19354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19355 }
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj;
19364 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19365 wxRect arg2 ;
19366 PyObject * obj0 = 0 ;
19367 PyObject * obj1 = 0 ;
19368 char *kwnames[] = {
19369 (char *) "self",(char *) "rect", NULL
19370 };
19371
19372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19374 if (SWIG_arg_fail(1)) SWIG_fail;
19375 {
19376 wxRect * argp;
19377 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19378 if (SWIG_arg_fail(2)) SWIG_fail;
19379 if (argp == NULL) {
19380 SWIG_null_ref("wxRect");
19381 }
19382 if (SWIG_arg_fail(2)) SWIG_fail;
19383 arg2 = *argp;
19384 }
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 (arg1)->SetRect(arg2);
19388
19389 wxPyEndAllowThreads(__tstate);
19390 if (PyErr_Occurred()) SWIG_fail;
19391 }
19392 Py_INCREF(Py_None); resultobj = Py_None;
19393 return resultobj;
19394 fail:
19395 return NULL;
19396 }
19397
19398
19399 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19400 PyObject *resultobj;
19401 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19402 wxSize arg2 ;
19403 PyObject * obj0 = 0 ;
19404 PyObject * obj1 = 0 ;
19405 char *kwnames[] = {
19406 (char *) "self",(char *) "size", NULL
19407 };
19408
19409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19411 if (SWIG_arg_fail(1)) SWIG_fail;
19412 {
19413 wxSize * argp;
19414 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19415 if (SWIG_arg_fail(2)) SWIG_fail;
19416 if (argp == NULL) {
19417 SWIG_null_ref("wxSize");
19418 }
19419 if (SWIG_arg_fail(2)) SWIG_fail;
19420 arg2 = *argp;
19421 }
19422 {
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 wxSizeEvent_SetSize(arg1,arg2);
19425
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 Py_INCREF(Py_None); resultobj = Py_None;
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj;
19438 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19439 wxSize *arg2 = (wxSize *) 0 ;
19440 PyObject * obj0 = 0 ;
19441 PyObject * obj1 = 0 ;
19442 char *kwnames[] = {
19443 (char *) "self",(char *) "m_size", NULL
19444 };
19445
19446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19448 if (SWIG_arg_fail(1)) SWIG_fail;
19449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19450 if (SWIG_arg_fail(2)) SWIG_fail;
19451 if (arg1) (arg1)->m_size = *arg2;
19452
19453 Py_INCREF(Py_None); resultobj = Py_None;
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj;
19462 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19463 wxSize *result;
19464 PyObject * obj0 = 0 ;
19465 char *kwnames[] = {
19466 (char *) "self", NULL
19467 };
19468
19469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19471 if (SWIG_arg_fail(1)) SWIG_fail;
19472 result = (wxSize *)& ((arg1)->m_size);
19473
19474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19475 return resultobj;
19476 fail:
19477 return NULL;
19478 }
19479
19480
19481 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19482 PyObject *resultobj;
19483 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19484 wxRect *arg2 = (wxRect *) 0 ;
19485 PyObject * obj0 = 0 ;
19486 PyObject * obj1 = 0 ;
19487 char *kwnames[] = {
19488 (char *) "self",(char *) "m_rect", NULL
19489 };
19490
19491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19493 if (SWIG_arg_fail(1)) SWIG_fail;
19494 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19495 if (SWIG_arg_fail(2)) SWIG_fail;
19496 if (arg1) (arg1)->m_rect = *arg2;
19497
19498 Py_INCREF(Py_None); resultobj = Py_None;
19499 return resultobj;
19500 fail:
19501 return NULL;
19502 }
19503
19504
19505 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19506 PyObject *resultobj;
19507 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19508 wxRect *result;
19509 PyObject * obj0 = 0 ;
19510 char *kwnames[] = {
19511 (char *) "self", NULL
19512 };
19513
19514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19516 if (SWIG_arg_fail(1)) SWIG_fail;
19517 result = (wxRect *)& ((arg1)->m_rect);
19518
19519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19520 return resultobj;
19521 fail:
19522 return NULL;
19523 }
19524
19525
19526 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19527 PyObject *obj;
19528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19529 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19530 Py_INCREF(obj);
19531 return Py_BuildValue((char *)"");
19532 }
19533 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19534 PyObject *resultobj;
19535 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19536 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19537 int arg2 = (int) 0 ;
19538 wxMoveEvent *result;
19539 wxPoint temp1 ;
19540 PyObject * obj0 = 0 ;
19541 PyObject * obj1 = 0 ;
19542 char *kwnames[] = {
19543 (char *) "pos",(char *) "winid", NULL
19544 };
19545
19546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19547 if (obj0) {
19548 {
19549 arg1 = &temp1;
19550 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19551 }
19552 }
19553 if (obj1) {
19554 {
19555 arg2 = (int)(SWIG_As_int(obj1));
19556 if (SWIG_arg_fail(2)) SWIG_fail;
19557 }
19558 }
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19562
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19567 return resultobj;
19568 fail:
19569 return NULL;
19570 }
19571
19572
19573 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19574 PyObject *resultobj;
19575 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19576 wxPoint result;
19577 PyObject * obj0 = 0 ;
19578 char *kwnames[] = {
19579 (char *) "self", NULL
19580 };
19581
19582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19584 if (SWIG_arg_fail(1)) SWIG_fail;
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = ((wxMoveEvent const *)arg1)->GetPosition();
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 {
19593 wxPoint * resultptr;
19594 resultptr = new wxPoint((wxPoint &)(result));
19595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19596 }
19597 return resultobj;
19598 fail:
19599 return NULL;
19600 }
19601
19602
19603 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19604 PyObject *resultobj;
19605 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19606 wxRect result;
19607 PyObject * obj0 = 0 ;
19608 char *kwnames[] = {
19609 (char *) "self", NULL
19610 };
19611
19612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19614 if (SWIG_arg_fail(1)) SWIG_fail;
19615 {
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = ((wxMoveEvent const *)arg1)->GetRect();
19618
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 {
19623 wxRect * resultptr;
19624 resultptr = new wxRect((wxRect &)(result));
19625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19626 }
19627 return resultobj;
19628 fail:
19629 return NULL;
19630 }
19631
19632
19633 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19634 PyObject *resultobj;
19635 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19636 wxRect *arg2 = 0 ;
19637 wxRect temp2 ;
19638 PyObject * obj0 = 0 ;
19639 PyObject * obj1 = 0 ;
19640 char *kwnames[] = {
19641 (char *) "self",(char *) "rect", NULL
19642 };
19643
19644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19646 if (SWIG_arg_fail(1)) SWIG_fail;
19647 {
19648 arg2 = &temp2;
19649 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19650 }
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 (arg1)->SetRect((wxRect const &)*arg2);
19654
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 Py_INCREF(Py_None); resultobj = Py_None;
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19666 PyObject *resultobj;
19667 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19668 wxPoint *arg2 = 0 ;
19669 wxPoint temp2 ;
19670 PyObject * obj0 = 0 ;
19671 PyObject * obj1 = 0 ;
19672 char *kwnames[] = {
19673 (char *) "self",(char *) "pos", NULL
19674 };
19675
19676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19678 if (SWIG_arg_fail(1)) SWIG_fail;
19679 {
19680 arg2 = &temp2;
19681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19682 }
19683 {
19684 PyThreadState* __tstate = wxPyBeginAllowThreads();
19685 (arg1)->SetPosition((wxPoint const &)*arg2);
19686
19687 wxPyEndAllowThreads(__tstate);
19688 if (PyErr_Occurred()) SWIG_fail;
19689 }
19690 Py_INCREF(Py_None); resultobj = Py_None;
19691 return resultobj;
19692 fail:
19693 return NULL;
19694 }
19695
19696
19697 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19698 PyObject *obj;
19699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19700 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19701 Py_INCREF(obj);
19702 return Py_BuildValue((char *)"");
19703 }
19704 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19705 PyObject *resultobj;
19706 int arg1 = (int) 0 ;
19707 wxPaintEvent *result;
19708 PyObject * obj0 = 0 ;
19709 char *kwnames[] = {
19710 (char *) "Id", NULL
19711 };
19712
19713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19714 if (obj0) {
19715 {
19716 arg1 = (int)(SWIG_As_int(obj0));
19717 if (SWIG_arg_fail(1)) SWIG_fail;
19718 }
19719 }
19720 {
19721 PyThreadState* __tstate = wxPyBeginAllowThreads();
19722 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19723
19724 wxPyEndAllowThreads(__tstate);
19725 if (PyErr_Occurred()) SWIG_fail;
19726 }
19727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19735 PyObject *obj;
19736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19737 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19738 Py_INCREF(obj);
19739 return Py_BuildValue((char *)"");
19740 }
19741 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj;
19743 int arg1 = (int) 0 ;
19744 wxNcPaintEvent *result;
19745 PyObject * obj0 = 0 ;
19746 char *kwnames[] = {
19747 (char *) "winid", NULL
19748 };
19749
19750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19751 if (obj0) {
19752 {
19753 arg1 = (int)(SWIG_As_int(obj0));
19754 if (SWIG_arg_fail(1)) SWIG_fail;
19755 }
19756 }
19757 {
19758 PyThreadState* __tstate = wxPyBeginAllowThreads();
19759 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19760
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19765 return resultobj;
19766 fail:
19767 return NULL;
19768 }
19769
19770
19771 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19772 PyObject *obj;
19773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19774 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19775 Py_INCREF(obj);
19776 return Py_BuildValue((char *)"");
19777 }
19778 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19779 PyObject *resultobj;
19780 int arg1 = (int) 0 ;
19781 wxDC *arg2 = (wxDC *) NULL ;
19782 wxEraseEvent *result;
19783 PyObject * obj0 = 0 ;
19784 PyObject * obj1 = 0 ;
19785 char *kwnames[] = {
19786 (char *) "Id",(char *) "dc", NULL
19787 };
19788
19789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19790 if (obj0) {
19791 {
19792 arg1 = (int)(SWIG_As_int(obj0));
19793 if (SWIG_arg_fail(1)) SWIG_fail;
19794 }
19795 }
19796 if (obj1) {
19797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19798 if (SWIG_arg_fail(2)) SWIG_fail;
19799 }
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19803
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19815 PyObject *resultobj;
19816 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19817 wxDC *result;
19818 PyObject * obj0 = 0 ;
19819 char *kwnames[] = {
19820 (char *) "self", NULL
19821 };
19822
19823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19825 if (SWIG_arg_fail(1)) SWIG_fail;
19826 {
19827 PyThreadState* __tstate = wxPyBeginAllowThreads();
19828 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19829
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 resultobj = wxPyMake_wxObject(result, 0);
19835 }
19836 return resultobj;
19837 fail:
19838 return NULL;
19839 }
19840
19841
19842 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19843 PyObject *obj;
19844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19845 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19846 Py_INCREF(obj);
19847 return Py_BuildValue((char *)"");
19848 }
19849 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj;
19851 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19852 int arg2 = (int) 0 ;
19853 wxFocusEvent *result;
19854 PyObject * obj0 = 0 ;
19855 PyObject * obj1 = 0 ;
19856 char *kwnames[] = {
19857 (char *) "type",(char *) "winid", NULL
19858 };
19859
19860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19861 if (obj0) {
19862 {
19863 arg1 = (wxEventType)(SWIG_As_int(obj0));
19864 if (SWIG_arg_fail(1)) SWIG_fail;
19865 }
19866 }
19867 if (obj1) {
19868 {
19869 arg2 = (int)(SWIG_As_int(obj1));
19870 if (SWIG_arg_fail(2)) SWIG_fail;
19871 }
19872 }
19873 {
19874 PyThreadState* __tstate = wxPyBeginAllowThreads();
19875 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19876
19877 wxPyEndAllowThreads(__tstate);
19878 if (PyErr_Occurred()) SWIG_fail;
19879 }
19880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj;
19889 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19890 wxWindow *result;
19891 PyObject * obj0 = 0 ;
19892 char *kwnames[] = {
19893 (char *) "self", NULL
19894 };
19895
19896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19898 if (SWIG_arg_fail(1)) SWIG_fail;
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19902
19903 wxPyEndAllowThreads(__tstate);
19904 if (PyErr_Occurred()) SWIG_fail;
19905 }
19906 {
19907 resultobj = wxPyMake_wxObject(result, 0);
19908 }
19909 return resultobj;
19910 fail:
19911 return NULL;
19912 }
19913
19914
19915 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19916 PyObject *resultobj;
19917 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19918 wxWindow *arg2 = (wxWindow *) 0 ;
19919 PyObject * obj0 = 0 ;
19920 PyObject * obj1 = 0 ;
19921 char *kwnames[] = {
19922 (char *) "self",(char *) "win", NULL
19923 };
19924
19925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19927 if (SWIG_arg_fail(1)) SWIG_fail;
19928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19929 if (SWIG_arg_fail(2)) SWIG_fail;
19930 {
19931 PyThreadState* __tstate = wxPyBeginAllowThreads();
19932 (arg1)->SetWindow(arg2);
19933
19934 wxPyEndAllowThreads(__tstate);
19935 if (PyErr_Occurred()) SWIG_fail;
19936 }
19937 Py_INCREF(Py_None); resultobj = Py_None;
19938 return resultobj;
19939 fail:
19940 return NULL;
19941 }
19942
19943
19944 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19945 PyObject *obj;
19946 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19947 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19948 Py_INCREF(obj);
19949 return Py_BuildValue((char *)"");
19950 }
19951 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj;
19953 wxWindow *arg1 = (wxWindow *) NULL ;
19954 wxChildFocusEvent *result;
19955 PyObject * obj0 = 0 ;
19956 char *kwnames[] = {
19957 (char *) "win", NULL
19958 };
19959
19960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19961 if (obj0) {
19962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19963 if (SWIG_arg_fail(1)) SWIG_fail;
19964 }
19965 {
19966 PyThreadState* __tstate = wxPyBeginAllowThreads();
19967 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19968
19969 wxPyEndAllowThreads(__tstate);
19970 if (PyErr_Occurred()) SWIG_fail;
19971 }
19972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19980 PyObject *resultobj;
19981 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19982 wxWindow *result;
19983 PyObject * obj0 = 0 ;
19984 char *kwnames[] = {
19985 (char *) "self", NULL
19986 };
19987
19988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19990 if (SWIG_arg_fail(1)) SWIG_fail;
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19994
19995 wxPyEndAllowThreads(__tstate);
19996 if (PyErr_Occurred()) SWIG_fail;
19997 }
19998 {
19999 resultobj = wxPyMake_wxObject(result, 0);
20000 }
20001 return resultobj;
20002 fail:
20003 return NULL;
20004 }
20005
20006
20007 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20008 PyObject *obj;
20009 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20010 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20011 Py_INCREF(obj);
20012 return Py_BuildValue((char *)"");
20013 }
20014 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20015 PyObject *resultobj;
20016 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20017 bool arg2 = (bool) true ;
20018 int arg3 = (int) 0 ;
20019 wxActivateEvent *result;
20020 PyObject * obj0 = 0 ;
20021 PyObject * obj1 = 0 ;
20022 PyObject * obj2 = 0 ;
20023 char *kwnames[] = {
20024 (char *) "type",(char *) "active",(char *) "Id", NULL
20025 };
20026
20027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20028 if (obj0) {
20029 {
20030 arg1 = (wxEventType)(SWIG_As_int(obj0));
20031 if (SWIG_arg_fail(1)) SWIG_fail;
20032 }
20033 }
20034 if (obj1) {
20035 {
20036 arg2 = (bool)(SWIG_As_bool(obj1));
20037 if (SWIG_arg_fail(2)) SWIG_fail;
20038 }
20039 }
20040 if (obj2) {
20041 {
20042 arg3 = (int)(SWIG_As_int(obj2));
20043 if (SWIG_arg_fail(3)) SWIG_fail;
20044 }
20045 }
20046 {
20047 PyThreadState* __tstate = wxPyBeginAllowThreads();
20048 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20049
20050 wxPyEndAllowThreads(__tstate);
20051 if (PyErr_Occurred()) SWIG_fail;
20052 }
20053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20054 return resultobj;
20055 fail:
20056 return NULL;
20057 }
20058
20059
20060 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20061 PyObject *resultobj;
20062 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20063 bool result;
20064 PyObject * obj0 = 0 ;
20065 char *kwnames[] = {
20066 (char *) "self", NULL
20067 };
20068
20069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20071 if (SWIG_arg_fail(1)) SWIG_fail;
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20075
20076 wxPyEndAllowThreads(__tstate);
20077 if (PyErr_Occurred()) SWIG_fail;
20078 }
20079 {
20080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20081 }
20082 return resultobj;
20083 fail:
20084 return NULL;
20085 }
20086
20087
20088 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20089 PyObject *obj;
20090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20091 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20092 Py_INCREF(obj);
20093 return Py_BuildValue((char *)"");
20094 }
20095 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20096 PyObject *resultobj;
20097 int arg1 = (int) 0 ;
20098 wxInitDialogEvent *result;
20099 PyObject * obj0 = 0 ;
20100 char *kwnames[] = {
20101 (char *) "Id", NULL
20102 };
20103
20104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20105 if (obj0) {
20106 {
20107 arg1 = (int)(SWIG_As_int(obj0));
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 }
20110 }
20111 {
20112 PyThreadState* __tstate = wxPyBeginAllowThreads();
20113 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20114
20115 wxPyEndAllowThreads(__tstate);
20116 if (PyErr_Occurred()) SWIG_fail;
20117 }
20118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20119 return resultobj;
20120 fail:
20121 return NULL;
20122 }
20123
20124
20125 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20126 PyObject *obj;
20127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20128 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20129 Py_INCREF(obj);
20130 return Py_BuildValue((char *)"");
20131 }
20132 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj;
20134 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20135 int arg2 = (int) 0 ;
20136 wxMenu *arg3 = (wxMenu *) NULL ;
20137 wxMenuEvent *result;
20138 PyObject * obj0 = 0 ;
20139 PyObject * obj1 = 0 ;
20140 PyObject * obj2 = 0 ;
20141 char *kwnames[] = {
20142 (char *) "type",(char *) "winid",(char *) "menu", NULL
20143 };
20144
20145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20146 if (obj0) {
20147 {
20148 arg1 = (wxEventType)(SWIG_As_int(obj0));
20149 if (SWIG_arg_fail(1)) SWIG_fail;
20150 }
20151 }
20152 if (obj1) {
20153 {
20154 arg2 = (int)(SWIG_As_int(obj1));
20155 if (SWIG_arg_fail(2)) SWIG_fail;
20156 }
20157 }
20158 if (obj2) {
20159 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20160 if (SWIG_arg_fail(3)) SWIG_fail;
20161 }
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj;
20178 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20179 int result;
20180 PyObject * obj0 = 0 ;
20181 char *kwnames[] = {
20182 (char *) "self", NULL
20183 };
20184
20185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20187 if (SWIG_arg_fail(1)) SWIG_fail;
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20191
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 {
20196 resultobj = SWIG_From_int((int)(result));
20197 }
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj;
20206 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20207 bool result;
20208 PyObject * obj0 = 0 ;
20209 char *kwnames[] = {
20210 (char *) "self", NULL
20211 };
20212
20213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20215 if (SWIG_arg_fail(1)) SWIG_fail;
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20219
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 {
20224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20225 }
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20233 PyObject *resultobj;
20234 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20235 wxMenu *result;
20236 PyObject * obj0 = 0 ;
20237 char *kwnames[] = {
20238 (char *) "self", NULL
20239 };
20240
20241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20243 if (SWIG_arg_fail(1)) SWIG_fail;
20244 {
20245 PyThreadState* __tstate = wxPyBeginAllowThreads();
20246 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20247
20248 wxPyEndAllowThreads(__tstate);
20249 if (PyErr_Occurred()) SWIG_fail;
20250 }
20251 {
20252 resultobj = wxPyMake_wxObject(result, 0);
20253 }
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20261 PyObject *obj;
20262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20263 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20264 Py_INCREF(obj);
20265 return Py_BuildValue((char *)"");
20266 }
20267 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20268 PyObject *resultobj;
20269 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20270 int arg2 = (int) 0 ;
20271 wxCloseEvent *result;
20272 PyObject * obj0 = 0 ;
20273 PyObject * obj1 = 0 ;
20274 char *kwnames[] = {
20275 (char *) "type",(char *) "winid", NULL
20276 };
20277
20278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20279 if (obj0) {
20280 {
20281 arg1 = (wxEventType)(SWIG_As_int(obj0));
20282 if (SWIG_arg_fail(1)) SWIG_fail;
20283 }
20284 }
20285 if (obj1) {
20286 {
20287 arg2 = (int)(SWIG_As_int(obj1));
20288 if (SWIG_arg_fail(2)) SWIG_fail;
20289 }
20290 }
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20294
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20306 PyObject *resultobj;
20307 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20308 bool arg2 ;
20309 PyObject * obj0 = 0 ;
20310 PyObject * obj1 = 0 ;
20311 char *kwnames[] = {
20312 (char *) "self",(char *) "logOff", NULL
20313 };
20314
20315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20317 if (SWIG_arg_fail(1)) SWIG_fail;
20318 {
20319 arg2 = (bool)(SWIG_As_bool(obj1));
20320 if (SWIG_arg_fail(2)) SWIG_fail;
20321 }
20322 {
20323 PyThreadState* __tstate = wxPyBeginAllowThreads();
20324 (arg1)->SetLoggingOff(arg2);
20325
20326 wxPyEndAllowThreads(__tstate);
20327 if (PyErr_Occurred()) SWIG_fail;
20328 }
20329 Py_INCREF(Py_None); resultobj = Py_None;
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20337 PyObject *resultobj;
20338 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20339 bool result;
20340 PyObject * obj0 = 0 ;
20341 char *kwnames[] = {
20342 (char *) "self", NULL
20343 };
20344
20345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(1)) SWIG_fail;
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20351
20352 wxPyEndAllowThreads(__tstate);
20353 if (PyErr_Occurred()) SWIG_fail;
20354 }
20355 {
20356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20357 }
20358 return resultobj;
20359 fail:
20360 return NULL;
20361 }
20362
20363
20364 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20365 PyObject *resultobj;
20366 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20367 bool arg2 = (bool) true ;
20368 PyObject * obj0 = 0 ;
20369 PyObject * obj1 = 0 ;
20370 char *kwnames[] = {
20371 (char *) "self",(char *) "veto", NULL
20372 };
20373
20374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20376 if (SWIG_arg_fail(1)) SWIG_fail;
20377 if (obj1) {
20378 {
20379 arg2 = (bool)(SWIG_As_bool(obj1));
20380 if (SWIG_arg_fail(2)) SWIG_fail;
20381 }
20382 }
20383 {
20384 PyThreadState* __tstate = wxPyBeginAllowThreads();
20385 (arg1)->Veto(arg2);
20386
20387 wxPyEndAllowThreads(__tstate);
20388 if (PyErr_Occurred()) SWIG_fail;
20389 }
20390 Py_INCREF(Py_None); resultobj = Py_None;
20391 return resultobj;
20392 fail:
20393 return NULL;
20394 }
20395
20396
20397 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20398 PyObject *resultobj;
20399 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20400 bool result;
20401 PyObject * obj0 = 0 ;
20402 char *kwnames[] = {
20403 (char *) "self", NULL
20404 };
20405
20406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20408 if (SWIG_arg_fail(1)) SWIG_fail;
20409 {
20410 PyThreadState* __tstate = wxPyBeginAllowThreads();
20411 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20412
20413 wxPyEndAllowThreads(__tstate);
20414 if (PyErr_Occurred()) SWIG_fail;
20415 }
20416 {
20417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20418 }
20419 return resultobj;
20420 fail:
20421 return NULL;
20422 }
20423
20424
20425 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20426 PyObject *resultobj;
20427 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20428 bool arg2 ;
20429 PyObject * obj0 = 0 ;
20430 PyObject * obj1 = 0 ;
20431 char *kwnames[] = {
20432 (char *) "self",(char *) "canVeto", NULL
20433 };
20434
20435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20437 if (SWIG_arg_fail(1)) SWIG_fail;
20438 {
20439 arg2 = (bool)(SWIG_As_bool(obj1));
20440 if (SWIG_arg_fail(2)) SWIG_fail;
20441 }
20442 {
20443 PyThreadState* __tstate = wxPyBeginAllowThreads();
20444 (arg1)->SetCanVeto(arg2);
20445
20446 wxPyEndAllowThreads(__tstate);
20447 if (PyErr_Occurred()) SWIG_fail;
20448 }
20449 Py_INCREF(Py_None); resultobj = Py_None;
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20457 PyObject *resultobj;
20458 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20459 bool result;
20460 PyObject * obj0 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20467 if (SWIG_arg_fail(1)) SWIG_fail;
20468 {
20469 PyThreadState* __tstate = wxPyBeginAllowThreads();
20470 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20471
20472 wxPyEndAllowThreads(__tstate);
20473 if (PyErr_Occurred()) SWIG_fail;
20474 }
20475 {
20476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20477 }
20478 return resultobj;
20479 fail:
20480 return NULL;
20481 }
20482
20483
20484 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20485 PyObject *obj;
20486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20487 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20488 Py_INCREF(obj);
20489 return Py_BuildValue((char *)"");
20490 }
20491 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20492 PyObject *resultobj;
20493 int arg1 = (int) 0 ;
20494 bool arg2 = (bool) false ;
20495 wxShowEvent *result;
20496 PyObject * obj0 = 0 ;
20497 PyObject * obj1 = 0 ;
20498 char *kwnames[] = {
20499 (char *) "winid",(char *) "show", NULL
20500 };
20501
20502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20503 if (obj0) {
20504 {
20505 arg1 = (int)(SWIG_As_int(obj0));
20506 if (SWIG_arg_fail(1)) SWIG_fail;
20507 }
20508 }
20509 if (obj1) {
20510 {
20511 arg2 = (bool)(SWIG_As_bool(obj1));
20512 if (SWIG_arg_fail(2)) SWIG_fail;
20513 }
20514 }
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20518
20519 wxPyEndAllowThreads(__tstate);
20520 if (PyErr_Occurred()) SWIG_fail;
20521 }
20522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20523 return resultobj;
20524 fail:
20525 return NULL;
20526 }
20527
20528
20529 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20530 PyObject *resultobj;
20531 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20532 bool arg2 ;
20533 PyObject * obj0 = 0 ;
20534 PyObject * obj1 = 0 ;
20535 char *kwnames[] = {
20536 (char *) "self",(char *) "show", NULL
20537 };
20538
20539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20541 if (SWIG_arg_fail(1)) SWIG_fail;
20542 {
20543 arg2 = (bool)(SWIG_As_bool(obj1));
20544 if (SWIG_arg_fail(2)) SWIG_fail;
20545 }
20546 {
20547 PyThreadState* __tstate = wxPyBeginAllowThreads();
20548 (arg1)->SetShow(arg2);
20549
20550 wxPyEndAllowThreads(__tstate);
20551 if (PyErr_Occurred()) SWIG_fail;
20552 }
20553 Py_INCREF(Py_None); resultobj = Py_None;
20554 return resultobj;
20555 fail:
20556 return NULL;
20557 }
20558
20559
20560 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20561 PyObject *resultobj;
20562 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20563 bool result;
20564 PyObject * obj0 = 0 ;
20565 char *kwnames[] = {
20566 (char *) "self", NULL
20567 };
20568
20569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20571 if (SWIG_arg_fail(1)) SWIG_fail;
20572 {
20573 PyThreadState* __tstate = wxPyBeginAllowThreads();
20574 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20575
20576 wxPyEndAllowThreads(__tstate);
20577 if (PyErr_Occurred()) SWIG_fail;
20578 }
20579 {
20580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20581 }
20582 return resultobj;
20583 fail:
20584 return NULL;
20585 }
20586
20587
20588 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20589 PyObject *obj;
20590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20591 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20592 Py_INCREF(obj);
20593 return Py_BuildValue((char *)"");
20594 }
20595 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20596 PyObject *resultobj;
20597 int arg1 = (int) 0 ;
20598 bool arg2 = (bool) true ;
20599 wxIconizeEvent *result;
20600 PyObject * obj0 = 0 ;
20601 PyObject * obj1 = 0 ;
20602 char *kwnames[] = {
20603 (char *) "id",(char *) "iconized", NULL
20604 };
20605
20606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20607 if (obj0) {
20608 {
20609 arg1 = (int)(SWIG_As_int(obj0));
20610 if (SWIG_arg_fail(1)) SWIG_fail;
20611 }
20612 }
20613 if (obj1) {
20614 {
20615 arg2 = (bool)(SWIG_As_bool(obj1));
20616 if (SWIG_arg_fail(2)) SWIG_fail;
20617 }
20618 }
20619 {
20620 PyThreadState* __tstate = wxPyBeginAllowThreads();
20621 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20622
20623 wxPyEndAllowThreads(__tstate);
20624 if (PyErr_Occurred()) SWIG_fail;
20625 }
20626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20634 PyObject *resultobj;
20635 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20636 bool result;
20637 PyObject * obj0 = 0 ;
20638 char *kwnames[] = {
20639 (char *) "self", NULL
20640 };
20641
20642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20644 if (SWIG_arg_fail(1)) SWIG_fail;
20645 {
20646 PyThreadState* __tstate = wxPyBeginAllowThreads();
20647 result = (bool)(arg1)->Iconized();
20648
20649 wxPyEndAllowThreads(__tstate);
20650 if (PyErr_Occurred()) SWIG_fail;
20651 }
20652 {
20653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20654 }
20655 return resultobj;
20656 fail:
20657 return NULL;
20658 }
20659
20660
20661 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20662 PyObject *obj;
20663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20664 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20665 Py_INCREF(obj);
20666 return Py_BuildValue((char *)"");
20667 }
20668 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20669 PyObject *resultobj;
20670 int arg1 = (int) 0 ;
20671 wxMaximizeEvent *result;
20672 PyObject * obj0 = 0 ;
20673 char *kwnames[] = {
20674 (char *) "id", NULL
20675 };
20676
20677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20678 if (obj0) {
20679 {
20680 arg1 = (int)(SWIG_As_int(obj0));
20681 if (SWIG_arg_fail(1)) SWIG_fail;
20682 }
20683 }
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20687
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20699 PyObject *obj;
20700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20701 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20702 Py_INCREF(obj);
20703 return Py_BuildValue((char *)"");
20704 }
20705 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20706 PyObject *resultobj;
20707 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20708 wxPoint result;
20709 PyObject * obj0 = 0 ;
20710 char *kwnames[] = {
20711 (char *) "self", NULL
20712 };
20713
20714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20716 if (SWIG_arg_fail(1)) SWIG_fail;
20717 {
20718 PyThreadState* __tstate = wxPyBeginAllowThreads();
20719 result = (arg1)->GetPosition();
20720
20721 wxPyEndAllowThreads(__tstate);
20722 if (PyErr_Occurred()) SWIG_fail;
20723 }
20724 {
20725 wxPoint * resultptr;
20726 resultptr = new wxPoint((wxPoint &)(result));
20727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20736 PyObject *resultobj;
20737 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20738 int result;
20739 PyObject * obj0 = 0 ;
20740 char *kwnames[] = {
20741 (char *) "self", NULL
20742 };
20743
20744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20746 if (SWIG_arg_fail(1)) SWIG_fail;
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 result = (int)(arg1)->GetNumberOfFiles();
20750
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 {
20755 resultobj = SWIG_From_int((int)(result));
20756 }
20757 return resultobj;
20758 fail:
20759 return NULL;
20760 }
20761
20762
20763 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20764 PyObject *resultobj;
20765 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20766 PyObject *result;
20767 PyObject * obj0 = 0 ;
20768 char *kwnames[] = {
20769 (char *) "self", NULL
20770 };
20771
20772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20774 if (SWIG_arg_fail(1)) SWIG_fail;
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20778
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 resultobj = result;
20783 return resultobj;
20784 fail:
20785 return NULL;
20786 }
20787
20788
20789 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20790 PyObject *obj;
20791 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20792 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20793 Py_INCREF(obj);
20794 return Py_BuildValue((char *)"");
20795 }
20796 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20797 PyObject *resultobj;
20798 int arg1 = (int) 0 ;
20799 wxUpdateUIEvent *result;
20800 PyObject * obj0 = 0 ;
20801 char *kwnames[] = {
20802 (char *) "commandId", NULL
20803 };
20804
20805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20806 if (obj0) {
20807 {
20808 arg1 = (int)(SWIG_As_int(obj0));
20809 if (SWIG_arg_fail(1)) SWIG_fail;
20810 }
20811 }
20812 {
20813 PyThreadState* __tstate = wxPyBeginAllowThreads();
20814 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20815
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj;
20828 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20829 bool result;
20830 PyObject * obj0 = 0 ;
20831 char *kwnames[] = {
20832 (char *) "self", NULL
20833 };
20834
20835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20837 if (SWIG_arg_fail(1)) SWIG_fail;
20838 {
20839 PyThreadState* __tstate = wxPyBeginAllowThreads();
20840 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20841
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 {
20846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20847 }
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20855 PyObject *resultobj;
20856 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20857 bool result;
20858 PyObject * obj0 = 0 ;
20859 char *kwnames[] = {
20860 (char *) "self", NULL
20861 };
20862
20863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20865 if (SWIG_arg_fail(1)) SWIG_fail;
20866 {
20867 PyThreadState* __tstate = wxPyBeginAllowThreads();
20868 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20869
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 {
20874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20875 }
20876 return resultobj;
20877 fail:
20878 return NULL;
20879 }
20880
20881
20882 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20883 PyObject *resultobj;
20884 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20885 wxString result;
20886 PyObject * obj0 = 0 ;
20887 char *kwnames[] = {
20888 (char *) "self", NULL
20889 };
20890
20891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20893 if (SWIG_arg_fail(1)) SWIG_fail;
20894 {
20895 PyThreadState* __tstate = wxPyBeginAllowThreads();
20896 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20897
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 {
20902 #if wxUSE_UNICODE
20903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20904 #else
20905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20906 #endif
20907 }
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20915 PyObject *resultobj;
20916 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20917 bool result;
20918 PyObject * obj0 = 0 ;
20919 char *kwnames[] = {
20920 (char *) "self", NULL
20921 };
20922
20923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20925 if (SWIG_arg_fail(1)) SWIG_fail;
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20929
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 {
20934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20935 }
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20943 PyObject *resultobj;
20944 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20945 bool result;
20946 PyObject * obj0 = 0 ;
20947 char *kwnames[] = {
20948 (char *) "self", NULL
20949 };
20950
20951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20953 if (SWIG_arg_fail(1)) SWIG_fail;
20954 {
20955 PyThreadState* __tstate = wxPyBeginAllowThreads();
20956 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20957
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 {
20962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20963 }
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj;
20972 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20973 bool result;
20974 PyObject * obj0 = 0 ;
20975 char *kwnames[] = {
20976 (char *) "self", NULL
20977 };
20978
20979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20981 if (SWIG_arg_fail(1)) SWIG_fail;
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20985
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 {
20990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20991 }
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20999 PyObject *resultobj;
21000 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21001 bool arg2 ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 char *kwnames[] = {
21005 (char *) "self",(char *) "check", NULL
21006 };
21007
21008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21010 if (SWIG_arg_fail(1)) SWIG_fail;
21011 {
21012 arg2 = (bool)(SWIG_As_bool(obj1));
21013 if (SWIG_arg_fail(2)) SWIG_fail;
21014 }
21015 {
21016 PyThreadState* __tstate = wxPyBeginAllowThreads();
21017 (arg1)->Check(arg2);
21018
21019 wxPyEndAllowThreads(__tstate);
21020 if (PyErr_Occurred()) SWIG_fail;
21021 }
21022 Py_INCREF(Py_None); resultobj = Py_None;
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21030 PyObject *resultobj;
21031 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21032 bool arg2 ;
21033 PyObject * obj0 = 0 ;
21034 PyObject * obj1 = 0 ;
21035 char *kwnames[] = {
21036 (char *) "self",(char *) "enable", NULL
21037 };
21038
21039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21041 if (SWIG_arg_fail(1)) SWIG_fail;
21042 {
21043 arg2 = (bool)(SWIG_As_bool(obj1));
21044 if (SWIG_arg_fail(2)) SWIG_fail;
21045 }
21046 {
21047 PyThreadState* __tstate = wxPyBeginAllowThreads();
21048 (arg1)->Enable(arg2);
21049
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 Py_INCREF(Py_None); resultobj = Py_None;
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj;
21062 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21063 wxString *arg2 = 0 ;
21064 bool temp2 = false ;
21065 PyObject * obj0 = 0 ;
21066 PyObject * obj1 = 0 ;
21067 char *kwnames[] = {
21068 (char *) "self",(char *) "text", NULL
21069 };
21070
21071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21073 if (SWIG_arg_fail(1)) SWIG_fail;
21074 {
21075 arg2 = wxString_in_helper(obj1);
21076 if (arg2 == NULL) SWIG_fail;
21077 temp2 = true;
21078 }
21079 {
21080 PyThreadState* __tstate = wxPyBeginAllowThreads();
21081 (arg1)->SetText((wxString const &)*arg2);
21082
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 Py_INCREF(Py_None); resultobj = Py_None;
21087 {
21088 if (temp2)
21089 delete arg2;
21090 }
21091 return resultobj;
21092 fail:
21093 {
21094 if (temp2)
21095 delete arg2;
21096 }
21097 return NULL;
21098 }
21099
21100
21101 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21102 PyObject *resultobj;
21103 long arg1 ;
21104 PyObject * obj0 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "updateInterval", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21110 {
21111 arg1 = (long)(SWIG_As_long(obj0));
21112 if (SWIG_arg_fail(1)) SWIG_fail;
21113 }
21114 {
21115 PyThreadState* __tstate = wxPyBeginAllowThreads();
21116 wxUpdateUIEvent::SetUpdateInterval(arg1);
21117
21118 wxPyEndAllowThreads(__tstate);
21119 if (PyErr_Occurred()) SWIG_fail;
21120 }
21121 Py_INCREF(Py_None); resultobj = Py_None;
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21129 PyObject *resultobj;
21130 long result;
21131 char *kwnames[] = {
21132 NULL
21133 };
21134
21135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21136 {
21137 PyThreadState* __tstate = wxPyBeginAllowThreads();
21138 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21139
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 {
21144 resultobj = SWIG_From_long((long)(result));
21145 }
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21153 PyObject *resultobj;
21154 wxWindow *arg1 = (wxWindow *) 0 ;
21155 bool result;
21156 PyObject * obj0 = 0 ;
21157 char *kwnames[] = {
21158 (char *) "win", NULL
21159 };
21160
21161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21163 if (SWIG_arg_fail(1)) SWIG_fail;
21164 {
21165 PyThreadState* __tstate = wxPyBeginAllowThreads();
21166 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21167
21168 wxPyEndAllowThreads(__tstate);
21169 if (PyErr_Occurred()) SWIG_fail;
21170 }
21171 {
21172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21173 }
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21181 PyObject *resultobj;
21182 char *kwnames[] = {
21183 NULL
21184 };
21185
21186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 wxUpdateUIEvent::ResetUpdateTime();
21190
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 Py_INCREF(Py_None); resultobj = Py_None;
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21202 PyObject *resultobj;
21203 wxUpdateUIMode arg1 ;
21204 PyObject * obj0 = 0 ;
21205 char *kwnames[] = {
21206 (char *) "mode", NULL
21207 };
21208
21209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21210 {
21211 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21212 if (SWIG_arg_fail(1)) SWIG_fail;
21213 }
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21217
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 Py_INCREF(Py_None); resultobj = Py_None;
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21229 PyObject *resultobj;
21230 wxUpdateUIMode result;
21231 char *kwnames[] = {
21232 NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21236 {
21237 PyThreadState* __tstate = wxPyBeginAllowThreads();
21238 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21239
21240 wxPyEndAllowThreads(__tstate);
21241 if (PyErr_Occurred()) SWIG_fail;
21242 }
21243 resultobj = SWIG_From_int((result));
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21251 PyObject *obj;
21252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21253 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21254 Py_INCREF(obj);
21255 return Py_BuildValue((char *)"");
21256 }
21257 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21258 PyObject *resultobj;
21259 wxSysColourChangedEvent *result;
21260 char *kwnames[] = {
21261 NULL
21262 };
21263
21264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21265 {
21266 PyThreadState* __tstate = wxPyBeginAllowThreads();
21267 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21268
21269 wxPyEndAllowThreads(__tstate);
21270 if (PyErr_Occurred()) SWIG_fail;
21271 }
21272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21280 PyObject *obj;
21281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21282 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21283 Py_INCREF(obj);
21284 return Py_BuildValue((char *)"");
21285 }
21286 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21287 PyObject *resultobj;
21288 int arg1 = (int) 0 ;
21289 wxWindow *arg2 = (wxWindow *) NULL ;
21290 wxMouseCaptureChangedEvent *result;
21291 PyObject * obj0 = 0 ;
21292 PyObject * obj1 = 0 ;
21293 char *kwnames[] = {
21294 (char *) "winid",(char *) "gainedCapture", NULL
21295 };
21296
21297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21298 if (obj0) {
21299 {
21300 arg1 = (int)(SWIG_As_int(obj0));
21301 if (SWIG_arg_fail(1)) SWIG_fail;
21302 }
21303 }
21304 if (obj1) {
21305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21306 if (SWIG_arg_fail(2)) SWIG_fail;
21307 }
21308 {
21309 PyThreadState* __tstate = wxPyBeginAllowThreads();
21310 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21311
21312 wxPyEndAllowThreads(__tstate);
21313 if (PyErr_Occurred()) SWIG_fail;
21314 }
21315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj;
21324 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21325 wxWindow *result;
21326 PyObject * obj0 = 0 ;
21327 char *kwnames[] = {
21328 (char *) "self", NULL
21329 };
21330
21331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21333 if (SWIG_arg_fail(1)) SWIG_fail;
21334 {
21335 PyThreadState* __tstate = wxPyBeginAllowThreads();
21336 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21337
21338 wxPyEndAllowThreads(__tstate);
21339 if (PyErr_Occurred()) SWIG_fail;
21340 }
21341 {
21342 resultobj = wxPyMake_wxObject(result, 0);
21343 }
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21351 PyObject *obj;
21352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21353 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21354 Py_INCREF(obj);
21355 return Py_BuildValue((char *)"");
21356 }
21357 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21358 PyObject *resultobj;
21359 wxDisplayChangedEvent *result;
21360 char *kwnames[] = {
21361 NULL
21362 };
21363
21364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21368
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21373 return resultobj;
21374 fail:
21375 return NULL;
21376 }
21377
21378
21379 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21380 PyObject *obj;
21381 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21382 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21383 Py_INCREF(obj);
21384 return Py_BuildValue((char *)"");
21385 }
21386 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21387 PyObject *resultobj;
21388 int arg1 = (int) 0 ;
21389 wxPaletteChangedEvent *result;
21390 PyObject * obj0 = 0 ;
21391 char *kwnames[] = {
21392 (char *) "id", NULL
21393 };
21394
21395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21396 if (obj0) {
21397 {
21398 arg1 = (int)(SWIG_As_int(obj0));
21399 if (SWIG_arg_fail(1)) SWIG_fail;
21400 }
21401 }
21402 {
21403 PyThreadState* __tstate = wxPyBeginAllowThreads();
21404 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21405
21406 wxPyEndAllowThreads(__tstate);
21407 if (PyErr_Occurred()) SWIG_fail;
21408 }
21409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21410 return resultobj;
21411 fail:
21412 return NULL;
21413 }
21414
21415
21416 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21417 PyObject *resultobj;
21418 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21419 wxWindow *arg2 = (wxWindow *) 0 ;
21420 PyObject * obj0 = 0 ;
21421 PyObject * obj1 = 0 ;
21422 char *kwnames[] = {
21423 (char *) "self",(char *) "win", NULL
21424 };
21425
21426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21428 if (SWIG_arg_fail(1)) SWIG_fail;
21429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21430 if (SWIG_arg_fail(2)) SWIG_fail;
21431 {
21432 PyThreadState* __tstate = wxPyBeginAllowThreads();
21433 (arg1)->SetChangedWindow(arg2);
21434
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 Py_INCREF(Py_None); resultobj = Py_None;
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21446 PyObject *resultobj;
21447 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21448 wxWindow *result;
21449 PyObject * obj0 = 0 ;
21450 char *kwnames[] = {
21451 (char *) "self", NULL
21452 };
21453
21454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21456 if (SWIG_arg_fail(1)) SWIG_fail;
21457 {
21458 PyThreadState* __tstate = wxPyBeginAllowThreads();
21459 result = (wxWindow *)(arg1)->GetChangedWindow();
21460
21461 wxPyEndAllowThreads(__tstate);
21462 if (PyErr_Occurred()) SWIG_fail;
21463 }
21464 {
21465 resultobj = wxPyMake_wxObject(result, 0);
21466 }
21467 return resultobj;
21468 fail:
21469 return NULL;
21470 }
21471
21472
21473 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21474 PyObject *obj;
21475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21476 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21477 Py_INCREF(obj);
21478 return Py_BuildValue((char *)"");
21479 }
21480 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21481 PyObject *resultobj;
21482 int arg1 = (int) 0 ;
21483 wxQueryNewPaletteEvent *result;
21484 PyObject * obj0 = 0 ;
21485 char *kwnames[] = {
21486 (char *) "winid", NULL
21487 };
21488
21489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21490 if (obj0) {
21491 {
21492 arg1 = (int)(SWIG_As_int(obj0));
21493 if (SWIG_arg_fail(1)) SWIG_fail;
21494 }
21495 }
21496 {
21497 PyThreadState* __tstate = wxPyBeginAllowThreads();
21498 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21499
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21504 return resultobj;
21505 fail:
21506 return NULL;
21507 }
21508
21509
21510 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21511 PyObject *resultobj;
21512 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21513 bool arg2 ;
21514 PyObject * obj0 = 0 ;
21515 PyObject * obj1 = 0 ;
21516 char *kwnames[] = {
21517 (char *) "self",(char *) "realized", NULL
21518 };
21519
21520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21522 if (SWIG_arg_fail(1)) SWIG_fail;
21523 {
21524 arg2 = (bool)(SWIG_As_bool(obj1));
21525 if (SWIG_arg_fail(2)) SWIG_fail;
21526 }
21527 {
21528 PyThreadState* __tstate = wxPyBeginAllowThreads();
21529 (arg1)->SetPaletteRealized(arg2);
21530
21531 wxPyEndAllowThreads(__tstate);
21532 if (PyErr_Occurred()) SWIG_fail;
21533 }
21534 Py_INCREF(Py_None); resultobj = Py_None;
21535 return resultobj;
21536 fail:
21537 return NULL;
21538 }
21539
21540
21541 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21542 PyObject *resultobj;
21543 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21544 bool result;
21545 PyObject * obj0 = 0 ;
21546 char *kwnames[] = {
21547 (char *) "self", NULL
21548 };
21549
21550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21552 if (SWIG_arg_fail(1)) SWIG_fail;
21553 {
21554 PyThreadState* __tstate = wxPyBeginAllowThreads();
21555 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21556
21557 wxPyEndAllowThreads(__tstate);
21558 if (PyErr_Occurred()) SWIG_fail;
21559 }
21560 {
21561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21562 }
21563 return resultobj;
21564 fail:
21565 return NULL;
21566 }
21567
21568
21569 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21570 PyObject *obj;
21571 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21572 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21573 Py_INCREF(obj);
21574 return Py_BuildValue((char *)"");
21575 }
21576 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21577 PyObject *resultobj;
21578 wxNavigationKeyEvent *result;
21579 char *kwnames[] = {
21580 NULL
21581 };
21582
21583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21584 {
21585 PyThreadState* __tstate = wxPyBeginAllowThreads();
21586 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21587
21588 wxPyEndAllowThreads(__tstate);
21589 if (PyErr_Occurred()) SWIG_fail;
21590 }
21591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21592 return resultobj;
21593 fail:
21594 return NULL;
21595 }
21596
21597
21598 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21599 PyObject *resultobj;
21600 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21601 bool result;
21602 PyObject * obj0 = 0 ;
21603 char *kwnames[] = {
21604 (char *) "self", NULL
21605 };
21606
21607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21609 if (SWIG_arg_fail(1)) SWIG_fail;
21610 {
21611 PyThreadState* __tstate = wxPyBeginAllowThreads();
21612 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21613
21614 wxPyEndAllowThreads(__tstate);
21615 if (PyErr_Occurred()) SWIG_fail;
21616 }
21617 {
21618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21619 }
21620 return resultobj;
21621 fail:
21622 return NULL;
21623 }
21624
21625
21626 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21627 PyObject *resultobj;
21628 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21629 bool arg2 ;
21630 PyObject * obj0 = 0 ;
21631 PyObject * obj1 = 0 ;
21632 char *kwnames[] = {
21633 (char *) "self",(char *) "forward", NULL
21634 };
21635
21636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21638 if (SWIG_arg_fail(1)) SWIG_fail;
21639 {
21640 arg2 = (bool)(SWIG_As_bool(obj1));
21641 if (SWIG_arg_fail(2)) SWIG_fail;
21642 }
21643 {
21644 PyThreadState* __tstate = wxPyBeginAllowThreads();
21645 (arg1)->SetDirection(arg2);
21646
21647 wxPyEndAllowThreads(__tstate);
21648 if (PyErr_Occurred()) SWIG_fail;
21649 }
21650 Py_INCREF(Py_None); resultobj = Py_None;
21651 return resultobj;
21652 fail:
21653 return NULL;
21654 }
21655
21656
21657 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj;
21659 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21660 bool result;
21661 PyObject * obj0 = 0 ;
21662 char *kwnames[] = {
21663 (char *) "self", NULL
21664 };
21665
21666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21668 if (SWIG_arg_fail(1)) SWIG_fail;
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21672
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 {
21677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21678 }
21679 return resultobj;
21680 fail:
21681 return NULL;
21682 }
21683
21684
21685 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21686 PyObject *resultobj;
21687 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21688 bool arg2 ;
21689 PyObject * obj0 = 0 ;
21690 PyObject * obj1 = 0 ;
21691 char *kwnames[] = {
21692 (char *) "self",(char *) "ischange", NULL
21693 };
21694
21695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21697 if (SWIG_arg_fail(1)) SWIG_fail;
21698 {
21699 arg2 = (bool)(SWIG_As_bool(obj1));
21700 if (SWIG_arg_fail(2)) SWIG_fail;
21701 }
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 (arg1)->SetWindowChange(arg2);
21705
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 Py_INCREF(Py_None); resultobj = Py_None;
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21719 bool result;
21720 PyObject * obj0 = 0 ;
21721 char *kwnames[] = {
21722 (char *) "self", NULL
21723 };
21724
21725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21727 if (SWIG_arg_fail(1)) SWIG_fail;
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21731
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21737 }
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj;
21746 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21747 bool arg2 ;
21748 PyObject * obj0 = 0 ;
21749 PyObject * obj1 = 0 ;
21750 char *kwnames[] = {
21751 (char *) "self",(char *) "bIs", NULL
21752 };
21753
21754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21756 if (SWIG_arg_fail(1)) SWIG_fail;
21757 {
21758 arg2 = (bool)(SWIG_As_bool(obj1));
21759 if (SWIG_arg_fail(2)) SWIG_fail;
21760 }
21761 {
21762 PyThreadState* __tstate = wxPyBeginAllowThreads();
21763 (arg1)->SetFromTab(arg2);
21764
21765 wxPyEndAllowThreads(__tstate);
21766 if (PyErr_Occurred()) SWIG_fail;
21767 }
21768 Py_INCREF(Py_None); resultobj = Py_None;
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21776 PyObject *resultobj;
21777 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21778 long arg2 ;
21779 PyObject * obj0 = 0 ;
21780 PyObject * obj1 = 0 ;
21781 char *kwnames[] = {
21782 (char *) "self",(char *) "flags", NULL
21783 };
21784
21785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21787 if (SWIG_arg_fail(1)) SWIG_fail;
21788 {
21789 arg2 = (long)(SWIG_As_long(obj1));
21790 if (SWIG_arg_fail(2)) SWIG_fail;
21791 }
21792 {
21793 PyThreadState* __tstate = wxPyBeginAllowThreads();
21794 (arg1)->SetFlags(arg2);
21795
21796 wxPyEndAllowThreads(__tstate);
21797 if (PyErr_Occurred()) SWIG_fail;
21798 }
21799 Py_INCREF(Py_None); resultobj = Py_None;
21800 return resultobj;
21801 fail:
21802 return NULL;
21803 }
21804
21805
21806 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21807 PyObject *resultobj;
21808 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21809 wxWindow *result;
21810 PyObject * obj0 = 0 ;
21811 char *kwnames[] = {
21812 (char *) "self", NULL
21813 };
21814
21815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21817 if (SWIG_arg_fail(1)) SWIG_fail;
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 {
21826 resultobj = wxPyMake_wxObject(result, 0);
21827 }
21828 return resultobj;
21829 fail:
21830 return NULL;
21831 }
21832
21833
21834 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21835 PyObject *resultobj;
21836 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21837 wxWindow *arg2 = (wxWindow *) 0 ;
21838 PyObject * obj0 = 0 ;
21839 PyObject * obj1 = 0 ;
21840 char *kwnames[] = {
21841 (char *) "self",(char *) "win", NULL
21842 };
21843
21844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21846 if (SWIG_arg_fail(1)) SWIG_fail;
21847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21848 if (SWIG_arg_fail(2)) SWIG_fail;
21849 {
21850 PyThreadState* __tstate = wxPyBeginAllowThreads();
21851 (arg1)->SetCurrentFocus(arg2);
21852
21853 wxPyEndAllowThreads(__tstate);
21854 if (PyErr_Occurred()) SWIG_fail;
21855 }
21856 Py_INCREF(Py_None); resultobj = Py_None;
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21864 PyObject *obj;
21865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21866 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21867 Py_INCREF(obj);
21868 return Py_BuildValue((char *)"");
21869 }
21870 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21871 PyObject *resultobj;
21872 wxWindow *arg1 = (wxWindow *) NULL ;
21873 wxWindowCreateEvent *result;
21874 PyObject * obj0 = 0 ;
21875 char *kwnames[] = {
21876 (char *) "win", NULL
21877 };
21878
21879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21880 if (obj0) {
21881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21882 if (SWIG_arg_fail(1)) SWIG_fail;
21883 }
21884 {
21885 PyThreadState* __tstate = wxPyBeginAllowThreads();
21886 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21887
21888 wxPyEndAllowThreads(__tstate);
21889 if (PyErr_Occurred()) SWIG_fail;
21890 }
21891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21892 return resultobj;
21893 fail:
21894 return NULL;
21895 }
21896
21897
21898 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21899 PyObject *resultobj;
21900 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21901 wxWindow *result;
21902 PyObject * obj0 = 0 ;
21903 char *kwnames[] = {
21904 (char *) "self", NULL
21905 };
21906
21907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21909 if (SWIG_arg_fail(1)) SWIG_fail;
21910 {
21911 PyThreadState* __tstate = wxPyBeginAllowThreads();
21912 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21913
21914 wxPyEndAllowThreads(__tstate);
21915 if (PyErr_Occurred()) SWIG_fail;
21916 }
21917 {
21918 resultobj = wxPyMake_wxObject(result, 0);
21919 }
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21927 PyObject *obj;
21928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21929 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21930 Py_INCREF(obj);
21931 return Py_BuildValue((char *)"");
21932 }
21933 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21934 PyObject *resultobj;
21935 wxWindow *arg1 = (wxWindow *) NULL ;
21936 wxWindowDestroyEvent *result;
21937 PyObject * obj0 = 0 ;
21938 char *kwnames[] = {
21939 (char *) "win", NULL
21940 };
21941
21942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21943 if (obj0) {
21944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21945 if (SWIG_arg_fail(1)) SWIG_fail;
21946 }
21947 {
21948 PyThreadState* __tstate = wxPyBeginAllowThreads();
21949 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21950
21951 wxPyEndAllowThreads(__tstate);
21952 if (PyErr_Occurred()) SWIG_fail;
21953 }
21954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21955 return resultobj;
21956 fail:
21957 return NULL;
21958 }
21959
21960
21961 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21962 PyObject *resultobj;
21963 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21964 wxWindow *result;
21965 PyObject * obj0 = 0 ;
21966 char *kwnames[] = {
21967 (char *) "self", NULL
21968 };
21969
21970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21972 if (SWIG_arg_fail(1)) SWIG_fail;
21973 {
21974 PyThreadState* __tstate = wxPyBeginAllowThreads();
21975 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21976
21977 wxPyEndAllowThreads(__tstate);
21978 if (PyErr_Occurred()) SWIG_fail;
21979 }
21980 {
21981 resultobj = wxPyMake_wxObject(result, 0);
21982 }
21983 return resultobj;
21984 fail:
21985 return NULL;
21986 }
21987
21988
21989 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21990 PyObject *obj;
21991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21992 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21993 Py_INCREF(obj);
21994 return Py_BuildValue((char *)"");
21995 }
21996 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21997 PyObject *resultobj;
21998 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21999 int arg2 = (int) 0 ;
22000 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22001 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22002 wxContextMenuEvent *result;
22003 wxPoint temp3 ;
22004 PyObject * obj0 = 0 ;
22005 PyObject * obj1 = 0 ;
22006 PyObject * obj2 = 0 ;
22007 char *kwnames[] = {
22008 (char *) "type",(char *) "winid",(char *) "pt", NULL
22009 };
22010
22011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22012 if (obj0) {
22013 {
22014 arg1 = (wxEventType)(SWIG_As_int(obj0));
22015 if (SWIG_arg_fail(1)) SWIG_fail;
22016 }
22017 }
22018 if (obj1) {
22019 {
22020 arg2 = (int)(SWIG_As_int(obj1));
22021 if (SWIG_arg_fail(2)) SWIG_fail;
22022 }
22023 }
22024 if (obj2) {
22025 {
22026 arg3 = &temp3;
22027 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22028 }
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22033
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22038 return resultobj;
22039 fail:
22040 return NULL;
22041 }
22042
22043
22044 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22045 PyObject *resultobj;
22046 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22047 wxPoint *result;
22048 PyObject * obj0 = 0 ;
22049 char *kwnames[] = {
22050 (char *) "self", NULL
22051 };
22052
22053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22055 if (SWIG_arg_fail(1)) SWIG_fail;
22056 {
22057 PyThreadState* __tstate = wxPyBeginAllowThreads();
22058 {
22059 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22060 result = (wxPoint *) &_result_ref;
22061 }
22062
22063 wxPyEndAllowThreads(__tstate);
22064 if (PyErr_Occurred()) SWIG_fail;
22065 }
22066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22067 return resultobj;
22068 fail:
22069 return NULL;
22070 }
22071
22072
22073 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22074 PyObject *resultobj;
22075 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22076 wxPoint *arg2 = 0 ;
22077 wxPoint temp2 ;
22078 PyObject * obj0 = 0 ;
22079 PyObject * obj1 = 0 ;
22080 char *kwnames[] = {
22081 (char *) "self",(char *) "pos", NULL
22082 };
22083
22084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22086 if (SWIG_arg_fail(1)) SWIG_fail;
22087 {
22088 arg2 = &temp2;
22089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22090 }
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 (arg1)->SetPosition((wxPoint const &)*arg2);
22094
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 Py_INCREF(Py_None); resultobj = Py_None;
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22106 PyObject *obj;
22107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22108 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22109 Py_INCREF(obj);
22110 return Py_BuildValue((char *)"");
22111 }
22112 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22113 PyObject *resultobj;
22114 wxIdleEvent *result;
22115 char *kwnames[] = {
22116 NULL
22117 };
22118
22119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (wxIdleEvent *)new wxIdleEvent();
22123
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22128 return resultobj;
22129 fail:
22130 return NULL;
22131 }
22132
22133
22134 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22135 PyObject *resultobj;
22136 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22137 bool arg2 = (bool) true ;
22138 PyObject * obj0 = 0 ;
22139 PyObject * obj1 = 0 ;
22140 char *kwnames[] = {
22141 (char *) "self",(char *) "needMore", NULL
22142 };
22143
22144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22146 if (SWIG_arg_fail(1)) SWIG_fail;
22147 if (obj1) {
22148 {
22149 arg2 = (bool)(SWIG_As_bool(obj1));
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 }
22152 }
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 (arg1)->RequestMore(arg2);
22156
22157 wxPyEndAllowThreads(__tstate);
22158 if (PyErr_Occurred()) SWIG_fail;
22159 }
22160 Py_INCREF(Py_None); resultobj = Py_None;
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj;
22169 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22170 bool result;
22171 PyObject * obj0 = 0 ;
22172 char *kwnames[] = {
22173 (char *) "self", NULL
22174 };
22175
22176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22178 if (SWIG_arg_fail(1)) SWIG_fail;
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22182
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 {
22187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22188 }
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj;
22197 wxIdleMode arg1 ;
22198 PyObject * obj0 = 0 ;
22199 char *kwnames[] = {
22200 (char *) "mode", NULL
22201 };
22202
22203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22204 {
22205 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22206 if (SWIG_arg_fail(1)) SWIG_fail;
22207 }
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 wxIdleEvent::SetMode((wxIdleMode )arg1);
22211
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 Py_INCREF(Py_None); resultobj = Py_None;
22216 return resultobj;
22217 fail:
22218 return NULL;
22219 }
22220
22221
22222 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22223 PyObject *resultobj;
22224 wxIdleMode result;
22225 char *kwnames[] = {
22226 NULL
22227 };
22228
22229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 result = (wxIdleMode)wxIdleEvent::GetMode();
22233
22234 wxPyEndAllowThreads(__tstate);
22235 if (PyErr_Occurred()) SWIG_fail;
22236 }
22237 resultobj = SWIG_From_int((result));
22238 return resultobj;
22239 fail:
22240 return NULL;
22241 }
22242
22243
22244 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22245 PyObject *resultobj;
22246 wxWindow *arg1 = (wxWindow *) 0 ;
22247 bool result;
22248 PyObject * obj0 = 0 ;
22249 char *kwnames[] = {
22250 (char *) "win", NULL
22251 };
22252
22253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22255 if (SWIG_arg_fail(1)) SWIG_fail;
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 result = (bool)wxIdleEvent::CanSend(arg1);
22259
22260 wxPyEndAllowThreads(__tstate);
22261 if (PyErr_Occurred()) SWIG_fail;
22262 }
22263 {
22264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22265 }
22266 return resultobj;
22267 fail:
22268 return NULL;
22269 }
22270
22271
22272 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22273 PyObject *obj;
22274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22275 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22276 Py_INCREF(obj);
22277 return Py_BuildValue((char *)"");
22278 }
22279 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22280 PyObject *resultobj;
22281 int arg1 = (int) 0 ;
22282 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22283 wxPyEvent *result;
22284 PyObject * obj0 = 0 ;
22285 PyObject * obj1 = 0 ;
22286 char *kwnames[] = {
22287 (char *) "winid",(char *) "eventType", NULL
22288 };
22289
22290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22291 if (obj0) {
22292 {
22293 arg1 = (int)(SWIG_As_int(obj0));
22294 if (SWIG_arg_fail(1)) SWIG_fail;
22295 }
22296 }
22297 if (obj1) {
22298 {
22299 arg2 = (wxEventType)(SWIG_As_int(obj1));
22300 if (SWIG_arg_fail(2)) SWIG_fail;
22301 }
22302 }
22303 {
22304 PyThreadState* __tstate = wxPyBeginAllowThreads();
22305 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22306
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22311 return resultobj;
22312 fail:
22313 return NULL;
22314 }
22315
22316
22317 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22318 PyObject *resultobj;
22319 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22320 PyObject * obj0 = 0 ;
22321 char *kwnames[] = {
22322 (char *) "self", NULL
22323 };
22324
22325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(1)) SWIG_fail;
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 delete arg1;
22331
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 Py_INCREF(Py_None); resultobj = Py_None;
22336 return resultobj;
22337 fail:
22338 return NULL;
22339 }
22340
22341
22342 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22343 PyObject *resultobj;
22344 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22345 PyObject *arg2 = (PyObject *) 0 ;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348 char *kwnames[] = {
22349 (char *) "self",(char *) "self", NULL
22350 };
22351
22352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22354 if (SWIG_arg_fail(1)) SWIG_fail;
22355 arg2 = obj1;
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 (arg1)->SetSelf(arg2);
22359
22360 wxPyEndAllowThreads(__tstate);
22361 if (PyErr_Occurred()) SWIG_fail;
22362 }
22363 Py_INCREF(Py_None); resultobj = Py_None;
22364 return resultobj;
22365 fail:
22366 return NULL;
22367 }
22368
22369
22370 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22371 PyObject *resultobj;
22372 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22373 PyObject *result;
22374 PyObject * obj0 = 0 ;
22375 char *kwnames[] = {
22376 (char *) "self", NULL
22377 };
22378
22379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22381 if (SWIG_arg_fail(1)) SWIG_fail;
22382 {
22383 PyThreadState* __tstate = wxPyBeginAllowThreads();
22384 result = (PyObject *)(arg1)->GetSelf();
22385
22386 wxPyEndAllowThreads(__tstate);
22387 if (PyErr_Occurred()) SWIG_fail;
22388 }
22389 resultobj = result;
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22397 PyObject *obj;
22398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22399 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22400 Py_INCREF(obj);
22401 return Py_BuildValue((char *)"");
22402 }
22403 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22404 PyObject *resultobj;
22405 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22406 int arg2 = (int) 0 ;
22407 wxPyCommandEvent *result;
22408 PyObject * obj0 = 0 ;
22409 PyObject * obj1 = 0 ;
22410 char *kwnames[] = {
22411 (char *) "eventType",(char *) "id", NULL
22412 };
22413
22414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22415 if (obj0) {
22416 {
22417 arg1 = (wxEventType)(SWIG_As_int(obj0));
22418 if (SWIG_arg_fail(1)) SWIG_fail;
22419 }
22420 }
22421 if (obj1) {
22422 {
22423 arg2 = (int)(SWIG_As_int(obj1));
22424 if (SWIG_arg_fail(2)) SWIG_fail;
22425 }
22426 }
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22430
22431 wxPyEndAllowThreads(__tstate);
22432 if (PyErr_Occurred()) SWIG_fail;
22433 }
22434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22435 return resultobj;
22436 fail:
22437 return NULL;
22438 }
22439
22440
22441 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22442 PyObject *resultobj;
22443 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22444 PyObject * obj0 = 0 ;
22445 char *kwnames[] = {
22446 (char *) "self", NULL
22447 };
22448
22449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22451 if (SWIG_arg_fail(1)) SWIG_fail;
22452 {
22453 PyThreadState* __tstate = wxPyBeginAllowThreads();
22454 delete arg1;
22455
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 Py_INCREF(Py_None); resultobj = Py_None;
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22467 PyObject *resultobj;
22468 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22469 PyObject *arg2 = (PyObject *) 0 ;
22470 PyObject * obj0 = 0 ;
22471 PyObject * obj1 = 0 ;
22472 char *kwnames[] = {
22473 (char *) "self",(char *) "self", NULL
22474 };
22475
22476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(1)) SWIG_fail;
22479 arg2 = obj1;
22480 {
22481 PyThreadState* __tstate = wxPyBeginAllowThreads();
22482 (arg1)->SetSelf(arg2);
22483
22484 wxPyEndAllowThreads(__tstate);
22485 if (PyErr_Occurred()) SWIG_fail;
22486 }
22487 Py_INCREF(Py_None); resultobj = Py_None;
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22495 PyObject *resultobj;
22496 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22497 PyObject *result;
22498 PyObject * obj0 = 0 ;
22499 char *kwnames[] = {
22500 (char *) "self", NULL
22501 };
22502
22503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
22504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22505 if (SWIG_arg_fail(1)) SWIG_fail;
22506 {
22507 PyThreadState* __tstate = wxPyBeginAllowThreads();
22508 result = (PyObject *)(arg1)->GetSelf();
22509
22510 wxPyEndAllowThreads(__tstate);
22511 if (PyErr_Occurred()) SWIG_fail;
22512 }
22513 resultobj = result;
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22521 PyObject *obj;
22522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22523 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22524 Py_INCREF(obj);
22525 return Py_BuildValue((char *)"");
22526 }
22527 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22528 PyObject *resultobj;
22529 wxWindow *arg1 = (wxWindow *) 0 ;
22530 wxDateTime *arg2 = 0 ;
22531 wxEventType arg3 ;
22532 wxDateEvent *result;
22533 PyObject * obj0 = 0 ;
22534 PyObject * obj1 = 0 ;
22535 PyObject * obj2 = 0 ;
22536 char *kwnames[] = {
22537 (char *) "win",(char *) "dt",(char *) "type", NULL
22538 };
22539
22540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22542 if (SWIG_arg_fail(1)) SWIG_fail;
22543 {
22544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(2)) SWIG_fail;
22546 if (arg2 == NULL) {
22547 SWIG_null_ref("wxDateTime");
22548 }
22549 if (SWIG_arg_fail(2)) SWIG_fail;
22550 }
22551 {
22552 arg3 = (wxEventType)(SWIG_As_int(obj2));
22553 if (SWIG_arg_fail(3)) SWIG_fail;
22554 }
22555 {
22556 PyThreadState* __tstate = wxPyBeginAllowThreads();
22557 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22558
22559 wxPyEndAllowThreads(__tstate);
22560 if (PyErr_Occurred()) SWIG_fail;
22561 }
22562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22563 return resultobj;
22564 fail:
22565 return NULL;
22566 }
22567
22568
22569 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22570 PyObject *resultobj;
22571 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22572 wxDateTime *result;
22573 PyObject * obj0 = 0 ;
22574 char *kwnames[] = {
22575 (char *) "self", NULL
22576 };
22577
22578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22580 if (SWIG_arg_fail(1)) SWIG_fail;
22581 {
22582 PyThreadState* __tstate = wxPyBeginAllowThreads();
22583 {
22584 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22585 result = (wxDateTime *) &_result_ref;
22586 }
22587
22588 wxPyEndAllowThreads(__tstate);
22589 if (PyErr_Occurred()) SWIG_fail;
22590 }
22591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22592 return resultobj;
22593 fail:
22594 return NULL;
22595 }
22596
22597
22598 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22599 PyObject *resultobj;
22600 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22601 wxDateTime *arg2 = 0 ;
22602 PyObject * obj0 = 0 ;
22603 PyObject * obj1 = 0 ;
22604 char *kwnames[] = {
22605 (char *) "self",(char *) "date", NULL
22606 };
22607
22608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22610 if (SWIG_arg_fail(1)) SWIG_fail;
22611 {
22612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22613 if (SWIG_arg_fail(2)) SWIG_fail;
22614 if (arg2 == NULL) {
22615 SWIG_null_ref("wxDateTime");
22616 }
22617 if (SWIG_arg_fail(2)) SWIG_fail;
22618 }
22619 {
22620 PyThreadState* __tstate = wxPyBeginAllowThreads();
22621 (arg1)->SetDate((wxDateTime const &)*arg2);
22622
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 Py_INCREF(Py_None); resultobj = Py_None;
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22634 PyObject *obj;
22635 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22636 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22637 Py_INCREF(obj);
22638 return Py_BuildValue((char *)"");
22639 }
22640 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22641 PyObject *resultobj;
22642 wxPyApp *result;
22643 char *kwnames[] = {
22644 NULL
22645 };
22646
22647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22648 {
22649 PyThreadState* __tstate = wxPyBeginAllowThreads();
22650 result = (wxPyApp *)new_wxPyApp();
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject *_wrap_delete_PyApp(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:delete_PyApp",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 delete arg1;
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__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22688 PyObject *resultobj;
22689 wxPyApp *arg1 = (wxPyApp *) 0 ;
22690 PyObject *arg2 = (PyObject *) 0 ;
22691 PyObject *arg3 = (PyObject *) 0 ;
22692 bool arg4 ;
22693 PyObject * obj0 = 0 ;
22694 PyObject * obj1 = 0 ;
22695 PyObject * obj2 = 0 ;
22696 PyObject * obj3 = 0 ;
22697 char *kwnames[] = {
22698 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22699 };
22700
22701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22703 if (SWIG_arg_fail(1)) SWIG_fail;
22704 arg2 = obj1;
22705 arg3 = obj2;
22706 {
22707 arg4 = (bool)(SWIG_As_bool(obj3));
22708 if (SWIG_arg_fail(4)) SWIG_fail;
22709 }
22710 {
22711 PyThreadState* __tstate = wxPyBeginAllowThreads();
22712 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22713
22714 wxPyEndAllowThreads(__tstate);
22715 if (PyErr_Occurred()) SWIG_fail;
22716 }
22717 Py_INCREF(Py_None); resultobj = Py_None;
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22725 PyObject *resultobj;
22726 wxPyApp *arg1 = (wxPyApp *) 0 ;
22727 wxString result;
22728 PyObject * obj0 = 0 ;
22729 char *kwnames[] = {
22730 (char *) "self", NULL
22731 };
22732
22733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22735 if (SWIG_arg_fail(1)) SWIG_fail;
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 result = ((wxPyApp const *)arg1)->GetAppName();
22739
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 {
22744 #if wxUSE_UNICODE
22745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22746 #else
22747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22748 #endif
22749 }
22750 return resultobj;
22751 fail:
22752 return NULL;
22753 }
22754
22755
22756 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22757 PyObject *resultobj;
22758 wxPyApp *arg1 = (wxPyApp *) 0 ;
22759 wxString *arg2 = 0 ;
22760 bool temp2 = false ;
22761 PyObject * obj0 = 0 ;
22762 PyObject * obj1 = 0 ;
22763 char *kwnames[] = {
22764 (char *) "self",(char *) "name", NULL
22765 };
22766
22767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22769 if (SWIG_arg_fail(1)) SWIG_fail;
22770 {
22771 arg2 = wxString_in_helper(obj1);
22772 if (arg2 == NULL) SWIG_fail;
22773 temp2 = true;
22774 }
22775 {
22776 PyThreadState* __tstate = wxPyBeginAllowThreads();
22777 (arg1)->SetAppName((wxString const &)*arg2);
22778
22779 wxPyEndAllowThreads(__tstate);
22780 if (PyErr_Occurred()) SWIG_fail;
22781 }
22782 Py_INCREF(Py_None); resultobj = Py_None;
22783 {
22784 if (temp2)
22785 delete arg2;
22786 }
22787 return resultobj;
22788 fail:
22789 {
22790 if (temp2)
22791 delete arg2;
22792 }
22793 return NULL;
22794 }
22795
22796
22797 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22798 PyObject *resultobj;
22799 wxPyApp *arg1 = (wxPyApp *) 0 ;
22800 wxString result;
22801 PyObject * obj0 = 0 ;
22802 char *kwnames[] = {
22803 (char *) "self", NULL
22804 };
22805
22806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22808 if (SWIG_arg_fail(1)) SWIG_fail;
22809 {
22810 PyThreadState* __tstate = wxPyBeginAllowThreads();
22811 result = ((wxPyApp const *)arg1)->GetClassName();
22812
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 #if wxUSE_UNICODE
22818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22819 #else
22820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22821 #endif
22822 }
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22830 PyObject *resultobj;
22831 wxPyApp *arg1 = (wxPyApp *) 0 ;
22832 wxString *arg2 = 0 ;
22833 bool temp2 = false ;
22834 PyObject * obj0 = 0 ;
22835 PyObject * obj1 = 0 ;
22836 char *kwnames[] = {
22837 (char *) "self",(char *) "name", NULL
22838 };
22839
22840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22842 if (SWIG_arg_fail(1)) SWIG_fail;
22843 {
22844 arg2 = wxString_in_helper(obj1);
22845 if (arg2 == NULL) SWIG_fail;
22846 temp2 = true;
22847 }
22848 {
22849 PyThreadState* __tstate = wxPyBeginAllowThreads();
22850 (arg1)->SetClassName((wxString const &)*arg2);
22851
22852 wxPyEndAllowThreads(__tstate);
22853 if (PyErr_Occurred()) SWIG_fail;
22854 }
22855 Py_INCREF(Py_None); resultobj = Py_None;
22856 {
22857 if (temp2)
22858 delete arg2;
22859 }
22860 return resultobj;
22861 fail:
22862 {
22863 if (temp2)
22864 delete arg2;
22865 }
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22871 PyObject *resultobj;
22872 wxPyApp *arg1 = (wxPyApp *) 0 ;
22873 wxString *result;
22874 PyObject * obj0 = 0 ;
22875 char *kwnames[] = {
22876 (char *) "self", NULL
22877 };
22878
22879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",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 {
22885 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22886 result = (wxString *) &_result_ref;
22887 }
22888
22889 wxPyEndAllowThreads(__tstate);
22890 if (PyErr_Occurred()) SWIG_fail;
22891 }
22892 {
22893 #if wxUSE_UNICODE
22894 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22895 #else
22896 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22897 #endif
22898 }
22899 return resultobj;
22900 fail:
22901 return NULL;
22902 }
22903
22904
22905 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22906 PyObject *resultobj;
22907 wxPyApp *arg1 = (wxPyApp *) 0 ;
22908 wxString *arg2 = 0 ;
22909 bool temp2 = false ;
22910 PyObject * obj0 = 0 ;
22911 PyObject * obj1 = 0 ;
22912 char *kwnames[] = {
22913 (char *) "self",(char *) "name", NULL
22914 };
22915
22916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22918 if (SWIG_arg_fail(1)) SWIG_fail;
22919 {
22920 arg2 = wxString_in_helper(obj1);
22921 if (arg2 == NULL) SWIG_fail;
22922 temp2 = true;
22923 }
22924 {
22925 PyThreadState* __tstate = wxPyBeginAllowThreads();
22926 (arg1)->SetVendorName((wxString const &)*arg2);
22927
22928 wxPyEndAllowThreads(__tstate);
22929 if (PyErr_Occurred()) SWIG_fail;
22930 }
22931 Py_INCREF(Py_None); resultobj = Py_None;
22932 {
22933 if (temp2)
22934 delete arg2;
22935 }
22936 return resultobj;
22937 fail:
22938 {
22939 if (temp2)
22940 delete arg2;
22941 }
22942 return NULL;
22943 }
22944
22945
22946 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22947 PyObject *resultobj;
22948 wxPyApp *arg1 = (wxPyApp *) 0 ;
22949 wxAppTraits *result;
22950 PyObject * obj0 = 0 ;
22951 char *kwnames[] = {
22952 (char *) "self", NULL
22953 };
22954
22955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22957 if (SWIG_arg_fail(1)) SWIG_fail;
22958 {
22959 PyThreadState* __tstate = wxPyBeginAllowThreads();
22960 result = (wxAppTraits *)(arg1)->GetTraits();
22961
22962 wxPyEndAllowThreads(__tstate);
22963 if (PyErr_Occurred()) SWIG_fail;
22964 }
22965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22966 return resultobj;
22967 fail:
22968 return NULL;
22969 }
22970
22971
22972 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22973 PyObject *resultobj;
22974 wxPyApp *arg1 = (wxPyApp *) 0 ;
22975 PyObject * obj0 = 0 ;
22976 char *kwnames[] = {
22977 (char *) "self", NULL
22978 };
22979
22980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22982 if (SWIG_arg_fail(1)) SWIG_fail;
22983 {
22984 PyThreadState* __tstate = wxPyBeginAllowThreads();
22985 (arg1)->ProcessPendingEvents();
22986
22987 wxPyEndAllowThreads(__tstate);
22988 if (PyErr_Occurred()) SWIG_fail;
22989 }
22990 Py_INCREF(Py_None); resultobj = Py_None;
22991 return resultobj;
22992 fail:
22993 return NULL;
22994 }
22995
22996
22997 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22998 PyObject *resultobj;
22999 wxPyApp *arg1 = (wxPyApp *) 0 ;
23000 bool arg2 = (bool) false ;
23001 bool result;
23002 PyObject * obj0 = 0 ;
23003 PyObject * obj1 = 0 ;
23004 char *kwnames[] = {
23005 (char *) "self",(char *) "onlyIfNeeded", NULL
23006 };
23007
23008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23010 if (SWIG_arg_fail(1)) SWIG_fail;
23011 if (obj1) {
23012 {
23013 arg2 = (bool)(SWIG_As_bool(obj1));
23014 if (SWIG_arg_fail(2)) SWIG_fail;
23015 }
23016 }
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 result = (bool)(arg1)->Yield(arg2);
23020
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 {
23025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23026 }
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23034 PyObject *resultobj;
23035 wxPyApp *arg1 = (wxPyApp *) 0 ;
23036 PyObject * obj0 = 0 ;
23037 char *kwnames[] = {
23038 (char *) "self", NULL
23039 };
23040
23041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23043 if (SWIG_arg_fail(1)) SWIG_fail;
23044 {
23045 PyThreadState* __tstate = wxPyBeginAllowThreads();
23046 (arg1)->WakeUpIdle();
23047
23048 wxPyEndAllowThreads(__tstate);
23049 if (PyErr_Occurred()) SWIG_fail;
23050 }
23051 Py_INCREF(Py_None); resultobj = Py_None;
23052 return resultobj;
23053 fail:
23054 return NULL;
23055 }
23056
23057
23058 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23059 PyObject *resultobj;
23060 bool result;
23061 char *kwnames[] = {
23062 NULL
23063 };
23064
23065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 result = (bool)wxPyApp::IsMainLoopRunning();
23069
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 {
23074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23075 }
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23083 PyObject *resultobj;
23084 wxPyApp *arg1 = (wxPyApp *) 0 ;
23085 int result;
23086 PyObject * obj0 = 0 ;
23087 char *kwnames[] = {
23088 (char *) "self", NULL
23089 };
23090
23091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23093 if (SWIG_arg_fail(1)) SWIG_fail;
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = (int)(arg1)->MainLoop();
23097
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 {
23102 resultobj = SWIG_From_int((int)(result));
23103 }
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23111 PyObject *resultobj;
23112 wxPyApp *arg1 = (wxPyApp *) 0 ;
23113 PyObject * obj0 = 0 ;
23114 char *kwnames[] = {
23115 (char *) "self", NULL
23116 };
23117
23118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23120 if (SWIG_arg_fail(1)) SWIG_fail;
23121 {
23122 PyThreadState* __tstate = wxPyBeginAllowThreads();
23123 (arg1)->Exit();
23124
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 Py_INCREF(Py_None); resultobj = Py_None;
23129 return resultobj;
23130 fail:
23131 return NULL;
23132 }
23133
23134
23135 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23136 PyObject *resultobj;
23137 wxPyApp *arg1 = (wxPyApp *) 0 ;
23138 PyObject * obj0 = 0 ;
23139 char *kwnames[] = {
23140 (char *) "self", NULL
23141 };
23142
23143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23145 if (SWIG_arg_fail(1)) SWIG_fail;
23146 {
23147 PyThreadState* __tstate = wxPyBeginAllowThreads();
23148 (arg1)->ExitMainLoop();
23149
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 Py_INCREF(Py_None); resultobj = Py_None;
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj;
23162 wxPyApp *arg1 = (wxPyApp *) 0 ;
23163 bool result;
23164 PyObject * obj0 = 0 ;
23165 char *kwnames[] = {
23166 (char *) "self", NULL
23167 };
23168
23169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23171 if (SWIG_arg_fail(1)) SWIG_fail;
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (bool)(arg1)->Pending();
23175
23176 wxPyEndAllowThreads(__tstate);
23177 if (PyErr_Occurred()) SWIG_fail;
23178 }
23179 {
23180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23181 }
23182 return resultobj;
23183 fail:
23184 return NULL;
23185 }
23186
23187
23188 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23189 PyObject *resultobj;
23190 wxPyApp *arg1 = (wxPyApp *) 0 ;
23191 bool result;
23192 PyObject * obj0 = 0 ;
23193 char *kwnames[] = {
23194 (char *) "self", NULL
23195 };
23196
23197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23199 if (SWIG_arg_fail(1)) SWIG_fail;
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (bool)(arg1)->Dispatch();
23203
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 {
23208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23209 }
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23217 PyObject *resultobj;
23218 wxPyApp *arg1 = (wxPyApp *) 0 ;
23219 bool result;
23220 PyObject * obj0 = 0 ;
23221 char *kwnames[] = {
23222 (char *) "self", NULL
23223 };
23224
23225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23227 if (SWIG_arg_fail(1)) SWIG_fail;
23228 {
23229 PyThreadState* __tstate = wxPyBeginAllowThreads();
23230 result = (bool)(arg1)->ProcessIdle();
23231
23232 wxPyEndAllowThreads(__tstate);
23233 if (PyErr_Occurred()) SWIG_fail;
23234 }
23235 {
23236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23237 }
23238 return resultobj;
23239 fail:
23240 return NULL;
23241 }
23242
23243
23244 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23245 PyObject *resultobj;
23246 wxPyApp *arg1 = (wxPyApp *) 0 ;
23247 wxWindow *arg2 = (wxWindow *) 0 ;
23248 wxIdleEvent *arg3 = 0 ;
23249 bool result;
23250 PyObject * obj0 = 0 ;
23251 PyObject * obj1 = 0 ;
23252 PyObject * obj2 = 0 ;
23253 char *kwnames[] = {
23254 (char *) "self",(char *) "win",(char *) "event", NULL
23255 };
23256
23257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23259 if (SWIG_arg_fail(1)) SWIG_fail;
23260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23261 if (SWIG_arg_fail(2)) SWIG_fail;
23262 {
23263 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(3)) SWIG_fail;
23265 if (arg3 == NULL) {
23266 SWIG_null_ref("wxIdleEvent");
23267 }
23268 if (SWIG_arg_fail(3)) SWIG_fail;
23269 }
23270 {
23271 PyThreadState* __tstate = wxPyBeginAllowThreads();
23272 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23273
23274 wxPyEndAllowThreads(__tstate);
23275 if (PyErr_Occurred()) SWIG_fail;
23276 }
23277 {
23278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23279 }
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj;
23288 wxPyApp *arg1 = (wxPyApp *) 0 ;
23289 bool result;
23290 PyObject * obj0 = 0 ;
23291 char *kwnames[] = {
23292 (char *) "self", NULL
23293 };
23294
23295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23297 if (SWIG_arg_fail(1)) SWIG_fail;
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 result = (bool)((wxPyApp const *)arg1)->IsActive();
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 {
23306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23307 }
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj;
23316 wxPyApp *arg1 = (wxPyApp *) 0 ;
23317 wxWindow *arg2 = (wxWindow *) 0 ;
23318 PyObject * obj0 = 0 ;
23319 PyObject * obj1 = 0 ;
23320 char *kwnames[] = {
23321 (char *) "self",(char *) "win", NULL
23322 };
23323
23324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23326 if (SWIG_arg_fail(1)) SWIG_fail;
23327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23328 if (SWIG_arg_fail(2)) SWIG_fail;
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 (arg1)->SetTopWindow(arg2);
23332
23333 wxPyEndAllowThreads(__tstate);
23334 if (PyErr_Occurred()) SWIG_fail;
23335 }
23336 Py_INCREF(Py_None); resultobj = Py_None;
23337 return resultobj;
23338 fail:
23339 return NULL;
23340 }
23341
23342
23343 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23344 PyObject *resultobj;
23345 wxPyApp *arg1 = (wxPyApp *) 0 ;
23346 wxWindow *result;
23347 PyObject * obj0 = 0 ;
23348 char *kwnames[] = {
23349 (char *) "self", NULL
23350 };
23351
23352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23354 if (SWIG_arg_fail(1)) SWIG_fail;
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23358
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 {
23363 resultobj = wxPyMake_wxObject(result, 0);
23364 }
23365 return resultobj;
23366 fail:
23367 return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23372 PyObject *resultobj;
23373 wxPyApp *arg1 = (wxPyApp *) 0 ;
23374 bool arg2 ;
23375 PyObject * obj0 = 0 ;
23376 PyObject * obj1 = 0 ;
23377 char *kwnames[] = {
23378 (char *) "self",(char *) "flag", NULL
23379 };
23380
23381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23383 if (SWIG_arg_fail(1)) SWIG_fail;
23384 {
23385 arg2 = (bool)(SWIG_As_bool(obj1));
23386 if (SWIG_arg_fail(2)) SWIG_fail;
23387 }
23388 {
23389 PyThreadState* __tstate = wxPyBeginAllowThreads();
23390 (arg1)->SetExitOnFrameDelete(arg2);
23391
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 Py_INCREF(Py_None); resultobj = Py_None;
23396 return resultobj;
23397 fail:
23398 return NULL;
23399 }
23400
23401
23402 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23403 PyObject *resultobj;
23404 wxPyApp *arg1 = (wxPyApp *) 0 ;
23405 bool result;
23406 PyObject * obj0 = 0 ;
23407 char *kwnames[] = {
23408 (char *) "self", NULL
23409 };
23410
23411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",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 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23417
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 {
23422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23423 }
23424 return resultobj;
23425 fail:
23426 return NULL;
23427 }
23428
23429
23430 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23431 PyObject *resultobj;
23432 wxPyApp *arg1 = (wxPyApp *) 0 ;
23433 bool arg2 ;
23434 PyObject * obj0 = 0 ;
23435 PyObject * obj1 = 0 ;
23436 char *kwnames[] = {
23437 (char *) "self",(char *) "flag", NULL
23438 };
23439
23440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23442 if (SWIG_arg_fail(1)) SWIG_fail;
23443 {
23444 arg2 = (bool)(SWIG_As_bool(obj1));
23445 if (SWIG_arg_fail(2)) SWIG_fail;
23446 }
23447 {
23448 PyThreadState* __tstate = wxPyBeginAllowThreads();
23449 (arg1)->SetUseBestVisual(arg2);
23450
23451 wxPyEndAllowThreads(__tstate);
23452 if (PyErr_Occurred()) SWIG_fail;
23453 }
23454 Py_INCREF(Py_None); resultobj = Py_None;
23455 return resultobj;
23456 fail:
23457 return NULL;
23458 }
23459
23460
23461 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23462 PyObject *resultobj;
23463 wxPyApp *arg1 = (wxPyApp *) 0 ;
23464 bool result;
23465 PyObject * obj0 = 0 ;
23466 char *kwnames[] = {
23467 (char *) "self", NULL
23468 };
23469
23470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23472 if (SWIG_arg_fail(1)) SWIG_fail;
23473 {
23474 PyThreadState* __tstate = wxPyBeginAllowThreads();
23475 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23476
23477 wxPyEndAllowThreads(__tstate);
23478 if (PyErr_Occurred()) SWIG_fail;
23479 }
23480 {
23481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23482 }
23483 return resultobj;
23484 fail:
23485 return NULL;
23486 }
23487
23488
23489 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23490 PyObject *resultobj;
23491 wxPyApp *arg1 = (wxPyApp *) 0 ;
23492 int arg2 ;
23493 PyObject * obj0 = 0 ;
23494 PyObject * obj1 = 0 ;
23495 char *kwnames[] = {
23496 (char *) "self",(char *) "mode", NULL
23497 };
23498
23499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23501 if (SWIG_arg_fail(1)) SWIG_fail;
23502 {
23503 arg2 = (int)(SWIG_As_int(obj1));
23504 if (SWIG_arg_fail(2)) SWIG_fail;
23505 }
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 (arg1)->SetPrintMode(arg2);
23509
23510 wxPyEndAllowThreads(__tstate);
23511 if (PyErr_Occurred()) SWIG_fail;
23512 }
23513 Py_INCREF(Py_None); resultobj = Py_None;
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj;
23522 wxPyApp *arg1 = (wxPyApp *) 0 ;
23523 int result;
23524 PyObject * obj0 = 0 ;
23525 char *kwnames[] = {
23526 (char *) "self", NULL
23527 };
23528
23529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23531 if (SWIG_arg_fail(1)) SWIG_fail;
23532 {
23533 PyThreadState* __tstate = wxPyBeginAllowThreads();
23534 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23535
23536 wxPyEndAllowThreads(__tstate);
23537 if (PyErr_Occurred()) SWIG_fail;
23538 }
23539 {
23540 resultobj = SWIG_From_int((int)(result));
23541 }
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj;
23550 wxPyApp *arg1 = (wxPyApp *) 0 ;
23551 int arg2 ;
23552 PyObject * obj0 = 0 ;
23553 PyObject * obj1 = 0 ;
23554 char *kwnames[] = {
23555 (char *) "self",(char *) "mode", NULL
23556 };
23557
23558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23560 if (SWIG_arg_fail(1)) SWIG_fail;
23561 {
23562 arg2 = (int)(SWIG_As_int(obj1));
23563 if (SWIG_arg_fail(2)) SWIG_fail;
23564 }
23565 {
23566 PyThreadState* __tstate = wxPyBeginAllowThreads();
23567 (arg1)->SetAssertMode(arg2);
23568
23569 wxPyEndAllowThreads(__tstate);
23570 if (PyErr_Occurred()) SWIG_fail;
23571 }
23572 Py_INCREF(Py_None); resultobj = Py_None;
23573 return resultobj;
23574 fail:
23575 return NULL;
23576 }
23577
23578
23579 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23580 PyObject *resultobj;
23581 wxPyApp *arg1 = (wxPyApp *) 0 ;
23582 int result;
23583 PyObject * obj0 = 0 ;
23584 char *kwnames[] = {
23585 (char *) "self", NULL
23586 };
23587
23588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23590 if (SWIG_arg_fail(1)) SWIG_fail;
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (int)(arg1)->GetAssertMode();
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = SWIG_From_int((int)(result));
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj;
23609 bool result;
23610 char *kwnames[] = {
23611 NULL
23612 };
23613
23614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23615 {
23616 PyThreadState* __tstate = wxPyBeginAllowThreads();
23617 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23618
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 {
23623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23632 PyObject *resultobj;
23633 long result;
23634 char *kwnames[] = {
23635 NULL
23636 };
23637
23638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23639 {
23640 PyThreadState* __tstate = wxPyBeginAllowThreads();
23641 result = (long)wxPyApp::GetMacAboutMenuItemId();
23642
23643 wxPyEndAllowThreads(__tstate);
23644 if (PyErr_Occurred()) SWIG_fail;
23645 }
23646 {
23647 resultobj = SWIG_From_long((long)(result));
23648 }
23649 return resultobj;
23650 fail:
23651 return NULL;
23652 }
23653
23654
23655 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23656 PyObject *resultobj;
23657 long result;
23658 char *kwnames[] = {
23659 NULL
23660 };
23661
23662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23666
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 {
23671 resultobj = SWIG_From_long((long)(result));
23672 }
23673 return resultobj;
23674 fail:
23675 return NULL;
23676 }
23677
23678
23679 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23680 PyObject *resultobj;
23681 long result;
23682 char *kwnames[] = {
23683 NULL
23684 };
23685
23686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 result = (long)wxPyApp::GetMacExitMenuItemId();
23690
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 {
23695 resultobj = SWIG_From_long((long)(result));
23696 }
23697 return resultobj;
23698 fail:
23699 return NULL;
23700 }
23701
23702
23703 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23704 PyObject *resultobj;
23705 wxString result;
23706 char *kwnames[] = {
23707 NULL
23708 };
23709
23710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = wxPyApp::GetMacHelpMenuTitleName();
23714
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 {
23719 #if wxUSE_UNICODE
23720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23721 #else
23722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23723 #endif
23724 }
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23732 PyObject *resultobj;
23733 bool arg1 ;
23734 PyObject * obj0 = 0 ;
23735 char *kwnames[] = {
23736 (char *) "val", NULL
23737 };
23738
23739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23740 {
23741 arg1 = (bool)(SWIG_As_bool(obj0));
23742 if (SWIG_arg_fail(1)) SWIG_fail;
23743 }
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23747
23748 wxPyEndAllowThreads(__tstate);
23749 if (PyErr_Occurred()) SWIG_fail;
23750 }
23751 Py_INCREF(Py_None); resultobj = Py_None;
23752 return resultobj;
23753 fail:
23754 return NULL;
23755 }
23756
23757
23758 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23759 PyObject *resultobj;
23760 long arg1 ;
23761 PyObject * obj0 = 0 ;
23762 char *kwnames[] = {
23763 (char *) "val", NULL
23764 };
23765
23766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23767 {
23768 arg1 = (long)(SWIG_As_long(obj0));
23769 if (SWIG_arg_fail(1)) SWIG_fail;
23770 }
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 wxPyApp::SetMacAboutMenuItemId(arg1);
23774
23775 wxPyEndAllowThreads(__tstate);
23776 if (PyErr_Occurred()) SWIG_fail;
23777 }
23778 Py_INCREF(Py_None); resultobj = Py_None;
23779 return resultobj;
23780 fail:
23781 return NULL;
23782 }
23783
23784
23785 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23786 PyObject *resultobj;
23787 long arg1 ;
23788 PyObject * obj0 = 0 ;
23789 char *kwnames[] = {
23790 (char *) "val", NULL
23791 };
23792
23793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23794 {
23795 arg1 = (long)(SWIG_As_long(obj0));
23796 if (SWIG_arg_fail(1)) SWIG_fail;
23797 }
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23801
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 Py_INCREF(Py_None); resultobj = Py_None;
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23813 PyObject *resultobj;
23814 long arg1 ;
23815 PyObject * obj0 = 0 ;
23816 char *kwnames[] = {
23817 (char *) "val", NULL
23818 };
23819
23820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23821 {
23822 arg1 = (long)(SWIG_As_long(obj0));
23823 if (SWIG_arg_fail(1)) SWIG_fail;
23824 }
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 wxPyApp::SetMacExitMenuItemId(arg1);
23828
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 Py_INCREF(Py_None); resultobj = Py_None;
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23840 PyObject *resultobj;
23841 wxString *arg1 = 0 ;
23842 bool temp1 = false ;
23843 PyObject * obj0 = 0 ;
23844 char *kwnames[] = {
23845 (char *) "val", NULL
23846 };
23847
23848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23849 {
23850 arg1 = wxString_in_helper(obj0);
23851 if (arg1 == NULL) SWIG_fail;
23852 temp1 = true;
23853 }
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23857
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 Py_INCREF(Py_None); resultobj = Py_None;
23862 {
23863 if (temp1)
23864 delete arg1;
23865 }
23866 return resultobj;
23867 fail:
23868 {
23869 if (temp1)
23870 delete arg1;
23871 }
23872 return NULL;
23873 }
23874
23875
23876 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23877 PyObject *resultobj;
23878 wxPyApp *arg1 = (wxPyApp *) 0 ;
23879 PyObject * obj0 = 0 ;
23880 char *kwnames[] = {
23881 (char *) "self", NULL
23882 };
23883
23884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23886 if (SWIG_arg_fail(1)) SWIG_fail;
23887 {
23888 PyThreadState* __tstate = wxPyBeginAllowThreads();
23889 (arg1)->_BootstrapApp();
23890
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 Py_INCREF(Py_None); resultobj = Py_None;
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23902 PyObject *resultobj;
23903 int result;
23904 char *kwnames[] = {
23905 NULL
23906 };
23907
23908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23909 {
23910 PyThreadState* __tstate = wxPyBeginAllowThreads();
23911 result = (int)PyApp_GetComCtl32Version();
23912
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 {
23917 resultobj = SWIG_From_int((int)(result));
23918 }
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23926 PyObject *obj;
23927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23928 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23929 Py_INCREF(obj);
23930 return Py_BuildValue((char *)"");
23931 }
23932 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23933 PyObject *resultobj;
23934 char *kwnames[] = {
23935 NULL
23936 };
23937
23938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23939 {
23940 PyThreadState* __tstate = wxPyBeginAllowThreads();
23941 wxExit();
23942
23943 wxPyEndAllowThreads(__tstate);
23944 if (PyErr_Occurred()) SWIG_fail;
23945 }
23946 Py_INCREF(Py_None); resultobj = Py_None;
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23954 PyObject *resultobj;
23955 bool result;
23956 char *kwnames[] = {
23957 NULL
23958 };
23959
23960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = (bool)wxYield();
23964
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 {
23969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23978 PyObject *resultobj;
23979 bool result;
23980 char *kwnames[] = {
23981 NULL
23982 };
23983
23984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23985 {
23986 PyThreadState* __tstate = wxPyBeginAllowThreads();
23987 result = (bool)wxYieldIfNeeded();
23988
23989 wxPyEndAllowThreads(__tstate);
23990 if (PyErr_Occurred()) SWIG_fail;
23991 }
23992 {
23993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23994 }
23995 return resultobj;
23996 fail:
23997 return NULL;
23998 }
23999
24000
24001 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24002 PyObject *resultobj;
24003 wxWindow *arg1 = (wxWindow *) NULL ;
24004 bool arg2 = (bool) false ;
24005 bool result;
24006 PyObject * obj0 = 0 ;
24007 PyObject * obj1 = 0 ;
24008 char *kwnames[] = {
24009 (char *) "win",(char *) "onlyIfNeeded", NULL
24010 };
24011
24012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24013 if (obj0) {
24014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24015 if (SWIG_arg_fail(1)) SWIG_fail;
24016 }
24017 if (obj1) {
24018 {
24019 arg2 = (bool)(SWIG_As_bool(obj1));
24020 if (SWIG_arg_fail(2)) SWIG_fail;
24021 }
24022 }
24023 {
24024 PyThreadState* __tstate = wxPyBeginAllowThreads();
24025 result = (bool)wxSafeYield(arg1,arg2);
24026
24027 wxPyEndAllowThreads(__tstate);
24028 if (PyErr_Occurred()) SWIG_fail;
24029 }
24030 {
24031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24032 }
24033 return resultobj;
24034 fail:
24035 return NULL;
24036 }
24037
24038
24039 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24040 PyObject *resultobj;
24041 char *kwnames[] = {
24042 NULL
24043 };
24044
24045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 wxWakeUpIdle();
24049
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 Py_INCREF(Py_None); resultobj = Py_None;
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj;
24062 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24063 wxEvent *arg2 = 0 ;
24064 PyObject * obj0 = 0 ;
24065 PyObject * obj1 = 0 ;
24066 char *kwnames[] = {
24067 (char *) "dest",(char *) "event", NULL
24068 };
24069
24070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24072 if (SWIG_arg_fail(1)) SWIG_fail;
24073 {
24074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24075 if (SWIG_arg_fail(2)) SWIG_fail;
24076 if (arg2 == NULL) {
24077 SWIG_null_ref("wxEvent");
24078 }
24079 if (SWIG_arg_fail(2)) SWIG_fail;
24080 }
24081 {
24082 PyThreadState* __tstate = wxPyBeginAllowThreads();
24083 wxPostEvent(arg1,*arg2);
24084
24085 wxPyEndAllowThreads(__tstate);
24086 if (PyErr_Occurred()) SWIG_fail;
24087 }
24088 Py_INCREF(Py_None); resultobj = Py_None;
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24096 PyObject *resultobj;
24097 char *kwnames[] = {
24098 NULL
24099 };
24100
24101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 wxApp_CleanUp();
24105
24106 wxPyEndAllowThreads(__tstate);
24107 if (PyErr_Occurred()) SWIG_fail;
24108 }
24109 Py_INCREF(Py_None); resultobj = Py_None;
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxPyApp *result;
24119 char *kwnames[] = {
24120 NULL
24121 };
24122
24123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 result = (wxPyApp *)wxPyGetApp();
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 {
24132 resultobj = wxPyMake_wxObject(result, 0);
24133 }
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 char *arg1 = (char *) 0 ;
24143 PyObject * obj0 = 0 ;
24144 char *kwnames[] = {
24145 (char *) "encoding", NULL
24146 };
24147
24148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24149 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24150 SWIG_arg_fail(1);SWIG_fail;
24151 }
24152 {
24153 PyThreadState* __tstate = wxPyBeginAllowThreads();
24154 wxSetDefaultPyEncoding((char const *)arg1);
24155
24156 wxPyEndAllowThreads(__tstate);
24157 if (PyErr_Occurred()) SWIG_fail;
24158 }
24159 Py_INCREF(Py_None); resultobj = Py_None;
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24167 PyObject *resultobj;
24168 char *result;
24169 char *kwnames[] = {
24170 NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24174 {
24175 PyThreadState* __tstate = wxPyBeginAllowThreads();
24176 result = (char *)wxGetDefaultPyEncoding();
24177
24178 wxPyEndAllowThreads(__tstate);
24179 if (PyErr_Occurred()) SWIG_fail;
24180 }
24181 resultobj = SWIG_FromCharPtr(result);
24182 return resultobj;
24183 fail:
24184 return NULL;
24185 }
24186
24187
24188 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24189 PyObject *resultobj;
24190 wxEventLoop *result;
24191 char *kwnames[] = {
24192 NULL
24193 };
24194
24195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24196 {
24197 PyThreadState* __tstate = wxPyBeginAllowThreads();
24198 result = (wxEventLoop *)new wxEventLoop();
24199
24200 wxPyEndAllowThreads(__tstate);
24201 if (PyErr_Occurred()) SWIG_fail;
24202 }
24203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24204 return resultobj;
24205 fail:
24206 return NULL;
24207 }
24208
24209
24210 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24211 PyObject *resultobj;
24212 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24213 PyObject * obj0 = 0 ;
24214 char *kwnames[] = {
24215 (char *) "self", NULL
24216 };
24217
24218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24220 if (SWIG_arg_fail(1)) SWIG_fail;
24221 {
24222 PyThreadState* __tstate = wxPyBeginAllowThreads();
24223 delete arg1;
24224
24225 wxPyEndAllowThreads(__tstate);
24226 if (PyErr_Occurred()) SWIG_fail;
24227 }
24228 Py_INCREF(Py_None); resultobj = Py_None;
24229 return resultobj;
24230 fail:
24231 return NULL;
24232 }
24233
24234
24235 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24236 PyObject *resultobj;
24237 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24238 int result;
24239 PyObject * obj0 = 0 ;
24240 char *kwnames[] = {
24241 (char *) "self", NULL
24242 };
24243
24244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24246 if (SWIG_arg_fail(1)) SWIG_fail;
24247 {
24248 PyThreadState* __tstate = wxPyBeginAllowThreads();
24249 result = (int)(arg1)->Run();
24250
24251 wxPyEndAllowThreads(__tstate);
24252 if (PyErr_Occurred()) SWIG_fail;
24253 }
24254 {
24255 resultobj = SWIG_From_int((int)(result));
24256 }
24257 return resultobj;
24258 fail:
24259 return NULL;
24260 }
24261
24262
24263 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24264 PyObject *resultobj;
24265 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24266 int arg2 = (int) 0 ;
24267 PyObject * obj0 = 0 ;
24268 PyObject * obj1 = 0 ;
24269 char *kwnames[] = {
24270 (char *) "self",(char *) "rc", NULL
24271 };
24272
24273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24275 if (SWIG_arg_fail(1)) SWIG_fail;
24276 if (obj1) {
24277 {
24278 arg2 = (int)(SWIG_As_int(obj1));
24279 if (SWIG_arg_fail(2)) SWIG_fail;
24280 }
24281 }
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 (arg1)->Exit(arg2);
24285
24286 wxPyEndAllowThreads(__tstate);
24287 if (PyErr_Occurred()) SWIG_fail;
24288 }
24289 Py_INCREF(Py_None); resultobj = Py_None;
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj;
24298 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24299 bool result;
24300 PyObject * obj0 = 0 ;
24301 char *kwnames[] = {
24302 (char *) "self", NULL
24303 };
24304
24305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24307 if (SWIG_arg_fail(1)) SWIG_fail;
24308 {
24309 PyThreadState* __tstate = wxPyBeginAllowThreads();
24310 result = (bool)((wxEventLoop const *)arg1)->Pending();
24311
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24325 PyObject *resultobj;
24326 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24327 bool result;
24328 PyObject * obj0 = 0 ;
24329 char *kwnames[] = {
24330 (char *) "self", NULL
24331 };
24332
24333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24335 if (SWIG_arg_fail(1)) SWIG_fail;
24336 {
24337 PyThreadState* __tstate = wxPyBeginAllowThreads();
24338 result = (bool)(arg1)->Dispatch();
24339
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 {
24344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24345 }
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24353 PyObject *resultobj;
24354 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24355 bool result;
24356 PyObject * obj0 = 0 ;
24357 char *kwnames[] = {
24358 (char *) "self", NULL
24359 };
24360
24361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24363 if (SWIG_arg_fail(1)) SWIG_fail;
24364 {
24365 PyThreadState* __tstate = wxPyBeginAllowThreads();
24366 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24367
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 {
24372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24373 }
24374 return resultobj;
24375 fail:
24376 return NULL;
24377 }
24378
24379
24380 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj;
24382 wxEventLoop *result;
24383 char *kwnames[] = {
24384 NULL
24385 };
24386
24387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 result = (wxEventLoop *)wxEventLoop::GetActive();
24391
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj;
24404 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24405 PyObject * obj0 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "loop", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 {
24414 PyThreadState* __tstate = wxPyBeginAllowThreads();
24415 wxEventLoop::SetActive(arg1);
24416
24417 wxPyEndAllowThreads(__tstate);
24418 if (PyErr_Occurred()) SWIG_fail;
24419 }
24420 Py_INCREF(Py_None); resultobj = Py_None;
24421 return resultobj;
24422 fail:
24423 return NULL;
24424 }
24425
24426
24427 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24428 PyObject *obj;
24429 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24430 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24431 Py_INCREF(obj);
24432 return Py_BuildValue((char *)"");
24433 }
24434 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj;
24436 int arg1 = (int) 0 ;
24437 int arg2 = (int) 0 ;
24438 int arg3 = (int) 0 ;
24439 wxAcceleratorEntry *result;
24440 PyObject * obj0 = 0 ;
24441 PyObject * obj1 = 0 ;
24442 PyObject * obj2 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24448 if (obj0) {
24449 {
24450 arg1 = (int)(SWIG_As_int(obj0));
24451 if (SWIG_arg_fail(1)) SWIG_fail;
24452 }
24453 }
24454 if (obj1) {
24455 {
24456 arg2 = (int)(SWIG_As_int(obj1));
24457 if (SWIG_arg_fail(2)) SWIG_fail;
24458 }
24459 }
24460 if (obj2) {
24461 {
24462 arg3 = (int)(SWIG_As_int(obj2));
24463 if (SWIG_arg_fail(3)) SWIG_fail;
24464 }
24465 }
24466 {
24467 PyThreadState* __tstate = wxPyBeginAllowThreads();
24468 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24469
24470 wxPyEndAllowThreads(__tstate);
24471 if (PyErr_Occurred()) SWIG_fail;
24472 }
24473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24474 return resultobj;
24475 fail:
24476 return NULL;
24477 }
24478
24479
24480 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj;
24482 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24483 PyObject * obj0 = 0 ;
24484 char *kwnames[] = {
24485 (char *) "self", NULL
24486 };
24487
24488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24490 if (SWIG_arg_fail(1)) SWIG_fail;
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 delete arg1;
24494
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 Py_INCREF(Py_None); resultobj = Py_None;
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24506 PyObject *resultobj;
24507 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24508 int arg2 ;
24509 int arg3 ;
24510 int arg4 ;
24511 PyObject * obj0 = 0 ;
24512 PyObject * obj1 = 0 ;
24513 PyObject * obj2 = 0 ;
24514 PyObject * obj3 = 0 ;
24515 char *kwnames[] = {
24516 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24517 };
24518
24519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24521 if (SWIG_arg_fail(1)) SWIG_fail;
24522 {
24523 arg2 = (int)(SWIG_As_int(obj1));
24524 if (SWIG_arg_fail(2)) SWIG_fail;
24525 }
24526 {
24527 arg3 = (int)(SWIG_As_int(obj2));
24528 if (SWIG_arg_fail(3)) SWIG_fail;
24529 }
24530 {
24531 arg4 = (int)(SWIG_As_int(obj3));
24532 if (SWIG_arg_fail(4)) SWIG_fail;
24533 }
24534 {
24535 PyThreadState* __tstate = wxPyBeginAllowThreads();
24536 (arg1)->Set(arg2,arg3,arg4);
24537
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 Py_INCREF(Py_None); resultobj = Py_None;
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj;
24550 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24551 int result;
24552 PyObject * obj0 = 0 ;
24553 char *kwnames[] = {
24554 (char *) "self", NULL
24555 };
24556
24557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24559 if (SWIG_arg_fail(1)) SWIG_fail;
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = (int)(arg1)->GetFlags();
24563
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 {
24568 resultobj = SWIG_From_int((int)(result));
24569 }
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj;
24578 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24579 int result;
24580 PyObject * obj0 = 0 ;
24581 char *kwnames[] = {
24582 (char *) "self", NULL
24583 };
24584
24585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24587 if (SWIG_arg_fail(1)) SWIG_fail;
24588 {
24589 PyThreadState* __tstate = wxPyBeginAllowThreads();
24590 result = (int)(arg1)->GetKeyCode();
24591
24592 wxPyEndAllowThreads(__tstate);
24593 if (PyErr_Occurred()) SWIG_fail;
24594 }
24595 {
24596 resultobj = SWIG_From_int((int)(result));
24597 }
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24605 PyObject *resultobj;
24606 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24607 int result;
24608 PyObject * obj0 = 0 ;
24609 char *kwnames[] = {
24610 (char *) "self", NULL
24611 };
24612
24613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24615 if (SWIG_arg_fail(1)) SWIG_fail;
24616 {
24617 PyThreadState* __tstate = wxPyBeginAllowThreads();
24618 result = (int)(arg1)->GetCommand();
24619
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 {
24624 resultobj = SWIG_From_int((int)(result));
24625 }
24626 return resultobj;
24627 fail:
24628 return NULL;
24629 }
24630
24631
24632 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24633 PyObject *obj;
24634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24635 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24636 Py_INCREF(obj);
24637 return Py_BuildValue((char *)"");
24638 }
24639 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj;
24641 int arg1 ;
24642 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24643 wxAcceleratorTable *result;
24644 PyObject * obj0 = 0 ;
24645 char *kwnames[] = {
24646 (char *) "n", NULL
24647 };
24648
24649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24650 {
24651 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24652 if (arg2) arg1 = PyList_Size(obj0);
24653 else arg1 = 0;
24654 }
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24658
24659 wxPyEndAllowThreads(__tstate);
24660 if (PyErr_Occurred()) SWIG_fail;
24661 }
24662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24663 {
24664 delete [] arg2;
24665 }
24666 return resultobj;
24667 fail:
24668 {
24669 delete [] arg2;
24670 }
24671 return NULL;
24672 }
24673
24674
24675 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24676 PyObject *resultobj;
24677 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24678 PyObject * obj0 = 0 ;
24679 char *kwnames[] = {
24680 (char *) "self", NULL
24681 };
24682
24683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24685 if (SWIG_arg_fail(1)) SWIG_fail;
24686 {
24687 PyThreadState* __tstate = wxPyBeginAllowThreads();
24688 delete arg1;
24689
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 Py_INCREF(Py_None); resultobj = Py_None;
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24701 PyObject *resultobj;
24702 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24703 bool result;
24704 PyObject * obj0 = 0 ;
24705 char *kwnames[] = {
24706 (char *) "self", NULL
24707 };
24708
24709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24711 if (SWIG_arg_fail(1)) SWIG_fail;
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24715
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 {
24720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24721 }
24722 return resultobj;
24723 fail:
24724 return NULL;
24725 }
24726
24727
24728 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24729 PyObject *obj;
24730 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24731 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24732 Py_INCREF(obj);
24733 return Py_BuildValue((char *)"");
24734 }
24735 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24736 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24737 return 1;
24738 }
24739
24740
24741 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24742 PyObject *pyobj;
24743
24744 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24745 return pyobj;
24746 }
24747
24748
24749 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24750 PyObject *resultobj;
24751 wxString *arg1 = 0 ;
24752 wxAcceleratorEntry *result;
24753 bool temp1 = false ;
24754 PyObject * obj0 = 0 ;
24755 char *kwnames[] = {
24756 (char *) "label", NULL
24757 };
24758
24759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24760 {
24761 arg1 = wxString_in_helper(obj0);
24762 if (arg1 == NULL) SWIG_fail;
24763 temp1 = true;
24764 }
24765 {
24766 PyThreadState* __tstate = wxPyBeginAllowThreads();
24767 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24768
24769 wxPyEndAllowThreads(__tstate);
24770 if (PyErr_Occurred()) SWIG_fail;
24771 }
24772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24773 {
24774 if (temp1)
24775 delete arg1;
24776 }
24777 return resultobj;
24778 fail:
24779 {
24780 if (temp1)
24781 delete arg1;
24782 }
24783 return NULL;
24784 }
24785
24786
24787 static int _wrap_PanelNameStr_set(PyObject *) {
24788 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24789 return 1;
24790 }
24791
24792
24793 static PyObject *_wrap_PanelNameStr_get(void) {
24794 PyObject *pyobj;
24795
24796 {
24797 #if wxUSE_UNICODE
24798 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24799 #else
24800 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24801 #endif
24802 }
24803 return pyobj;
24804 }
24805
24806
24807 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24808 PyObject *resultobj;
24809 wxVisualAttributes *result;
24810 char *kwnames[] = {
24811 NULL
24812 };
24813
24814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (wxVisualAttributes *)new_wxVisualAttributes();
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24823 return resultobj;
24824 fail:
24825 return NULL;
24826 }
24827
24828
24829 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24830 PyObject *resultobj;
24831 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24832 PyObject * obj0 = 0 ;
24833 char *kwnames[] = {
24834 (char *) "self", NULL
24835 };
24836
24837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24839 if (SWIG_arg_fail(1)) SWIG_fail;
24840 {
24841 PyThreadState* __tstate = wxPyBeginAllowThreads();
24842 delete_wxVisualAttributes(arg1);
24843
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 Py_INCREF(Py_None); resultobj = Py_None;
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24855 PyObject *resultobj;
24856 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24857 wxFont *arg2 = (wxFont *) 0 ;
24858 PyObject * obj0 = 0 ;
24859 PyObject * obj1 = 0 ;
24860 char *kwnames[] = {
24861 (char *) "self",(char *) "font", NULL
24862 };
24863
24864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24866 if (SWIG_arg_fail(1)) SWIG_fail;
24867 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24868 if (SWIG_arg_fail(2)) SWIG_fail;
24869 if (arg1) (arg1)->font = *arg2;
24870
24871 Py_INCREF(Py_None); resultobj = Py_None;
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj;
24880 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24881 wxFont *result;
24882 PyObject * obj0 = 0 ;
24883 char *kwnames[] = {
24884 (char *) "self", NULL
24885 };
24886
24887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24889 if (SWIG_arg_fail(1)) SWIG_fail;
24890 result = (wxFont *)& ((arg1)->font);
24891
24892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24893 return resultobj;
24894 fail:
24895 return NULL;
24896 }
24897
24898
24899 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24900 PyObject *resultobj;
24901 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24902 wxColour *arg2 = (wxColour *) 0 ;
24903 PyObject * obj0 = 0 ;
24904 PyObject * obj1 = 0 ;
24905 char *kwnames[] = {
24906 (char *) "self",(char *) "colFg", NULL
24907 };
24908
24909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24911 if (SWIG_arg_fail(1)) SWIG_fail;
24912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24913 if (SWIG_arg_fail(2)) SWIG_fail;
24914 if (arg1) (arg1)->colFg = *arg2;
24915
24916 Py_INCREF(Py_None); resultobj = Py_None;
24917 return resultobj;
24918 fail:
24919 return NULL;
24920 }
24921
24922
24923 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24924 PyObject *resultobj;
24925 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24926 wxColour *result;
24927 PyObject * obj0 = 0 ;
24928 char *kwnames[] = {
24929 (char *) "self", NULL
24930 };
24931
24932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24934 if (SWIG_arg_fail(1)) SWIG_fail;
24935 result = (wxColour *)& ((arg1)->colFg);
24936
24937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24947 wxColour *arg2 = (wxColour *) 0 ;
24948 PyObject * obj0 = 0 ;
24949 PyObject * obj1 = 0 ;
24950 char *kwnames[] = {
24951 (char *) "self",(char *) "colBg", NULL
24952 };
24953
24954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24956 if (SWIG_arg_fail(1)) SWIG_fail;
24957 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24958 if (SWIG_arg_fail(2)) SWIG_fail;
24959 if (arg1) (arg1)->colBg = *arg2;
24960
24961 Py_INCREF(Py_None); resultobj = Py_None;
24962 return resultobj;
24963 fail:
24964 return NULL;
24965 }
24966
24967
24968 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24969 PyObject *resultobj;
24970 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24971 wxColour *result;
24972 PyObject * obj0 = 0 ;
24973 char *kwnames[] = {
24974 (char *) "self", NULL
24975 };
24976
24977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24979 if (SWIG_arg_fail(1)) SWIG_fail;
24980 result = (wxColour *)& ((arg1)->colBg);
24981
24982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24990 PyObject *obj;
24991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24992 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24993 Py_INCREF(obj);
24994 return Py_BuildValue((char *)"");
24995 }
24996 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24997 PyObject *resultobj;
24998 wxWindow *arg1 = (wxWindow *) 0 ;
24999 int arg2 = (int) (int)-1 ;
25000 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25001 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25002 wxSize const &arg4_defvalue = wxDefaultSize ;
25003 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25004 long arg5 = (long) 0 ;
25005 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25006 wxString *arg6 = (wxString *) &arg6_defvalue ;
25007 wxWindow *result;
25008 wxPoint temp3 ;
25009 wxSize temp4 ;
25010 bool temp6 = false ;
25011 PyObject * obj0 = 0 ;
25012 PyObject * obj1 = 0 ;
25013 PyObject * obj2 = 0 ;
25014 PyObject * obj3 = 0 ;
25015 PyObject * obj4 = 0 ;
25016 PyObject * obj5 = 0 ;
25017 char *kwnames[] = {
25018 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25019 };
25020
25021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25023 if (SWIG_arg_fail(1)) SWIG_fail;
25024 if (obj1) {
25025 {
25026 arg2 = (int const)(SWIG_As_int(obj1));
25027 if (SWIG_arg_fail(2)) SWIG_fail;
25028 }
25029 }
25030 if (obj2) {
25031 {
25032 arg3 = &temp3;
25033 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25034 }
25035 }
25036 if (obj3) {
25037 {
25038 arg4 = &temp4;
25039 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25040 }
25041 }
25042 if (obj4) {
25043 {
25044 arg5 = (long)(SWIG_As_long(obj4));
25045 if (SWIG_arg_fail(5)) SWIG_fail;
25046 }
25047 }
25048 if (obj5) {
25049 {
25050 arg6 = wxString_in_helper(obj5);
25051 if (arg6 == NULL) SWIG_fail;
25052 temp6 = true;
25053 }
25054 }
25055 {
25056 if (!wxPyCheckForApp()) SWIG_fail;
25057 PyThreadState* __tstate = wxPyBeginAllowThreads();
25058 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25059
25060 wxPyEndAllowThreads(__tstate);
25061 if (PyErr_Occurred()) SWIG_fail;
25062 }
25063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25064 {
25065 if (temp6)
25066 delete arg6;
25067 }
25068 return resultobj;
25069 fail:
25070 {
25071 if (temp6)
25072 delete arg6;
25073 }
25074 return NULL;
25075 }
25076
25077
25078 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25079 PyObject *resultobj;
25080 wxWindow *result;
25081 char *kwnames[] = {
25082 NULL
25083 };
25084
25085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25086 {
25087 if (!wxPyCheckForApp()) SWIG_fail;
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (wxWindow *)new wxWindow();
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25102 PyObject *resultobj;
25103 wxWindow *arg1 = (wxWindow *) 0 ;
25104 wxWindow *arg2 = (wxWindow *) 0 ;
25105 int arg3 = (int) (int)-1 ;
25106 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25107 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25108 wxSize const &arg5_defvalue = wxDefaultSize ;
25109 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25110 long arg6 = (long) 0 ;
25111 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25112 wxString *arg7 = (wxString *) &arg7_defvalue ;
25113 bool result;
25114 wxPoint temp4 ;
25115 wxSize temp5 ;
25116 bool temp7 = false ;
25117 PyObject * obj0 = 0 ;
25118 PyObject * obj1 = 0 ;
25119 PyObject * obj2 = 0 ;
25120 PyObject * obj3 = 0 ;
25121 PyObject * obj4 = 0 ;
25122 PyObject * obj5 = 0 ;
25123 PyObject * obj6 = 0 ;
25124 char *kwnames[] = {
25125 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25126 };
25127
25128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25130 if (SWIG_arg_fail(1)) SWIG_fail;
25131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25132 if (SWIG_arg_fail(2)) SWIG_fail;
25133 if (obj2) {
25134 {
25135 arg3 = (int const)(SWIG_As_int(obj2));
25136 if (SWIG_arg_fail(3)) SWIG_fail;
25137 }
25138 }
25139 if (obj3) {
25140 {
25141 arg4 = &temp4;
25142 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25143 }
25144 }
25145 if (obj4) {
25146 {
25147 arg5 = &temp5;
25148 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25149 }
25150 }
25151 if (obj5) {
25152 {
25153 arg6 = (long)(SWIG_As_long(obj5));
25154 if (SWIG_arg_fail(6)) SWIG_fail;
25155 }
25156 }
25157 if (obj6) {
25158 {
25159 arg7 = wxString_in_helper(obj6);
25160 if (arg7 == NULL) SWIG_fail;
25161 temp7 = true;
25162 }
25163 }
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25167
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 {
25172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25173 }
25174 {
25175 if (temp7)
25176 delete arg7;
25177 }
25178 return resultobj;
25179 fail:
25180 {
25181 if (temp7)
25182 delete arg7;
25183 }
25184 return NULL;
25185 }
25186
25187
25188 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25189 PyObject *resultobj;
25190 wxWindow *arg1 = (wxWindow *) 0 ;
25191 bool arg2 = (bool) false ;
25192 bool result;
25193 PyObject * obj0 = 0 ;
25194 PyObject * obj1 = 0 ;
25195 char *kwnames[] = {
25196 (char *) "self",(char *) "force", NULL
25197 };
25198
25199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25201 if (SWIG_arg_fail(1)) SWIG_fail;
25202 if (obj1) {
25203 {
25204 arg2 = (bool)(SWIG_As_bool(obj1));
25205 if (SWIG_arg_fail(2)) SWIG_fail;
25206 }
25207 }
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 result = (bool)(arg1)->Close(arg2);
25211
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 {
25216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25217 }
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj;
25226 wxWindow *arg1 = (wxWindow *) 0 ;
25227 bool result;
25228 PyObject * obj0 = 0 ;
25229 char *kwnames[] = {
25230 (char *) "self", NULL
25231 };
25232
25233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25235 if (SWIG_arg_fail(1)) SWIG_fail;
25236 {
25237 PyThreadState* __tstate = wxPyBeginAllowThreads();
25238 result = (bool)(arg1)->Destroy();
25239
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 {
25244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25245 }
25246 return resultobj;
25247 fail:
25248 return NULL;
25249 }
25250
25251
25252 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj;
25254 wxWindow *arg1 = (wxWindow *) 0 ;
25255 bool result;
25256 PyObject * obj0 = 0 ;
25257 char *kwnames[] = {
25258 (char *) "self", NULL
25259 };
25260
25261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25263 if (SWIG_arg_fail(1)) SWIG_fail;
25264 {
25265 PyThreadState* __tstate = wxPyBeginAllowThreads();
25266 result = (bool)(arg1)->DestroyChildren();
25267
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 {
25272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25273 }
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj;
25282 wxWindow *arg1 = (wxWindow *) 0 ;
25283 bool result;
25284 PyObject * obj0 = 0 ;
25285 char *kwnames[] = {
25286 (char *) "self", NULL
25287 };
25288
25289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25291 if (SWIG_arg_fail(1)) SWIG_fail;
25292 {
25293 PyThreadState* __tstate = wxPyBeginAllowThreads();
25294 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25295
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 {
25300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25301 }
25302 return resultobj;
25303 fail:
25304 return NULL;
25305 }
25306
25307
25308 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25309 PyObject *resultobj;
25310 wxWindow *arg1 = (wxWindow *) 0 ;
25311 wxString *arg2 = 0 ;
25312 bool temp2 = false ;
25313 PyObject * obj0 = 0 ;
25314 PyObject * obj1 = 0 ;
25315 char *kwnames[] = {
25316 (char *) "self",(char *) "title", NULL
25317 };
25318
25319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25321 if (SWIG_arg_fail(1)) SWIG_fail;
25322 {
25323 arg2 = wxString_in_helper(obj1);
25324 if (arg2 == NULL) SWIG_fail;
25325 temp2 = true;
25326 }
25327 {
25328 PyThreadState* __tstate = wxPyBeginAllowThreads();
25329 (arg1)->SetTitle((wxString const &)*arg2);
25330
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 Py_INCREF(Py_None); resultobj = Py_None;
25335 {
25336 if (temp2)
25337 delete arg2;
25338 }
25339 return resultobj;
25340 fail:
25341 {
25342 if (temp2)
25343 delete arg2;
25344 }
25345 return NULL;
25346 }
25347
25348
25349 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj;
25351 wxWindow *arg1 = (wxWindow *) 0 ;
25352 wxString result;
25353 PyObject * obj0 = 0 ;
25354 char *kwnames[] = {
25355 (char *) "self", NULL
25356 };
25357
25358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25360 if (SWIG_arg_fail(1)) SWIG_fail;
25361 {
25362 PyThreadState* __tstate = wxPyBeginAllowThreads();
25363 result = ((wxWindow const *)arg1)->GetTitle();
25364
25365 wxPyEndAllowThreads(__tstate);
25366 if (PyErr_Occurred()) SWIG_fail;
25367 }
25368 {
25369 #if wxUSE_UNICODE
25370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25371 #else
25372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25373 #endif
25374 }
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj;
25383 wxWindow *arg1 = (wxWindow *) 0 ;
25384 wxString *arg2 = 0 ;
25385 bool temp2 = false ;
25386 PyObject * obj0 = 0 ;
25387 PyObject * obj1 = 0 ;
25388 char *kwnames[] = {
25389 (char *) "self",(char *) "label", NULL
25390 };
25391
25392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25394 if (SWIG_arg_fail(1)) SWIG_fail;
25395 {
25396 arg2 = wxString_in_helper(obj1);
25397 if (arg2 == NULL) SWIG_fail;
25398 temp2 = true;
25399 }
25400 {
25401 PyThreadState* __tstate = wxPyBeginAllowThreads();
25402 (arg1)->SetLabel((wxString const &)*arg2);
25403
25404 wxPyEndAllowThreads(__tstate);
25405 if (PyErr_Occurred()) SWIG_fail;
25406 }
25407 Py_INCREF(Py_None); resultobj = Py_None;
25408 {
25409 if (temp2)
25410 delete arg2;
25411 }
25412 return resultobj;
25413 fail:
25414 {
25415 if (temp2)
25416 delete arg2;
25417 }
25418 return NULL;
25419 }
25420
25421
25422 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25423 PyObject *resultobj;
25424 wxWindow *arg1 = (wxWindow *) 0 ;
25425 wxString result;
25426 PyObject * obj0 = 0 ;
25427 char *kwnames[] = {
25428 (char *) "self", NULL
25429 };
25430
25431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25433 if (SWIG_arg_fail(1)) SWIG_fail;
25434 {
25435 PyThreadState* __tstate = wxPyBeginAllowThreads();
25436 result = ((wxWindow const *)arg1)->GetLabel();
25437
25438 wxPyEndAllowThreads(__tstate);
25439 if (PyErr_Occurred()) SWIG_fail;
25440 }
25441 {
25442 #if wxUSE_UNICODE
25443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25444 #else
25445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25446 #endif
25447 }
25448 return resultobj;
25449 fail:
25450 return NULL;
25451 }
25452
25453
25454 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25455 PyObject *resultobj;
25456 wxWindow *arg1 = (wxWindow *) 0 ;
25457 wxString *arg2 = 0 ;
25458 bool temp2 = false ;
25459 PyObject * obj0 = 0 ;
25460 PyObject * obj1 = 0 ;
25461 char *kwnames[] = {
25462 (char *) "self",(char *) "name", NULL
25463 };
25464
25465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25467 if (SWIG_arg_fail(1)) SWIG_fail;
25468 {
25469 arg2 = wxString_in_helper(obj1);
25470 if (arg2 == NULL) SWIG_fail;
25471 temp2 = true;
25472 }
25473 {
25474 PyThreadState* __tstate = wxPyBeginAllowThreads();
25475 (arg1)->SetName((wxString const &)*arg2);
25476
25477 wxPyEndAllowThreads(__tstate);
25478 if (PyErr_Occurred()) SWIG_fail;
25479 }
25480 Py_INCREF(Py_None); resultobj = Py_None;
25481 {
25482 if (temp2)
25483 delete arg2;
25484 }
25485 return resultobj;
25486 fail:
25487 {
25488 if (temp2)
25489 delete arg2;
25490 }
25491 return NULL;
25492 }
25493
25494
25495 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj;
25497 wxWindow *arg1 = (wxWindow *) 0 ;
25498 wxString result;
25499 PyObject * obj0 = 0 ;
25500 char *kwnames[] = {
25501 (char *) "self", NULL
25502 };
25503
25504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25506 if (SWIG_arg_fail(1)) SWIG_fail;
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 result = ((wxWindow const *)arg1)->GetName();
25510
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 {
25515 #if wxUSE_UNICODE
25516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25517 #else
25518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25519 #endif
25520 }
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25528 PyObject *resultobj;
25529 wxWindow *arg1 = (wxWindow *) 0 ;
25530 wxWindowVariant arg2 ;
25531 PyObject * obj0 = 0 ;
25532 PyObject * obj1 = 0 ;
25533 char *kwnames[] = {
25534 (char *) "self",(char *) "variant", NULL
25535 };
25536
25537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25539 if (SWIG_arg_fail(1)) SWIG_fail;
25540 {
25541 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25542 if (SWIG_arg_fail(2)) SWIG_fail;
25543 }
25544 {
25545 PyThreadState* __tstate = wxPyBeginAllowThreads();
25546 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25547
25548 wxPyEndAllowThreads(__tstate);
25549 if (PyErr_Occurred()) SWIG_fail;
25550 }
25551 Py_INCREF(Py_None); resultobj = Py_None;
25552 return resultobj;
25553 fail:
25554 return NULL;
25555 }
25556
25557
25558 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25559 PyObject *resultobj;
25560 wxWindow *arg1 = (wxWindow *) 0 ;
25561 wxWindowVariant result;
25562 PyObject * obj0 = 0 ;
25563 char *kwnames[] = {
25564 (char *) "self", NULL
25565 };
25566
25567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25569 if (SWIG_arg_fail(1)) SWIG_fail;
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25573
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 resultobj = SWIG_From_int((result));
25578 return resultobj;
25579 fail:
25580 return NULL;
25581 }
25582
25583
25584 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25585 PyObject *resultobj;
25586 wxWindow *arg1 = (wxWindow *) 0 ;
25587 int arg2 ;
25588 PyObject * obj0 = 0 ;
25589 PyObject * obj1 = 0 ;
25590 char *kwnames[] = {
25591 (char *) "self",(char *) "winid", NULL
25592 };
25593
25594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25596 if (SWIG_arg_fail(1)) SWIG_fail;
25597 {
25598 arg2 = (int)(SWIG_As_int(obj1));
25599 if (SWIG_arg_fail(2)) SWIG_fail;
25600 }
25601 {
25602 PyThreadState* __tstate = wxPyBeginAllowThreads();
25603 (arg1)->SetId(arg2);
25604
25605 wxPyEndAllowThreads(__tstate);
25606 if (PyErr_Occurred()) SWIG_fail;
25607 }
25608 Py_INCREF(Py_None); resultobj = Py_None;
25609 return resultobj;
25610 fail:
25611 return NULL;
25612 }
25613
25614
25615 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25616 PyObject *resultobj;
25617 wxWindow *arg1 = (wxWindow *) 0 ;
25618 int result;
25619 PyObject * obj0 = 0 ;
25620 char *kwnames[] = {
25621 (char *) "self", NULL
25622 };
25623
25624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25626 if (SWIG_arg_fail(1)) SWIG_fail;
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 result = (int)((wxWindow const *)arg1)->GetId();
25630
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 {
25635 resultobj = SWIG_From_int((int)(result));
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25644 PyObject *resultobj;
25645 int result;
25646 char *kwnames[] = {
25647 NULL
25648 };
25649
25650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 result = (int)wxWindow::NewControlId();
25654
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 {
25659 resultobj = SWIG_From_int((int)(result));
25660 }
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj;
25669 int arg1 ;
25670 int result;
25671 PyObject * obj0 = 0 ;
25672 char *kwnames[] = {
25673 (char *) "winid", NULL
25674 };
25675
25676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25677 {
25678 arg1 = (int)(SWIG_As_int(obj0));
25679 if (SWIG_arg_fail(1)) SWIG_fail;
25680 }
25681 {
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 result = (int)wxWindow::NextControlId(arg1);
25684
25685 wxPyEndAllowThreads(__tstate);
25686 if (PyErr_Occurred()) SWIG_fail;
25687 }
25688 {
25689 resultobj = SWIG_From_int((int)(result));
25690 }
25691 return resultobj;
25692 fail:
25693 return NULL;
25694 }
25695
25696
25697 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25698 PyObject *resultobj;
25699 int arg1 ;
25700 int result;
25701 PyObject * obj0 = 0 ;
25702 char *kwnames[] = {
25703 (char *) "winid", NULL
25704 };
25705
25706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25707 {
25708 arg1 = (int)(SWIG_As_int(obj0));
25709 if (SWIG_arg_fail(1)) SWIG_fail;
25710 }
25711 {
25712 PyThreadState* __tstate = wxPyBeginAllowThreads();
25713 result = (int)wxWindow::PrevControlId(arg1);
25714
25715 wxPyEndAllowThreads(__tstate);
25716 if (PyErr_Occurred()) SWIG_fail;
25717 }
25718 {
25719 resultobj = SWIG_From_int((int)(result));
25720 }
25721 return resultobj;
25722 fail:
25723 return NULL;
25724 }
25725
25726
25727 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25728 PyObject *resultobj;
25729 wxWindow *arg1 = (wxWindow *) 0 ;
25730 wxSize *arg2 = 0 ;
25731 wxSize temp2 ;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 char *kwnames[] = {
25735 (char *) "self",(char *) "size", NULL
25736 };
25737
25738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25740 if (SWIG_arg_fail(1)) SWIG_fail;
25741 {
25742 arg2 = &temp2;
25743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25744 }
25745 {
25746 PyThreadState* __tstate = wxPyBeginAllowThreads();
25747 (arg1)->SetSize((wxSize const &)*arg2);
25748
25749 wxPyEndAllowThreads(__tstate);
25750 if (PyErr_Occurred()) SWIG_fail;
25751 }
25752 Py_INCREF(Py_None); resultobj = Py_None;
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25760 PyObject *resultobj;
25761 wxWindow *arg1 = (wxWindow *) 0 ;
25762 int arg2 ;
25763 int arg3 ;
25764 int arg4 ;
25765 int arg5 ;
25766 int arg6 = (int) wxSIZE_AUTO ;
25767 PyObject * obj0 = 0 ;
25768 PyObject * obj1 = 0 ;
25769 PyObject * obj2 = 0 ;
25770 PyObject * obj3 = 0 ;
25771 PyObject * obj4 = 0 ;
25772 PyObject * obj5 = 0 ;
25773 char *kwnames[] = {
25774 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25775 };
25776
25777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25779 if (SWIG_arg_fail(1)) SWIG_fail;
25780 {
25781 arg2 = (int)(SWIG_As_int(obj1));
25782 if (SWIG_arg_fail(2)) SWIG_fail;
25783 }
25784 {
25785 arg3 = (int)(SWIG_As_int(obj2));
25786 if (SWIG_arg_fail(3)) SWIG_fail;
25787 }
25788 {
25789 arg4 = (int)(SWIG_As_int(obj3));
25790 if (SWIG_arg_fail(4)) SWIG_fail;
25791 }
25792 {
25793 arg5 = (int)(SWIG_As_int(obj4));
25794 if (SWIG_arg_fail(5)) SWIG_fail;
25795 }
25796 if (obj5) {
25797 {
25798 arg6 = (int)(SWIG_As_int(obj5));
25799 if (SWIG_arg_fail(6)) SWIG_fail;
25800 }
25801 }
25802 {
25803 PyThreadState* __tstate = wxPyBeginAllowThreads();
25804 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25805
25806 wxPyEndAllowThreads(__tstate);
25807 if (PyErr_Occurred()) SWIG_fail;
25808 }
25809 Py_INCREF(Py_None); resultobj = Py_None;
25810 return resultobj;
25811 fail:
25812 return NULL;
25813 }
25814
25815
25816 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj;
25818 wxWindow *arg1 = (wxWindow *) 0 ;
25819 wxRect *arg2 = 0 ;
25820 int arg3 = (int) wxSIZE_AUTO ;
25821 wxRect temp2 ;
25822 PyObject * obj0 = 0 ;
25823 PyObject * obj1 = 0 ;
25824 PyObject * obj2 = 0 ;
25825 char *kwnames[] = {
25826 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25827 };
25828
25829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25831 if (SWIG_arg_fail(1)) SWIG_fail;
25832 {
25833 arg2 = &temp2;
25834 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25835 }
25836 if (obj2) {
25837 {
25838 arg3 = (int)(SWIG_As_int(obj2));
25839 if (SWIG_arg_fail(3)) SWIG_fail;
25840 }
25841 }
25842 {
25843 PyThreadState* __tstate = wxPyBeginAllowThreads();
25844 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25845
25846 wxPyEndAllowThreads(__tstate);
25847 if (PyErr_Occurred()) SWIG_fail;
25848 }
25849 Py_INCREF(Py_None); resultobj = Py_None;
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj;
25858 wxWindow *arg1 = (wxWindow *) 0 ;
25859 int arg2 ;
25860 int arg3 ;
25861 PyObject * obj0 = 0 ;
25862 PyObject * obj1 = 0 ;
25863 PyObject * obj2 = 0 ;
25864 char *kwnames[] = {
25865 (char *) "self",(char *) "width",(char *) "height", NULL
25866 };
25867
25868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25870 if (SWIG_arg_fail(1)) SWIG_fail;
25871 {
25872 arg2 = (int)(SWIG_As_int(obj1));
25873 if (SWIG_arg_fail(2)) SWIG_fail;
25874 }
25875 {
25876 arg3 = (int)(SWIG_As_int(obj2));
25877 if (SWIG_arg_fail(3)) SWIG_fail;
25878 }
25879 {
25880 PyThreadState* __tstate = wxPyBeginAllowThreads();
25881 (arg1)->SetSize(arg2,arg3);
25882
25883 wxPyEndAllowThreads(__tstate);
25884 if (PyErr_Occurred()) SWIG_fail;
25885 }
25886 Py_INCREF(Py_None); resultobj = Py_None;
25887 return resultobj;
25888 fail:
25889 return NULL;
25890 }
25891
25892
25893 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25894 PyObject *resultobj;
25895 wxWindow *arg1 = (wxWindow *) 0 ;
25896 wxPoint *arg2 = 0 ;
25897 int arg3 = (int) wxSIZE_USE_EXISTING ;
25898 wxPoint temp2 ;
25899 PyObject * obj0 = 0 ;
25900 PyObject * obj1 = 0 ;
25901 PyObject * obj2 = 0 ;
25902 char *kwnames[] = {
25903 (char *) "self",(char *) "pt",(char *) "flags", NULL
25904 };
25905
25906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25908 if (SWIG_arg_fail(1)) SWIG_fail;
25909 {
25910 arg2 = &temp2;
25911 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25912 }
25913 if (obj2) {
25914 {
25915 arg3 = (int)(SWIG_As_int(obj2));
25916 if (SWIG_arg_fail(3)) SWIG_fail;
25917 }
25918 }
25919 {
25920 PyThreadState* __tstate = wxPyBeginAllowThreads();
25921 (arg1)->Move((wxPoint const &)*arg2,arg3);
25922
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 Py_INCREF(Py_None); resultobj = Py_None;
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25934 PyObject *resultobj;
25935 wxWindow *arg1 = (wxWindow *) 0 ;
25936 int arg2 ;
25937 int arg3 ;
25938 int arg4 = (int) wxSIZE_USE_EXISTING ;
25939 PyObject * obj0 = 0 ;
25940 PyObject * obj1 = 0 ;
25941 PyObject * obj2 = 0 ;
25942 PyObject * obj3 = 0 ;
25943 char *kwnames[] = {
25944 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25945 };
25946
25947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25949 if (SWIG_arg_fail(1)) SWIG_fail;
25950 {
25951 arg2 = (int)(SWIG_As_int(obj1));
25952 if (SWIG_arg_fail(2)) SWIG_fail;
25953 }
25954 {
25955 arg3 = (int)(SWIG_As_int(obj2));
25956 if (SWIG_arg_fail(3)) SWIG_fail;
25957 }
25958 if (obj3) {
25959 {
25960 arg4 = (int)(SWIG_As_int(obj3));
25961 if (SWIG_arg_fail(4)) SWIG_fail;
25962 }
25963 }
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 (arg1)->Move(arg2,arg3,arg4);
25967
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 Py_INCREF(Py_None); resultobj = Py_None;
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj;
25980 wxWindow *arg1 = (wxWindow *) 0 ;
25981 wxSize const &arg2_defvalue = wxDefaultSize ;
25982 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25983 wxSize temp2 ;
25984 PyObject * obj0 = 0 ;
25985 PyObject * obj1 = 0 ;
25986 char *kwnames[] = {
25987 (char *) "self",(char *) "size", NULL
25988 };
25989
25990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25992 if (SWIG_arg_fail(1)) SWIG_fail;
25993 if (obj1) {
25994 {
25995 arg2 = &temp2;
25996 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25997 }
25998 }
25999 {
26000 PyThreadState* __tstate = wxPyBeginAllowThreads();
26001 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26002
26003 wxPyEndAllowThreads(__tstate);
26004 if (PyErr_Occurred()) SWIG_fail;
26005 }
26006 Py_INCREF(Py_None); resultobj = Py_None;
26007 return resultobj;
26008 fail:
26009 return NULL;
26010 }
26011
26012
26013 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26014 PyObject *resultobj;
26015 wxWindow *arg1 = (wxWindow *) 0 ;
26016 PyObject * obj0 = 0 ;
26017 char *kwnames[] = {
26018 (char *) "self", NULL
26019 };
26020
26021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26023 if (SWIG_arg_fail(1)) SWIG_fail;
26024 {
26025 PyThreadState* __tstate = wxPyBeginAllowThreads();
26026 (arg1)->Raise();
26027
26028 wxPyEndAllowThreads(__tstate);
26029 if (PyErr_Occurred()) SWIG_fail;
26030 }
26031 Py_INCREF(Py_None); resultobj = Py_None;
26032 return resultobj;
26033 fail:
26034 return NULL;
26035 }
26036
26037
26038 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26039 PyObject *resultobj;
26040 wxWindow *arg1 = (wxWindow *) 0 ;
26041 PyObject * obj0 = 0 ;
26042 char *kwnames[] = {
26043 (char *) "self", NULL
26044 };
26045
26046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26048 if (SWIG_arg_fail(1)) SWIG_fail;
26049 {
26050 PyThreadState* __tstate = wxPyBeginAllowThreads();
26051 (arg1)->Lower();
26052
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 Py_INCREF(Py_None); resultobj = Py_None;
26057 return resultobj;
26058 fail:
26059 return NULL;
26060 }
26061
26062
26063 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26064 PyObject *resultobj;
26065 wxWindow *arg1 = (wxWindow *) 0 ;
26066 wxSize *arg2 = 0 ;
26067 wxSize temp2 ;
26068 PyObject * obj0 = 0 ;
26069 PyObject * obj1 = 0 ;
26070 char *kwnames[] = {
26071 (char *) "self",(char *) "size", NULL
26072 };
26073
26074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26076 if (SWIG_arg_fail(1)) SWIG_fail;
26077 {
26078 arg2 = &temp2;
26079 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26080 }
26081 {
26082 PyThreadState* __tstate = wxPyBeginAllowThreads();
26083 (arg1)->SetClientSize((wxSize const &)*arg2);
26084
26085 wxPyEndAllowThreads(__tstate);
26086 if (PyErr_Occurred()) SWIG_fail;
26087 }
26088 Py_INCREF(Py_None); resultobj = Py_None;
26089 return resultobj;
26090 fail:
26091 return NULL;
26092 }
26093
26094
26095 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26096 PyObject *resultobj;
26097 wxWindow *arg1 = (wxWindow *) 0 ;
26098 int arg2 ;
26099 int arg3 ;
26100 PyObject * obj0 = 0 ;
26101 PyObject * obj1 = 0 ;
26102 PyObject * obj2 = 0 ;
26103 char *kwnames[] = {
26104 (char *) "self",(char *) "width",(char *) "height", NULL
26105 };
26106
26107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26109 if (SWIG_arg_fail(1)) SWIG_fail;
26110 {
26111 arg2 = (int)(SWIG_As_int(obj1));
26112 if (SWIG_arg_fail(2)) SWIG_fail;
26113 }
26114 {
26115 arg3 = (int)(SWIG_As_int(obj2));
26116 if (SWIG_arg_fail(3)) SWIG_fail;
26117 }
26118 {
26119 PyThreadState* __tstate = wxPyBeginAllowThreads();
26120 (arg1)->SetClientSize(arg2,arg3);
26121
26122 wxPyEndAllowThreads(__tstate);
26123 if (PyErr_Occurred()) SWIG_fail;
26124 }
26125 Py_INCREF(Py_None); resultobj = Py_None;
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj;
26134 wxWindow *arg1 = (wxWindow *) 0 ;
26135 wxRect *arg2 = 0 ;
26136 wxRect temp2 ;
26137 PyObject * obj0 = 0 ;
26138 PyObject * obj1 = 0 ;
26139 char *kwnames[] = {
26140 (char *) "self",(char *) "rect", NULL
26141 };
26142
26143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26145 if (SWIG_arg_fail(1)) SWIG_fail;
26146 {
26147 arg2 = &temp2;
26148 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26149 }
26150 {
26151 PyThreadState* __tstate = wxPyBeginAllowThreads();
26152 (arg1)->SetClientSize((wxRect const &)*arg2);
26153
26154 wxPyEndAllowThreads(__tstate);
26155 if (PyErr_Occurred()) SWIG_fail;
26156 }
26157 Py_INCREF(Py_None); resultobj = Py_None;
26158 return resultobj;
26159 fail:
26160 return NULL;
26161 }
26162
26163
26164 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26165 PyObject *resultobj;
26166 wxWindow *arg1 = (wxWindow *) 0 ;
26167 wxPoint result;
26168 PyObject * obj0 = 0 ;
26169 char *kwnames[] = {
26170 (char *) "self", NULL
26171 };
26172
26173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26175 if (SWIG_arg_fail(1)) SWIG_fail;
26176 {
26177 PyThreadState* __tstate = wxPyBeginAllowThreads();
26178 result = (arg1)->GetPosition();
26179
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 {
26184 wxPoint * resultptr;
26185 resultptr = new wxPoint((wxPoint &)(result));
26186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26187 }
26188 return resultobj;
26189 fail:
26190 return NULL;
26191 }
26192
26193
26194 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26195 PyObject *resultobj;
26196 wxWindow *arg1 = (wxWindow *) 0 ;
26197 int *arg2 = (int *) 0 ;
26198 int *arg3 = (int *) 0 ;
26199 int temp2 ;
26200 int res2 = 0 ;
26201 int temp3 ;
26202 int res3 = 0 ;
26203 PyObject * obj0 = 0 ;
26204 char *kwnames[] = {
26205 (char *) "self", NULL
26206 };
26207
26208 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26209 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) 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 {
26214 PyThreadState* __tstate = wxPyBeginAllowThreads();
26215 (arg1)->GetPosition(arg2,arg3);
26216
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 Py_INCREF(Py_None); resultobj = Py_None;
26221 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26222 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26223 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26224 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26225 return resultobj;
26226 fail:
26227 return NULL;
26228 }
26229
26230
26231 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26232 PyObject *resultobj;
26233 wxWindow *arg1 = (wxWindow *) 0 ;
26234 wxSize result;
26235 PyObject * obj0 = 0 ;
26236 char *kwnames[] = {
26237 (char *) "self", NULL
26238 };
26239
26240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26242 if (SWIG_arg_fail(1)) SWIG_fail;
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 result = ((wxWindow const *)arg1)->GetSize();
26246
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 {
26251 wxSize * resultptr;
26252 resultptr = new wxSize((wxSize &)(result));
26253 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26254 }
26255 return resultobj;
26256 fail:
26257 return NULL;
26258 }
26259
26260
26261 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26262 PyObject *resultobj;
26263 wxWindow *arg1 = (wxWindow *) 0 ;
26264 int *arg2 = (int *) 0 ;
26265 int *arg3 = (int *) 0 ;
26266 int temp2 ;
26267 int res2 = 0 ;
26268 int temp3 ;
26269 int res3 = 0 ;
26270 PyObject * obj0 = 0 ;
26271 char *kwnames[] = {
26272 (char *) "self", NULL
26273 };
26274
26275 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26276 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26279 if (SWIG_arg_fail(1)) SWIG_fail;
26280 {
26281 PyThreadState* __tstate = wxPyBeginAllowThreads();
26282 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26283
26284 wxPyEndAllowThreads(__tstate);
26285 if (PyErr_Occurred()) SWIG_fail;
26286 }
26287 Py_INCREF(Py_None); resultobj = Py_None;
26288 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26289 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26290 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26291 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26292 return resultobj;
26293 fail:
26294 return NULL;
26295 }
26296
26297
26298 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26299 PyObject *resultobj;
26300 wxWindow *arg1 = (wxWindow *) 0 ;
26301 wxRect result;
26302 PyObject * obj0 = 0 ;
26303 char *kwnames[] = {
26304 (char *) "self", NULL
26305 };
26306
26307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26309 if (SWIG_arg_fail(1)) SWIG_fail;
26310 {
26311 PyThreadState* __tstate = wxPyBeginAllowThreads();
26312 result = ((wxWindow const *)arg1)->GetRect();
26313
26314 wxPyEndAllowThreads(__tstate);
26315 if (PyErr_Occurred()) SWIG_fail;
26316 }
26317 {
26318 wxRect * resultptr;
26319 resultptr = new wxRect((wxRect &)(result));
26320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26321 }
26322 return resultobj;
26323 fail:
26324 return NULL;
26325 }
26326
26327
26328 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26329 PyObject *resultobj;
26330 wxWindow *arg1 = (wxWindow *) 0 ;
26331 wxSize result;
26332 PyObject * obj0 = 0 ;
26333 char *kwnames[] = {
26334 (char *) "self", NULL
26335 };
26336
26337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26339 if (SWIG_arg_fail(1)) SWIG_fail;
26340 {
26341 PyThreadState* __tstate = wxPyBeginAllowThreads();
26342 result = ((wxWindow const *)arg1)->GetClientSize();
26343
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 {
26348 wxSize * resultptr;
26349 resultptr = new wxSize((wxSize &)(result));
26350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26351 }
26352 return resultobj;
26353 fail:
26354 return NULL;
26355 }
26356
26357
26358 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26359 PyObject *resultobj;
26360 wxWindow *arg1 = (wxWindow *) 0 ;
26361 int *arg2 = (int *) 0 ;
26362 int *arg3 = (int *) 0 ;
26363 int temp2 ;
26364 int res2 = 0 ;
26365 int temp3 ;
26366 int res3 = 0 ;
26367 PyObject * obj0 = 0 ;
26368 char *kwnames[] = {
26369 (char *) "self", NULL
26370 };
26371
26372 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26373 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26376 if (SWIG_arg_fail(1)) SWIG_fail;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 Py_INCREF(Py_None); resultobj = Py_None;
26385 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26386 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26387 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26388 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26389 return resultobj;
26390 fail:
26391 return NULL;
26392 }
26393
26394
26395 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26396 PyObject *resultobj;
26397 wxWindow *arg1 = (wxWindow *) 0 ;
26398 wxPoint result;
26399 PyObject * obj0 = 0 ;
26400 char *kwnames[] = {
26401 (char *) "self", NULL
26402 };
26403
26404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26406 if (SWIG_arg_fail(1)) SWIG_fail;
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26410
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 {
26415 wxPoint * resultptr;
26416 resultptr = new wxPoint((wxPoint &)(result));
26417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26418 }
26419 return resultobj;
26420 fail:
26421 return NULL;
26422 }
26423
26424
26425 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26426 PyObject *resultobj;
26427 wxWindow *arg1 = (wxWindow *) 0 ;
26428 wxRect result;
26429 PyObject * obj0 = 0 ;
26430 char *kwnames[] = {
26431 (char *) "self", NULL
26432 };
26433
26434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26436 if (SWIG_arg_fail(1)) SWIG_fail;
26437 {
26438 PyThreadState* __tstate = wxPyBeginAllowThreads();
26439 result = ((wxWindow const *)arg1)->GetClientRect();
26440
26441 wxPyEndAllowThreads(__tstate);
26442 if (PyErr_Occurred()) SWIG_fail;
26443 }
26444 {
26445 wxRect * resultptr;
26446 resultptr = new wxRect((wxRect &)(result));
26447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26448 }
26449 return resultobj;
26450 fail:
26451 return NULL;
26452 }
26453
26454
26455 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26456 PyObject *resultobj;
26457 wxWindow *arg1 = (wxWindow *) 0 ;
26458 wxSize result;
26459 PyObject * obj0 = 0 ;
26460 char *kwnames[] = {
26461 (char *) "self", NULL
26462 };
26463
26464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26466 if (SWIG_arg_fail(1)) SWIG_fail;
26467 {
26468 PyThreadState* __tstate = wxPyBeginAllowThreads();
26469 result = ((wxWindow const *)arg1)->GetBestSize();
26470
26471 wxPyEndAllowThreads(__tstate);
26472 if (PyErr_Occurred()) SWIG_fail;
26473 }
26474 {
26475 wxSize * resultptr;
26476 resultptr = new wxSize((wxSize &)(result));
26477 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26478 }
26479 return resultobj;
26480 fail:
26481 return NULL;
26482 }
26483
26484
26485 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26486 PyObject *resultobj;
26487 wxWindow *arg1 = (wxWindow *) 0 ;
26488 int *arg2 = (int *) 0 ;
26489 int *arg3 = (int *) 0 ;
26490 int temp2 ;
26491 int res2 = 0 ;
26492 int temp3 ;
26493 int res3 = 0 ;
26494 PyObject * obj0 = 0 ;
26495 char *kwnames[] = {
26496 (char *) "self", NULL
26497 };
26498
26499 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26500 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26503 if (SWIG_arg_fail(1)) SWIG_fail;
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26507
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 Py_INCREF(Py_None); resultobj = Py_None;
26512 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26513 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26514 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26515 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj;
26524 wxWindow *arg1 = (wxWindow *) 0 ;
26525 PyObject * obj0 = 0 ;
26526 char *kwnames[] = {
26527 (char *) "self", NULL
26528 };
26529
26530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26532 if (SWIG_arg_fail(1)) SWIG_fail;
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 (arg1)->InvalidateBestSize();
26536
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 Py_INCREF(Py_None); resultobj = Py_None;
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26548 PyObject *resultobj;
26549 wxWindow *arg1 = (wxWindow *) 0 ;
26550 wxSize *arg2 = 0 ;
26551 wxSize temp2 ;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554 char *kwnames[] = {
26555 (char *) "self",(char *) "size", NULL
26556 };
26557
26558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
26559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26560 if (SWIG_arg_fail(1)) SWIG_fail;
26561 {
26562 arg2 = &temp2;
26563 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26564 }
26565 {
26566 PyThreadState* __tstate = wxPyBeginAllowThreads();
26567 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
26568
26569 wxPyEndAllowThreads(__tstate);
26570 if (PyErr_Occurred()) SWIG_fail;
26571 }
26572 Py_INCREF(Py_None); resultobj = Py_None;
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26580 PyObject *resultobj;
26581 wxWindow *arg1 = (wxWindow *) 0 ;
26582 wxSize result;
26583 PyObject * obj0 = 0 ;
26584 char *kwnames[] = {
26585 (char *) "self", NULL
26586 };
26587
26588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26590 if (SWIG_arg_fail(1)) SWIG_fail;
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26594
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 {
26599 wxSize * resultptr;
26600 resultptr = new wxSize((wxSize &)(result));
26601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26602 }
26603 return resultobj;
26604 fail:
26605 return NULL;
26606 }
26607
26608
26609 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj;
26611 wxWindow *arg1 = (wxWindow *) 0 ;
26612 wxSize result;
26613 PyObject * obj0 = 0 ;
26614 char *kwnames[] = {
26615 (char *) "self", NULL
26616 };
26617
26618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26620 if (SWIG_arg_fail(1)) SWIG_fail;
26621 {
26622 PyThreadState* __tstate = wxPyBeginAllowThreads();
26623 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26624
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 {
26629 wxSize * resultptr;
26630 resultptr = new wxSize((wxSize &)(result));
26631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26632 }
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj;
26641 wxWindow *arg1 = (wxWindow *) 0 ;
26642 int arg2 = (int) wxBOTH ;
26643 PyObject * obj0 = 0 ;
26644 PyObject * obj1 = 0 ;
26645 char *kwnames[] = {
26646 (char *) "self",(char *) "direction", NULL
26647 };
26648
26649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26651 if (SWIG_arg_fail(1)) SWIG_fail;
26652 if (obj1) {
26653 {
26654 arg2 = (int)(SWIG_As_int(obj1));
26655 if (SWIG_arg_fail(2)) SWIG_fail;
26656 }
26657 }
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 (arg1)->Center(arg2);
26661
26662 wxPyEndAllowThreads(__tstate);
26663 if (PyErr_Occurred()) SWIG_fail;
26664 }
26665 Py_INCREF(Py_None); resultobj = Py_None;
26666 return resultobj;
26667 fail:
26668 return NULL;
26669 }
26670
26671
26672 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26673 PyObject *resultobj;
26674 wxWindow *arg1 = (wxWindow *) 0 ;
26675 int arg2 = (int) wxBOTH ;
26676 PyObject * obj0 = 0 ;
26677 PyObject * obj1 = 0 ;
26678 char *kwnames[] = {
26679 (char *) "self",(char *) "dir", NULL
26680 };
26681
26682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26684 if (SWIG_arg_fail(1)) SWIG_fail;
26685 if (obj1) {
26686 {
26687 arg2 = (int)(SWIG_As_int(obj1));
26688 if (SWIG_arg_fail(2)) SWIG_fail;
26689 }
26690 }
26691 {
26692 PyThreadState* __tstate = wxPyBeginAllowThreads();
26693 (arg1)->CenterOnScreen(arg2);
26694
26695 wxPyEndAllowThreads(__tstate);
26696 if (PyErr_Occurred()) SWIG_fail;
26697 }
26698 Py_INCREF(Py_None); resultobj = Py_None;
26699 return resultobj;
26700 fail:
26701 return NULL;
26702 }
26703
26704
26705 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26706 PyObject *resultobj;
26707 wxWindow *arg1 = (wxWindow *) 0 ;
26708 int arg2 = (int) wxBOTH ;
26709 PyObject * obj0 = 0 ;
26710 PyObject * obj1 = 0 ;
26711 char *kwnames[] = {
26712 (char *) "self",(char *) "dir", NULL
26713 };
26714
26715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26717 if (SWIG_arg_fail(1)) SWIG_fail;
26718 if (obj1) {
26719 {
26720 arg2 = (int)(SWIG_As_int(obj1));
26721 if (SWIG_arg_fail(2)) SWIG_fail;
26722 }
26723 }
26724 {
26725 PyThreadState* __tstate = wxPyBeginAllowThreads();
26726 (arg1)->CenterOnParent(arg2);
26727
26728 wxPyEndAllowThreads(__tstate);
26729 if (PyErr_Occurred()) SWIG_fail;
26730 }
26731 Py_INCREF(Py_None); resultobj = Py_None;
26732 return resultobj;
26733 fail:
26734 return NULL;
26735 }
26736
26737
26738 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26739 PyObject *resultobj;
26740 wxWindow *arg1 = (wxWindow *) 0 ;
26741 PyObject * obj0 = 0 ;
26742 char *kwnames[] = {
26743 (char *) "self", NULL
26744 };
26745
26746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26751 (arg1)->Fit();
26752
26753 wxPyEndAllowThreads(__tstate);
26754 if (PyErr_Occurred()) SWIG_fail;
26755 }
26756 Py_INCREF(Py_None); resultobj = Py_None;
26757 return resultobj;
26758 fail:
26759 return NULL;
26760 }
26761
26762
26763 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26764 PyObject *resultobj;
26765 wxWindow *arg1 = (wxWindow *) 0 ;
26766 PyObject * obj0 = 0 ;
26767 char *kwnames[] = {
26768 (char *) "self", NULL
26769 };
26770
26771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26773 if (SWIG_arg_fail(1)) SWIG_fail;
26774 {
26775 PyThreadState* __tstate = wxPyBeginAllowThreads();
26776 (arg1)->FitInside();
26777
26778 wxPyEndAllowThreads(__tstate);
26779 if (PyErr_Occurred()) SWIG_fail;
26780 }
26781 Py_INCREF(Py_None); resultobj = Py_None;
26782 return resultobj;
26783 fail:
26784 return NULL;
26785 }
26786
26787
26788 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26789 PyObject *resultobj;
26790 wxWindow *arg1 = (wxWindow *) 0 ;
26791 int arg2 ;
26792 int arg3 ;
26793 int arg4 = (int) -1 ;
26794 int arg5 = (int) -1 ;
26795 int arg6 = (int) -1 ;
26796 int arg7 = (int) -1 ;
26797 PyObject * obj0 = 0 ;
26798 PyObject * obj1 = 0 ;
26799 PyObject * obj2 = 0 ;
26800 PyObject * obj3 = 0 ;
26801 PyObject * obj4 = 0 ;
26802 PyObject * obj5 = 0 ;
26803 PyObject * obj6 = 0 ;
26804 char *kwnames[] = {
26805 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26806 };
26807
26808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26810 if (SWIG_arg_fail(1)) SWIG_fail;
26811 {
26812 arg2 = (int)(SWIG_As_int(obj1));
26813 if (SWIG_arg_fail(2)) SWIG_fail;
26814 }
26815 {
26816 arg3 = (int)(SWIG_As_int(obj2));
26817 if (SWIG_arg_fail(3)) SWIG_fail;
26818 }
26819 if (obj3) {
26820 {
26821 arg4 = (int)(SWIG_As_int(obj3));
26822 if (SWIG_arg_fail(4)) SWIG_fail;
26823 }
26824 }
26825 if (obj4) {
26826 {
26827 arg5 = (int)(SWIG_As_int(obj4));
26828 if (SWIG_arg_fail(5)) SWIG_fail;
26829 }
26830 }
26831 if (obj5) {
26832 {
26833 arg6 = (int)(SWIG_As_int(obj5));
26834 if (SWIG_arg_fail(6)) SWIG_fail;
26835 }
26836 }
26837 if (obj6) {
26838 {
26839 arg7 = (int)(SWIG_As_int(obj6));
26840 if (SWIG_arg_fail(7)) SWIG_fail;
26841 }
26842 }
26843 {
26844 PyThreadState* __tstate = wxPyBeginAllowThreads();
26845 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26846
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 Py_INCREF(Py_None); resultobj = Py_None;
26851 return resultobj;
26852 fail:
26853 return NULL;
26854 }
26855
26856
26857 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26858 PyObject *resultobj;
26859 wxWindow *arg1 = (wxWindow *) 0 ;
26860 wxSize *arg2 = 0 ;
26861 wxSize const &arg3_defvalue = wxDefaultSize ;
26862 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26863 wxSize const &arg4_defvalue = wxDefaultSize ;
26864 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26865 wxSize temp2 ;
26866 wxSize temp3 ;
26867 wxSize temp4 ;
26868 PyObject * obj0 = 0 ;
26869 PyObject * obj1 = 0 ;
26870 PyObject * obj2 = 0 ;
26871 PyObject * obj3 = 0 ;
26872 char *kwnames[] = {
26873 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26874 };
26875
26876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26878 if (SWIG_arg_fail(1)) SWIG_fail;
26879 {
26880 arg2 = &temp2;
26881 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26882 }
26883 if (obj2) {
26884 {
26885 arg3 = &temp3;
26886 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26887 }
26888 }
26889 if (obj3) {
26890 {
26891 arg4 = &temp4;
26892 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26893 }
26894 }
26895 {
26896 PyThreadState* __tstate = wxPyBeginAllowThreads();
26897 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26898
26899 wxPyEndAllowThreads(__tstate);
26900 if (PyErr_Occurred()) SWIG_fail;
26901 }
26902 Py_INCREF(Py_None); resultobj = Py_None;
26903 return resultobj;
26904 fail:
26905 return NULL;
26906 }
26907
26908
26909 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26910 PyObject *resultobj;
26911 wxWindow *arg1 = (wxWindow *) 0 ;
26912 int arg2 ;
26913 int arg3 ;
26914 int arg4 = (int) -1 ;
26915 int arg5 = (int) -1 ;
26916 PyObject * obj0 = 0 ;
26917 PyObject * obj1 = 0 ;
26918 PyObject * obj2 = 0 ;
26919 PyObject * obj3 = 0 ;
26920 PyObject * obj4 = 0 ;
26921 char *kwnames[] = {
26922 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26923 };
26924
26925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26927 if (SWIG_arg_fail(1)) SWIG_fail;
26928 {
26929 arg2 = (int)(SWIG_As_int(obj1));
26930 if (SWIG_arg_fail(2)) SWIG_fail;
26931 }
26932 {
26933 arg3 = (int)(SWIG_As_int(obj2));
26934 if (SWIG_arg_fail(3)) SWIG_fail;
26935 }
26936 if (obj3) {
26937 {
26938 arg4 = (int)(SWIG_As_int(obj3));
26939 if (SWIG_arg_fail(4)) SWIG_fail;
26940 }
26941 }
26942 if (obj4) {
26943 {
26944 arg5 = (int)(SWIG_As_int(obj4));
26945 if (SWIG_arg_fail(5)) SWIG_fail;
26946 }
26947 }
26948 {
26949 PyThreadState* __tstate = wxPyBeginAllowThreads();
26950 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26951
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 Py_INCREF(Py_None); resultobj = Py_None;
26956 return resultobj;
26957 fail:
26958 return NULL;
26959 }
26960
26961
26962 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26963 PyObject *resultobj;
26964 wxWindow *arg1 = (wxWindow *) 0 ;
26965 wxSize *arg2 = 0 ;
26966 wxSize const &arg3_defvalue = wxDefaultSize ;
26967 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26968 wxSize temp2 ;
26969 wxSize temp3 ;
26970 PyObject * obj0 = 0 ;
26971 PyObject * obj1 = 0 ;
26972 PyObject * obj2 = 0 ;
26973 char *kwnames[] = {
26974 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26975 };
26976
26977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26979 if (SWIG_arg_fail(1)) SWIG_fail;
26980 {
26981 arg2 = &temp2;
26982 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26983 }
26984 if (obj2) {
26985 {
26986 arg3 = &temp3;
26987 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26988 }
26989 }
26990 {
26991 PyThreadState* __tstate = wxPyBeginAllowThreads();
26992 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26993
26994 wxPyEndAllowThreads(__tstate);
26995 if (PyErr_Occurred()) SWIG_fail;
26996 }
26997 Py_INCREF(Py_None); resultobj = Py_None;
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27005 PyObject *resultobj;
27006 wxWindow *arg1 = (wxWindow *) 0 ;
27007 wxSize result;
27008 PyObject * obj0 = 0 ;
27009 char *kwnames[] = {
27010 (char *) "self", NULL
27011 };
27012
27013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27015 if (SWIG_arg_fail(1)) SWIG_fail;
27016 {
27017 PyThreadState* __tstate = wxPyBeginAllowThreads();
27018 result = ((wxWindow const *)arg1)->GetMaxSize();
27019
27020 wxPyEndAllowThreads(__tstate);
27021 if (PyErr_Occurred()) SWIG_fail;
27022 }
27023 {
27024 wxSize * resultptr;
27025 resultptr = new wxSize((wxSize &)(result));
27026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27027 }
27028 return resultobj;
27029 fail:
27030 return NULL;
27031 }
27032
27033
27034 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27035 PyObject *resultobj;
27036 wxWindow *arg1 = (wxWindow *) 0 ;
27037 wxSize result;
27038 PyObject * obj0 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27045 if (SWIG_arg_fail(1)) SWIG_fail;
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 result = ((wxWindow const *)arg1)->GetMinSize();
27049
27050 wxPyEndAllowThreads(__tstate);
27051 if (PyErr_Occurred()) SWIG_fail;
27052 }
27053 {
27054 wxSize * resultptr;
27055 resultptr = new wxSize((wxSize &)(result));
27056 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27057 }
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27065 PyObject *resultobj;
27066 wxWindow *arg1 = (wxWindow *) 0 ;
27067 wxSize *arg2 = 0 ;
27068 wxSize temp2 ;
27069 PyObject * obj0 = 0 ;
27070 PyObject * obj1 = 0 ;
27071 char *kwnames[] = {
27072 (char *) "self",(char *) "minSize", NULL
27073 };
27074
27075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27077 if (SWIG_arg_fail(1)) SWIG_fail;
27078 {
27079 arg2 = &temp2;
27080 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27081 }
27082 {
27083 PyThreadState* __tstate = wxPyBeginAllowThreads();
27084 (arg1)->SetMinSize((wxSize const &)*arg2);
27085
27086 wxPyEndAllowThreads(__tstate);
27087 if (PyErr_Occurred()) SWIG_fail;
27088 }
27089 Py_INCREF(Py_None); resultobj = Py_None;
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj;
27098 wxWindow *arg1 = (wxWindow *) 0 ;
27099 wxSize *arg2 = 0 ;
27100 wxSize temp2 ;
27101 PyObject * obj0 = 0 ;
27102 PyObject * obj1 = 0 ;
27103 char *kwnames[] = {
27104 (char *) "self",(char *) "maxSize", NULL
27105 };
27106
27107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27109 if (SWIG_arg_fail(1)) SWIG_fail;
27110 {
27111 arg2 = &temp2;
27112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27113 }
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 (arg1)->SetMaxSize((wxSize const &)*arg2);
27117
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 Py_INCREF(Py_None); resultobj = Py_None;
27122 return resultobj;
27123 fail:
27124 return NULL;
27125 }
27126
27127
27128 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27129 PyObject *resultobj;
27130 wxWindow *arg1 = (wxWindow *) 0 ;
27131 int result;
27132 PyObject * obj0 = 0 ;
27133 char *kwnames[] = {
27134 (char *) "self", NULL
27135 };
27136
27137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27139 if (SWIG_arg_fail(1)) SWIG_fail;
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27143
27144 wxPyEndAllowThreads(__tstate);
27145 if (PyErr_Occurred()) SWIG_fail;
27146 }
27147 {
27148 resultobj = SWIG_From_int((int)(result));
27149 }
27150 return resultobj;
27151 fail:
27152 return NULL;
27153 }
27154
27155
27156 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27157 PyObject *resultobj;
27158 wxWindow *arg1 = (wxWindow *) 0 ;
27159 int result;
27160 PyObject * obj0 = 0 ;
27161 char *kwnames[] = {
27162 (char *) "self", NULL
27163 };
27164
27165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27167 if (SWIG_arg_fail(1)) SWIG_fail;
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27171
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 {
27176 resultobj = SWIG_From_int((int)(result));
27177 }
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj;
27186 wxWindow *arg1 = (wxWindow *) 0 ;
27187 int result;
27188 PyObject * obj0 = 0 ;
27189 char *kwnames[] = {
27190 (char *) "self", NULL
27191 };
27192
27193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27195 if (SWIG_arg_fail(1)) SWIG_fail;
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27199
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 {
27204 resultobj = SWIG_From_int((int)(result));
27205 }
27206 return resultobj;
27207 fail:
27208 return NULL;
27209 }
27210
27211
27212 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27213 PyObject *resultobj;
27214 wxWindow *arg1 = (wxWindow *) 0 ;
27215 int result;
27216 PyObject * obj0 = 0 ;
27217 char *kwnames[] = {
27218 (char *) "self", NULL
27219 };
27220
27221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27223 if (SWIG_arg_fail(1)) SWIG_fail;
27224 {
27225 PyThreadState* __tstate = wxPyBeginAllowThreads();
27226 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27227
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 {
27232 resultobj = SWIG_From_int((int)(result));
27233 }
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj;
27242 wxWindow *arg1 = (wxWindow *) 0 ;
27243 wxSize *arg2 = 0 ;
27244 wxSize temp2 ;
27245 PyObject * obj0 = 0 ;
27246 PyObject * obj1 = 0 ;
27247 char *kwnames[] = {
27248 (char *) "self",(char *) "size", NULL
27249 };
27250
27251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27253 if (SWIG_arg_fail(1)) SWIG_fail;
27254 {
27255 arg2 = &temp2;
27256 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27257 }
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27261
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 Py_INCREF(Py_None); resultobj = Py_None;
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27273 PyObject *resultobj;
27274 wxWindow *arg1 = (wxWindow *) 0 ;
27275 int arg2 ;
27276 int arg3 ;
27277 PyObject * obj0 = 0 ;
27278 PyObject * obj1 = 0 ;
27279 PyObject * obj2 = 0 ;
27280 char *kwnames[] = {
27281 (char *) "self",(char *) "w",(char *) "h", NULL
27282 };
27283
27284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27286 if (SWIG_arg_fail(1)) SWIG_fail;
27287 {
27288 arg2 = (int)(SWIG_As_int(obj1));
27289 if (SWIG_arg_fail(2)) SWIG_fail;
27290 }
27291 {
27292 arg3 = (int)(SWIG_As_int(obj2));
27293 if (SWIG_arg_fail(3)) SWIG_fail;
27294 }
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 (arg1)->SetVirtualSize(arg2,arg3);
27298
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 Py_INCREF(Py_None); resultobj = Py_None;
27303 return resultobj;
27304 fail:
27305 return NULL;
27306 }
27307
27308
27309 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27310 PyObject *resultobj;
27311 wxWindow *arg1 = (wxWindow *) 0 ;
27312 wxSize result;
27313 PyObject * obj0 = 0 ;
27314 char *kwnames[] = {
27315 (char *) "self", NULL
27316 };
27317
27318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27320 if (SWIG_arg_fail(1)) SWIG_fail;
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 result = ((wxWindow const *)arg1)->GetVirtualSize();
27324
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 {
27329 wxSize * resultptr;
27330 resultptr = new wxSize((wxSize &)(result));
27331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27332 }
27333 return resultobj;
27334 fail:
27335 return NULL;
27336 }
27337
27338
27339 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27340 PyObject *resultobj;
27341 wxWindow *arg1 = (wxWindow *) 0 ;
27342 int *arg2 = (int *) 0 ;
27343 int *arg3 = (int *) 0 ;
27344 int temp2 ;
27345 int res2 = 0 ;
27346 int temp3 ;
27347 int res3 = 0 ;
27348 PyObject * obj0 = 0 ;
27349 char *kwnames[] = {
27350 (char *) "self", NULL
27351 };
27352
27353 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27354 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27357 if (SWIG_arg_fail(1)) SWIG_fail;
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27361
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 Py_INCREF(Py_None); resultobj = Py_None;
27366 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27367 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27368 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27369 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27370 return resultobj;
27371 fail:
27372 return NULL;
27373 }
27374
27375
27376 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27377 PyObject *resultobj;
27378 wxWindow *arg1 = (wxWindow *) 0 ;
27379 wxSize result;
27380 PyObject * obj0 = 0 ;
27381 char *kwnames[] = {
27382 (char *) "self", NULL
27383 };
27384
27385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27387 if (SWIG_arg_fail(1)) SWIG_fail;
27388 {
27389 PyThreadState* __tstate = wxPyBeginAllowThreads();
27390 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27391
27392 wxPyEndAllowThreads(__tstate);
27393 if (PyErr_Occurred()) SWIG_fail;
27394 }
27395 {
27396 wxSize * resultptr;
27397 resultptr = new wxSize((wxSize &)(result));
27398 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27399 }
27400 return resultobj;
27401 fail:
27402 return NULL;
27403 }
27404
27405
27406 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27407 PyObject *resultobj;
27408 wxWindow *arg1 = (wxWindow *) 0 ;
27409 bool arg2 = (bool) true ;
27410 bool result;
27411 PyObject * obj0 = 0 ;
27412 PyObject * obj1 = 0 ;
27413 char *kwnames[] = {
27414 (char *) "self",(char *) "show", NULL
27415 };
27416
27417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27419 if (SWIG_arg_fail(1)) SWIG_fail;
27420 if (obj1) {
27421 {
27422 arg2 = (bool)(SWIG_As_bool(obj1));
27423 if (SWIG_arg_fail(2)) SWIG_fail;
27424 }
27425 }
27426 {
27427 PyThreadState* __tstate = wxPyBeginAllowThreads();
27428 result = (bool)(arg1)->Show(arg2);
27429
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 {
27434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27435 }
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27443 PyObject *resultobj;
27444 wxWindow *arg1 = (wxWindow *) 0 ;
27445 bool result;
27446 PyObject * obj0 = 0 ;
27447 char *kwnames[] = {
27448 (char *) "self", NULL
27449 };
27450
27451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27453 if (SWIG_arg_fail(1)) SWIG_fail;
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 result = (bool)(arg1)->Hide();
27457
27458 wxPyEndAllowThreads(__tstate);
27459 if (PyErr_Occurred()) SWIG_fail;
27460 }
27461 {
27462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27463 }
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27471 PyObject *resultobj;
27472 wxWindow *arg1 = (wxWindow *) 0 ;
27473 bool arg2 = (bool) true ;
27474 bool result;
27475 PyObject * obj0 = 0 ;
27476 PyObject * obj1 = 0 ;
27477 char *kwnames[] = {
27478 (char *) "self",(char *) "enable", NULL
27479 };
27480
27481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27483 if (SWIG_arg_fail(1)) SWIG_fail;
27484 if (obj1) {
27485 {
27486 arg2 = (bool)(SWIG_As_bool(obj1));
27487 if (SWIG_arg_fail(2)) SWIG_fail;
27488 }
27489 }
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 result = (bool)(arg1)->Enable(arg2);
27493
27494 wxPyEndAllowThreads(__tstate);
27495 if (PyErr_Occurred()) SWIG_fail;
27496 }
27497 {
27498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27499 }
27500 return resultobj;
27501 fail:
27502 return NULL;
27503 }
27504
27505
27506 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27507 PyObject *resultobj;
27508 wxWindow *arg1 = (wxWindow *) 0 ;
27509 bool result;
27510 PyObject * obj0 = 0 ;
27511 char *kwnames[] = {
27512 (char *) "self", NULL
27513 };
27514
27515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27517 if (SWIG_arg_fail(1)) SWIG_fail;
27518 {
27519 PyThreadState* __tstate = wxPyBeginAllowThreads();
27520 result = (bool)(arg1)->Disable();
27521
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 {
27526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27527 }
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27535 PyObject *resultobj;
27536 wxWindow *arg1 = (wxWindow *) 0 ;
27537 bool result;
27538 PyObject * obj0 = 0 ;
27539 char *kwnames[] = {
27540 (char *) "self", NULL
27541 };
27542
27543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27545 if (SWIG_arg_fail(1)) SWIG_fail;
27546 {
27547 PyThreadState* __tstate = wxPyBeginAllowThreads();
27548 result = (bool)((wxWindow const *)arg1)->IsShown();
27549
27550 wxPyEndAllowThreads(__tstate);
27551 if (PyErr_Occurred()) SWIG_fail;
27552 }
27553 {
27554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27555 }
27556 return resultobj;
27557 fail:
27558 return NULL;
27559 }
27560
27561
27562 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27563 PyObject *resultobj;
27564 wxWindow *arg1 = (wxWindow *) 0 ;
27565 bool result;
27566 PyObject * obj0 = 0 ;
27567 char *kwnames[] = {
27568 (char *) "self", NULL
27569 };
27570
27571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27573 if (SWIG_arg_fail(1)) SWIG_fail;
27574 {
27575 PyThreadState* __tstate = wxPyBeginAllowThreads();
27576 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27577
27578 wxPyEndAllowThreads(__tstate);
27579 if (PyErr_Occurred()) SWIG_fail;
27580 }
27581 {
27582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27583 }
27584 return resultobj;
27585 fail:
27586 return NULL;
27587 }
27588
27589
27590 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27591 PyObject *resultobj;
27592 wxWindow *arg1 = (wxWindow *) 0 ;
27593 long arg2 ;
27594 PyObject * obj0 = 0 ;
27595 PyObject * obj1 = 0 ;
27596 char *kwnames[] = {
27597 (char *) "self",(char *) "style", NULL
27598 };
27599
27600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27602 if (SWIG_arg_fail(1)) SWIG_fail;
27603 {
27604 arg2 = (long)(SWIG_As_long(obj1));
27605 if (SWIG_arg_fail(2)) SWIG_fail;
27606 }
27607 {
27608 PyThreadState* __tstate = wxPyBeginAllowThreads();
27609 (arg1)->SetWindowStyleFlag(arg2);
27610
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 Py_INCREF(Py_None); resultobj = Py_None;
27615 return resultobj;
27616 fail:
27617 return NULL;
27618 }
27619
27620
27621 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27622 PyObject *resultobj;
27623 wxWindow *arg1 = (wxWindow *) 0 ;
27624 long result;
27625 PyObject * obj0 = 0 ;
27626 char *kwnames[] = {
27627 (char *) "self", NULL
27628 };
27629
27630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27632 if (SWIG_arg_fail(1)) SWIG_fail;
27633 {
27634 PyThreadState* __tstate = wxPyBeginAllowThreads();
27635 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27636
27637 wxPyEndAllowThreads(__tstate);
27638 if (PyErr_Occurred()) SWIG_fail;
27639 }
27640 {
27641 resultobj = SWIG_From_long((long)(result));
27642 }
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27650 PyObject *resultobj;
27651 wxWindow *arg1 = (wxWindow *) 0 ;
27652 int arg2 ;
27653 bool result;
27654 PyObject * obj0 = 0 ;
27655 PyObject * obj1 = 0 ;
27656 char *kwnames[] = {
27657 (char *) "self",(char *) "flag", NULL
27658 };
27659
27660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27662 if (SWIG_arg_fail(1)) SWIG_fail;
27663 {
27664 arg2 = (int)(SWIG_As_int(obj1));
27665 if (SWIG_arg_fail(2)) SWIG_fail;
27666 }
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27670
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 {
27675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27676 }
27677 return resultobj;
27678 fail:
27679 return NULL;
27680 }
27681
27682
27683 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27684 PyObject *resultobj;
27685 wxWindow *arg1 = (wxWindow *) 0 ;
27686 bool result;
27687 PyObject * obj0 = 0 ;
27688 char *kwnames[] = {
27689 (char *) "self", NULL
27690 };
27691
27692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27694 if (SWIG_arg_fail(1)) SWIG_fail;
27695 {
27696 PyThreadState* __tstate = wxPyBeginAllowThreads();
27697 result = (bool)((wxWindow const *)arg1)->IsRetained();
27698
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 {
27703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27704 }
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27712 PyObject *resultobj;
27713 wxWindow *arg1 = (wxWindow *) 0 ;
27714 long arg2 ;
27715 PyObject * obj0 = 0 ;
27716 PyObject * obj1 = 0 ;
27717 char *kwnames[] = {
27718 (char *) "self",(char *) "exStyle", NULL
27719 };
27720
27721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27723 if (SWIG_arg_fail(1)) SWIG_fail;
27724 {
27725 arg2 = (long)(SWIG_As_long(obj1));
27726 if (SWIG_arg_fail(2)) SWIG_fail;
27727 }
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 (arg1)->SetExtraStyle(arg2);
27731
27732 wxPyEndAllowThreads(__tstate);
27733 if (PyErr_Occurred()) SWIG_fail;
27734 }
27735 Py_INCREF(Py_None); resultobj = Py_None;
27736 return resultobj;
27737 fail:
27738 return NULL;
27739 }
27740
27741
27742 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27743 PyObject *resultobj;
27744 wxWindow *arg1 = (wxWindow *) 0 ;
27745 long result;
27746 PyObject * obj0 = 0 ;
27747 char *kwnames[] = {
27748 (char *) "self", NULL
27749 };
27750
27751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27753 if (SWIG_arg_fail(1)) SWIG_fail;
27754 {
27755 PyThreadState* __tstate = wxPyBeginAllowThreads();
27756 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27757
27758 wxPyEndAllowThreads(__tstate);
27759 if (PyErr_Occurred()) SWIG_fail;
27760 }
27761 {
27762 resultobj = SWIG_From_long((long)(result));
27763 }
27764 return resultobj;
27765 fail:
27766 return NULL;
27767 }
27768
27769
27770 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27771 PyObject *resultobj;
27772 wxWindow *arg1 = (wxWindow *) 0 ;
27773 bool arg2 = (bool) true ;
27774 PyObject * obj0 = 0 ;
27775 PyObject * obj1 = 0 ;
27776 char *kwnames[] = {
27777 (char *) "self",(char *) "modal", NULL
27778 };
27779
27780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27782 if (SWIG_arg_fail(1)) SWIG_fail;
27783 if (obj1) {
27784 {
27785 arg2 = (bool)(SWIG_As_bool(obj1));
27786 if (SWIG_arg_fail(2)) SWIG_fail;
27787 }
27788 }
27789 {
27790 PyThreadState* __tstate = wxPyBeginAllowThreads();
27791 (arg1)->MakeModal(arg2);
27792
27793 wxPyEndAllowThreads(__tstate);
27794 if (PyErr_Occurred()) SWIG_fail;
27795 }
27796 Py_INCREF(Py_None); resultobj = Py_None;
27797 return resultobj;
27798 fail:
27799 return NULL;
27800 }
27801
27802
27803 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27804 PyObject *resultobj;
27805 wxWindow *arg1 = (wxWindow *) 0 ;
27806 bool arg2 ;
27807 PyObject * obj0 = 0 ;
27808 PyObject * obj1 = 0 ;
27809 char *kwnames[] = {
27810 (char *) "self",(char *) "enableTheme", NULL
27811 };
27812
27813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27815 if (SWIG_arg_fail(1)) SWIG_fail;
27816 {
27817 arg2 = (bool)(SWIG_As_bool(obj1));
27818 if (SWIG_arg_fail(2)) SWIG_fail;
27819 }
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 (arg1)->SetThemeEnabled(arg2);
27823
27824 wxPyEndAllowThreads(__tstate);
27825 if (PyErr_Occurred()) SWIG_fail;
27826 }
27827 Py_INCREF(Py_None); resultobj = Py_None;
27828 return resultobj;
27829 fail:
27830 return NULL;
27831 }
27832
27833
27834 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27835 PyObject *resultobj;
27836 wxWindow *arg1 = (wxWindow *) 0 ;
27837 bool result;
27838 PyObject * obj0 = 0 ;
27839 char *kwnames[] = {
27840 (char *) "self", NULL
27841 };
27842
27843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27845 if (SWIG_arg_fail(1)) SWIG_fail;
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27849
27850 wxPyEndAllowThreads(__tstate);
27851 if (PyErr_Occurred()) SWIG_fail;
27852 }
27853 {
27854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27855 }
27856 return resultobj;
27857 fail:
27858 return NULL;
27859 }
27860
27861
27862 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27863 PyObject *resultobj;
27864 wxWindow *arg1 = (wxWindow *) 0 ;
27865 PyObject * obj0 = 0 ;
27866 char *kwnames[] = {
27867 (char *) "self", NULL
27868 };
27869
27870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27872 if (SWIG_arg_fail(1)) SWIG_fail;
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 (arg1)->SetFocus();
27876
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 Py_INCREF(Py_None); resultobj = Py_None;
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27888 PyObject *resultobj;
27889 wxWindow *arg1 = (wxWindow *) 0 ;
27890 PyObject * obj0 = 0 ;
27891 char *kwnames[] = {
27892 (char *) "self", NULL
27893 };
27894
27895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27897 if (SWIG_arg_fail(1)) SWIG_fail;
27898 {
27899 PyThreadState* __tstate = wxPyBeginAllowThreads();
27900 (arg1)->SetFocusFromKbd();
27901
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 Py_INCREF(Py_None); resultobj = Py_None;
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj;
27914 wxWindow *result;
27915 char *kwnames[] = {
27916 NULL
27917 };
27918
27919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27920 {
27921 if (!wxPyCheckForApp()) SWIG_fail;
27922 PyThreadState* __tstate = wxPyBeginAllowThreads();
27923 result = (wxWindow *)wxWindow::FindFocus();
27924
27925 wxPyEndAllowThreads(__tstate);
27926 if (PyErr_Occurred()) SWIG_fail;
27927 }
27928 {
27929 resultobj = wxPyMake_wxObject(result, 0);
27930 }
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27938 PyObject *resultobj;
27939 wxWindow *arg1 = (wxWindow *) 0 ;
27940 bool result;
27941 PyObject * obj0 = 0 ;
27942 char *kwnames[] = {
27943 (char *) "self", NULL
27944 };
27945
27946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27948 if (SWIG_arg_fail(1)) SWIG_fail;
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27952
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 {
27957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27958 }
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxWindow *arg1 = (wxWindow *) 0 ;
27968 bool result;
27969 PyObject * obj0 = 0 ;
27970 char *kwnames[] = {
27971 (char *) "self", NULL
27972 };
27973
27974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27976 if (SWIG_arg_fail(1)) SWIG_fail;
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27980
27981 wxPyEndAllowThreads(__tstate);
27982 if (PyErr_Occurred()) SWIG_fail;
27983 }
27984 {
27985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27986 }
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27994 PyObject *resultobj;
27995 wxWindow *arg1 = (wxWindow *) 0 ;
27996 wxWindow *result;
27997 PyObject * obj0 = 0 ;
27998 char *kwnames[] = {
27999 (char *) "self", NULL
28000 };
28001
28002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28004 if (SWIG_arg_fail(1)) SWIG_fail;
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28008
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 {
28013 resultobj = wxPyMake_wxObject(result, 0);
28014 }
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj;
28023 wxWindow *arg1 = (wxWindow *) 0 ;
28024 wxWindow *arg2 = (wxWindow *) 0 ;
28025 wxWindow *result;
28026 PyObject * obj0 = 0 ;
28027 PyObject * obj1 = 0 ;
28028 char *kwnames[] = {
28029 (char *) "self",(char *) "child", NULL
28030 };
28031
28032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28034 if (SWIG_arg_fail(1)) SWIG_fail;
28035 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28036 if (SWIG_arg_fail(2)) SWIG_fail;
28037 {
28038 PyThreadState* __tstate = wxPyBeginAllowThreads();
28039 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28040
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 {
28045 resultobj = wxPyMake_wxObject(result, 0);
28046 }
28047 return resultobj;
28048 fail:
28049 return NULL;
28050 }
28051
28052
28053 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28054 PyObject *resultobj;
28055 wxWindow *arg1 = (wxWindow *) 0 ;
28056 wxWindow *arg2 = (wxWindow *) 0 ;
28057 PyObject * obj0 = 0 ;
28058 PyObject * obj1 = 0 ;
28059 char *kwnames[] = {
28060 (char *) "self",(char *) "win", NULL
28061 };
28062
28063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28065 if (SWIG_arg_fail(1)) SWIG_fail;
28066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28067 if (SWIG_arg_fail(2)) SWIG_fail;
28068 {
28069 PyThreadState* __tstate = wxPyBeginAllowThreads();
28070 (arg1)->SetTmpDefaultItem(arg2);
28071
28072 wxPyEndAllowThreads(__tstate);
28073 if (PyErr_Occurred()) SWIG_fail;
28074 }
28075 Py_INCREF(Py_None); resultobj = Py_None;
28076 return resultobj;
28077 fail:
28078 return NULL;
28079 }
28080
28081
28082 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28083 PyObject *resultobj;
28084 wxWindow *arg1 = (wxWindow *) 0 ;
28085 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28086 bool result;
28087 PyObject * obj0 = 0 ;
28088 PyObject * obj1 = 0 ;
28089 char *kwnames[] = {
28090 (char *) "self",(char *) "flags", NULL
28091 };
28092
28093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28095 if (SWIG_arg_fail(1)) SWIG_fail;
28096 if (obj1) {
28097 {
28098 arg2 = (int)(SWIG_As_int(obj1));
28099 if (SWIG_arg_fail(2)) SWIG_fail;
28100 }
28101 }
28102 {
28103 PyThreadState* __tstate = wxPyBeginAllowThreads();
28104 result = (bool)(arg1)->Navigate(arg2);
28105
28106 wxPyEndAllowThreads(__tstate);
28107 if (PyErr_Occurred()) SWIG_fail;
28108 }
28109 {
28110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28111 }
28112 return resultobj;
28113 fail:
28114 return NULL;
28115 }
28116
28117
28118 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28119 PyObject *resultobj;
28120 wxWindow *arg1 = (wxWindow *) 0 ;
28121 wxWindow *arg2 = (wxWindow *) 0 ;
28122 PyObject * obj0 = 0 ;
28123 PyObject * obj1 = 0 ;
28124 char *kwnames[] = {
28125 (char *) "self",(char *) "win", NULL
28126 };
28127
28128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28130 if (SWIG_arg_fail(1)) SWIG_fail;
28131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28132 if (SWIG_arg_fail(2)) SWIG_fail;
28133 {
28134 PyThreadState* __tstate = wxPyBeginAllowThreads();
28135 (arg1)->MoveAfterInTabOrder(arg2);
28136
28137 wxPyEndAllowThreads(__tstate);
28138 if (PyErr_Occurred()) SWIG_fail;
28139 }
28140 Py_INCREF(Py_None); resultobj = Py_None;
28141 return resultobj;
28142 fail:
28143 return NULL;
28144 }
28145
28146
28147 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28148 PyObject *resultobj;
28149 wxWindow *arg1 = (wxWindow *) 0 ;
28150 wxWindow *arg2 = (wxWindow *) 0 ;
28151 PyObject * obj0 = 0 ;
28152 PyObject * obj1 = 0 ;
28153 char *kwnames[] = {
28154 (char *) "self",(char *) "win", NULL
28155 };
28156
28157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28159 if (SWIG_arg_fail(1)) SWIG_fail;
28160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28161 if (SWIG_arg_fail(2)) SWIG_fail;
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 (arg1)->MoveBeforeInTabOrder(arg2);
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 Py_INCREF(Py_None); resultobj = Py_None;
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj;
28178 wxWindow *arg1 = (wxWindow *) 0 ;
28179 PyObject *result;
28180 PyObject * obj0 = 0 ;
28181 char *kwnames[] = {
28182 (char *) "self", NULL
28183 };
28184
28185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28187 if (SWIG_arg_fail(1)) SWIG_fail;
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 result = (PyObject *)wxWindow_GetChildren(arg1);
28191
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 resultobj = result;
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj;
28204 wxWindow *arg1 = (wxWindow *) 0 ;
28205 wxWindow *result;
28206 PyObject * obj0 = 0 ;
28207 char *kwnames[] = {
28208 (char *) "self", NULL
28209 };
28210
28211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28213 if (SWIG_arg_fail(1)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28217
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 {
28222 resultobj = wxPyMake_wxObject(result, 0);
28223 }
28224 return resultobj;
28225 fail:
28226 return NULL;
28227 }
28228
28229
28230 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28231 PyObject *resultobj;
28232 wxWindow *arg1 = (wxWindow *) 0 ;
28233 wxWindow *result;
28234 PyObject * obj0 = 0 ;
28235 char *kwnames[] = {
28236 (char *) "self", NULL
28237 };
28238
28239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28241 if (SWIG_arg_fail(1)) SWIG_fail;
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28245
28246 wxPyEndAllowThreads(__tstate);
28247 if (PyErr_Occurred()) SWIG_fail;
28248 }
28249 {
28250 resultobj = wxPyMake_wxObject(result, 0);
28251 }
28252 return resultobj;
28253 fail:
28254 return NULL;
28255 }
28256
28257
28258 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28259 PyObject *resultobj;
28260 wxWindow *arg1 = (wxWindow *) 0 ;
28261 bool result;
28262 PyObject * obj0 = 0 ;
28263 char *kwnames[] = {
28264 (char *) "self", NULL
28265 };
28266
28267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28269 if (SWIG_arg_fail(1)) SWIG_fail;
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28273
28274 wxPyEndAllowThreads(__tstate);
28275 if (PyErr_Occurred()) SWIG_fail;
28276 }
28277 {
28278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28279 }
28280 return resultobj;
28281 fail:
28282 return NULL;
28283 }
28284
28285
28286 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28287 PyObject *resultobj;
28288 wxWindow *arg1 = (wxWindow *) 0 ;
28289 wxWindow *arg2 = (wxWindow *) 0 ;
28290 bool result;
28291 PyObject * obj0 = 0 ;
28292 PyObject * obj1 = 0 ;
28293 char *kwnames[] = {
28294 (char *) "self",(char *) "newParent", NULL
28295 };
28296
28297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28299 if (SWIG_arg_fail(1)) SWIG_fail;
28300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28301 if (SWIG_arg_fail(2)) SWIG_fail;
28302 {
28303 PyThreadState* __tstate = wxPyBeginAllowThreads();
28304 result = (bool)(arg1)->Reparent(arg2);
28305
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 {
28310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28311 }
28312 return resultobj;
28313 fail:
28314 return NULL;
28315 }
28316
28317
28318 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28319 PyObject *resultobj;
28320 wxWindow *arg1 = (wxWindow *) 0 ;
28321 wxWindow *arg2 = (wxWindow *) 0 ;
28322 PyObject * obj0 = 0 ;
28323 PyObject * obj1 = 0 ;
28324 char *kwnames[] = {
28325 (char *) "self",(char *) "child", NULL
28326 };
28327
28328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28330 if (SWIG_arg_fail(1)) SWIG_fail;
28331 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28332 if (SWIG_arg_fail(2)) SWIG_fail;
28333 {
28334 PyThreadState* __tstate = wxPyBeginAllowThreads();
28335 (arg1)->AddChild(arg2);
28336
28337 wxPyEndAllowThreads(__tstate);
28338 if (PyErr_Occurred()) SWIG_fail;
28339 }
28340 Py_INCREF(Py_None); resultobj = Py_None;
28341 return resultobj;
28342 fail:
28343 return NULL;
28344 }
28345
28346
28347 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28348 PyObject *resultobj;
28349 wxWindow *arg1 = (wxWindow *) 0 ;
28350 wxWindow *arg2 = (wxWindow *) 0 ;
28351 PyObject * obj0 = 0 ;
28352 PyObject * obj1 = 0 ;
28353 char *kwnames[] = {
28354 (char *) "self",(char *) "child", NULL
28355 };
28356
28357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28359 if (SWIG_arg_fail(1)) SWIG_fail;
28360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28361 if (SWIG_arg_fail(2)) SWIG_fail;
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 (arg1)->RemoveChild(arg2);
28365
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 Py_INCREF(Py_None); resultobj = Py_None;
28370 return resultobj;
28371 fail:
28372 return NULL;
28373 }
28374
28375
28376 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28377 PyObject *resultobj;
28378 wxWindow *arg1 = (wxWindow *) 0 ;
28379 long arg2 ;
28380 wxWindow *result;
28381 PyObject * obj0 = 0 ;
28382 PyObject * obj1 = 0 ;
28383 char *kwnames[] = {
28384 (char *) "self",(char *) "winid", NULL
28385 };
28386
28387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28389 if (SWIG_arg_fail(1)) SWIG_fail;
28390 {
28391 arg2 = (long)(SWIG_As_long(obj1));
28392 if (SWIG_arg_fail(2)) SWIG_fail;
28393 }
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (wxWindow *)(arg1)->FindWindow(arg2);
28397
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 {
28402 resultobj = wxPyMake_wxObject(result, 0);
28403 }
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28411 PyObject *resultobj;
28412 wxWindow *arg1 = (wxWindow *) 0 ;
28413 wxString *arg2 = 0 ;
28414 wxWindow *result;
28415 bool temp2 = false ;
28416 PyObject * obj0 = 0 ;
28417 PyObject * obj1 = 0 ;
28418 char *kwnames[] = {
28419 (char *) "self",(char *) "name", NULL
28420 };
28421
28422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28424 if (SWIG_arg_fail(1)) SWIG_fail;
28425 {
28426 arg2 = wxString_in_helper(obj1);
28427 if (arg2 == NULL) SWIG_fail;
28428 temp2 = true;
28429 }
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 {
28438 resultobj = wxPyMake_wxObject(result, 0);
28439 }
28440 {
28441 if (temp2)
28442 delete arg2;
28443 }
28444 return resultobj;
28445 fail:
28446 {
28447 if (temp2)
28448 delete arg2;
28449 }
28450 return NULL;
28451 }
28452
28453
28454 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28455 PyObject *resultobj;
28456 wxWindow *arg1 = (wxWindow *) 0 ;
28457 wxEvtHandler *result;
28458 PyObject * obj0 = 0 ;
28459 char *kwnames[] = {
28460 (char *) "self", NULL
28461 };
28462
28463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28465 if (SWIG_arg_fail(1)) SWIG_fail;
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28469
28470 wxPyEndAllowThreads(__tstate);
28471 if (PyErr_Occurred()) SWIG_fail;
28472 }
28473 {
28474 resultobj = wxPyMake_wxObject(result, 0);
28475 }
28476 return resultobj;
28477 fail:
28478 return NULL;
28479 }
28480
28481
28482 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28483 PyObject *resultobj;
28484 wxWindow *arg1 = (wxWindow *) 0 ;
28485 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28486 PyObject * obj0 = 0 ;
28487 PyObject * obj1 = 0 ;
28488 char *kwnames[] = {
28489 (char *) "self",(char *) "handler", NULL
28490 };
28491
28492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28494 if (SWIG_arg_fail(1)) SWIG_fail;
28495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28496 if (SWIG_arg_fail(2)) SWIG_fail;
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 (arg1)->SetEventHandler(arg2);
28500
28501 wxPyEndAllowThreads(__tstate);
28502 if (PyErr_Occurred()) SWIG_fail;
28503 }
28504 Py_INCREF(Py_None); resultobj = Py_None;
28505 return resultobj;
28506 fail:
28507 return NULL;
28508 }
28509
28510
28511 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28512 PyObject *resultobj;
28513 wxWindow *arg1 = (wxWindow *) 0 ;
28514 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28515 PyObject * obj0 = 0 ;
28516 PyObject * obj1 = 0 ;
28517 char *kwnames[] = {
28518 (char *) "self",(char *) "handler", NULL
28519 };
28520
28521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28523 if (SWIG_arg_fail(1)) SWIG_fail;
28524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28525 if (SWIG_arg_fail(2)) SWIG_fail;
28526 {
28527 PyThreadState* __tstate = wxPyBeginAllowThreads();
28528 (arg1)->PushEventHandler(arg2);
28529
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 Py_INCREF(Py_None); resultobj = Py_None;
28534 return resultobj;
28535 fail:
28536 return NULL;
28537 }
28538
28539
28540 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28541 PyObject *resultobj;
28542 wxWindow *arg1 = (wxWindow *) 0 ;
28543 bool arg2 = (bool) false ;
28544 wxEvtHandler *result;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 char *kwnames[] = {
28548 (char *) "self",(char *) "deleteHandler", NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28553 if (SWIG_arg_fail(1)) SWIG_fail;
28554 if (obj1) {
28555 {
28556 arg2 = (bool)(SWIG_As_bool(obj1));
28557 if (SWIG_arg_fail(2)) SWIG_fail;
28558 }
28559 }
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28563
28564 wxPyEndAllowThreads(__tstate);
28565 if (PyErr_Occurred()) SWIG_fail;
28566 }
28567 {
28568 resultobj = wxPyMake_wxObject(result, 0);
28569 }
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28577 PyObject *resultobj;
28578 wxWindow *arg1 = (wxWindow *) 0 ;
28579 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28580 bool result;
28581 PyObject * obj0 = 0 ;
28582 PyObject * obj1 = 0 ;
28583 char *kwnames[] = {
28584 (char *) "self",(char *) "handler", NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28589 if (SWIG_arg_fail(1)) SWIG_fail;
28590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28591 if (SWIG_arg_fail(2)) SWIG_fail;
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 result = (bool)(arg1)->RemoveEventHandler(arg2);
28595
28596 wxPyEndAllowThreads(__tstate);
28597 if (PyErr_Occurred()) SWIG_fail;
28598 }
28599 {
28600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28601 }
28602 return resultobj;
28603 fail:
28604 return NULL;
28605 }
28606
28607
28608 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28609 PyObject *resultobj;
28610 wxWindow *arg1 = (wxWindow *) 0 ;
28611 wxValidator *arg2 = 0 ;
28612 PyObject * obj0 = 0 ;
28613 PyObject * obj1 = 0 ;
28614 char *kwnames[] = {
28615 (char *) "self",(char *) "validator", NULL
28616 };
28617
28618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28620 if (SWIG_arg_fail(1)) SWIG_fail;
28621 {
28622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28623 if (SWIG_arg_fail(2)) SWIG_fail;
28624 if (arg2 == NULL) {
28625 SWIG_null_ref("wxValidator");
28626 }
28627 if (SWIG_arg_fail(2)) SWIG_fail;
28628 }
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 (arg1)->SetValidator((wxValidator const &)*arg2);
28632
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 Py_INCREF(Py_None); resultobj = Py_None;
28637 return resultobj;
28638 fail:
28639 return NULL;
28640 }
28641
28642
28643 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28644 PyObject *resultobj;
28645 wxWindow *arg1 = (wxWindow *) 0 ;
28646 wxValidator *result;
28647 PyObject * obj0 = 0 ;
28648 char *kwnames[] = {
28649 (char *) "self", NULL
28650 };
28651
28652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(1)) SWIG_fail;
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 result = (wxValidator *)(arg1)->GetValidator();
28658
28659 wxPyEndAllowThreads(__tstate);
28660 if (PyErr_Occurred()) SWIG_fail;
28661 }
28662 {
28663 resultobj = wxPyMake_wxObject(result, 0);
28664 }
28665 return resultobj;
28666 fail:
28667 return NULL;
28668 }
28669
28670
28671 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28672 PyObject *resultobj;
28673 wxWindow *arg1 = (wxWindow *) 0 ;
28674 bool result;
28675 PyObject * obj0 = 0 ;
28676 char *kwnames[] = {
28677 (char *) "self", NULL
28678 };
28679
28680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(1)) SWIG_fail;
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 result = (bool)(arg1)->Validate();
28686
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 {
28691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28692 }
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28700 PyObject *resultobj;
28701 wxWindow *arg1 = (wxWindow *) 0 ;
28702 bool result;
28703 PyObject * obj0 = 0 ;
28704 char *kwnames[] = {
28705 (char *) "self", NULL
28706 };
28707
28708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",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 result = (bool)(arg1)->TransferDataToWindow();
28714
28715 wxPyEndAllowThreads(__tstate);
28716 if (PyErr_Occurred()) SWIG_fail;
28717 }
28718 {
28719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28720 }
28721 return resultobj;
28722 fail:
28723 return NULL;
28724 }
28725
28726
28727 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28728 PyObject *resultobj;
28729 wxWindow *arg1 = (wxWindow *) 0 ;
28730 bool result;
28731 PyObject * obj0 = 0 ;
28732 char *kwnames[] = {
28733 (char *) "self", NULL
28734 };
28735
28736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28738 if (SWIG_arg_fail(1)) SWIG_fail;
28739 {
28740 PyThreadState* __tstate = wxPyBeginAllowThreads();
28741 result = (bool)(arg1)->TransferDataFromWindow();
28742
28743 wxPyEndAllowThreads(__tstate);
28744 if (PyErr_Occurred()) SWIG_fail;
28745 }
28746 {
28747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28748 }
28749 return resultobj;
28750 fail:
28751 return NULL;
28752 }
28753
28754
28755 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28756 PyObject *resultobj;
28757 wxWindow *arg1 = (wxWindow *) 0 ;
28758 PyObject * obj0 = 0 ;
28759 char *kwnames[] = {
28760 (char *) "self", NULL
28761 };
28762
28763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28765 if (SWIG_arg_fail(1)) SWIG_fail;
28766 {
28767 PyThreadState* __tstate = wxPyBeginAllowThreads();
28768 (arg1)->InitDialog();
28769
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 Py_INCREF(Py_None); resultobj = Py_None;
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28781 PyObject *resultobj;
28782 wxWindow *arg1 = (wxWindow *) 0 ;
28783 wxAcceleratorTable *arg2 = 0 ;
28784 PyObject * obj0 = 0 ;
28785 PyObject * obj1 = 0 ;
28786 char *kwnames[] = {
28787 (char *) "self",(char *) "accel", NULL
28788 };
28789
28790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) 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 {
28794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28795 if (SWIG_arg_fail(2)) SWIG_fail;
28796 if (arg2 == NULL) {
28797 SWIG_null_ref("wxAcceleratorTable");
28798 }
28799 if (SWIG_arg_fail(2)) SWIG_fail;
28800 }
28801 {
28802 PyThreadState* __tstate = wxPyBeginAllowThreads();
28803 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28804
28805 wxPyEndAllowThreads(__tstate);
28806 if (PyErr_Occurred()) SWIG_fail;
28807 }
28808 Py_INCREF(Py_None); resultobj = Py_None;
28809 return resultobj;
28810 fail:
28811 return NULL;
28812 }
28813
28814
28815 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28816 PyObject *resultobj;
28817 wxWindow *arg1 = (wxWindow *) 0 ;
28818 wxAcceleratorTable *result;
28819 PyObject * obj0 = 0 ;
28820 char *kwnames[] = {
28821 (char *) "self", NULL
28822 };
28823
28824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28826 if (SWIG_arg_fail(1)) SWIG_fail;
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28830
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj;
28843 wxWindow *arg1 = (wxWindow *) 0 ;
28844 int arg2 ;
28845 int arg3 ;
28846 int arg4 ;
28847 bool result;
28848 PyObject * obj0 = 0 ;
28849 PyObject * obj1 = 0 ;
28850 PyObject * obj2 = 0 ;
28851 PyObject * obj3 = 0 ;
28852 char *kwnames[] = {
28853 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28854 };
28855
28856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28858 if (SWIG_arg_fail(1)) SWIG_fail;
28859 {
28860 arg2 = (int)(SWIG_As_int(obj1));
28861 if (SWIG_arg_fail(2)) SWIG_fail;
28862 }
28863 {
28864 arg3 = (int)(SWIG_As_int(obj2));
28865 if (SWIG_arg_fail(3)) SWIG_fail;
28866 }
28867 {
28868 arg4 = (int)(SWIG_As_int(obj3));
28869 if (SWIG_arg_fail(4)) SWIG_fail;
28870 }
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 {
28879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28880 }
28881 return resultobj;
28882 fail:
28883 return NULL;
28884 }
28885
28886
28887 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28888 PyObject *resultobj;
28889 wxWindow *arg1 = (wxWindow *) 0 ;
28890 int arg2 ;
28891 bool result;
28892 PyObject * obj0 = 0 ;
28893 PyObject * obj1 = 0 ;
28894 char *kwnames[] = {
28895 (char *) "self",(char *) "hotkeyId", NULL
28896 };
28897
28898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28900 if (SWIG_arg_fail(1)) SWIG_fail;
28901 {
28902 arg2 = (int)(SWIG_As_int(obj1));
28903 if (SWIG_arg_fail(2)) SWIG_fail;
28904 }
28905 {
28906 PyThreadState* __tstate = wxPyBeginAllowThreads();
28907 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28908
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 {
28913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28914 }
28915 return resultobj;
28916 fail:
28917 return NULL;
28918 }
28919
28920
28921 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28922 PyObject *resultobj;
28923 wxWindow *arg1 = (wxWindow *) 0 ;
28924 wxPoint *arg2 = 0 ;
28925 wxPoint result;
28926 wxPoint temp2 ;
28927 PyObject * obj0 = 0 ;
28928 PyObject * obj1 = 0 ;
28929 char *kwnames[] = {
28930 (char *) "self",(char *) "pt", NULL
28931 };
28932
28933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28935 if (SWIG_arg_fail(1)) SWIG_fail;
28936 {
28937 arg2 = &temp2;
28938 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28939 }
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28943
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 {
28948 wxPoint * resultptr;
28949 resultptr = new wxPoint((wxPoint &)(result));
28950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28951 }
28952 return resultobj;
28953 fail:
28954 return NULL;
28955 }
28956
28957
28958 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28959 PyObject *resultobj;
28960 wxWindow *arg1 = (wxWindow *) 0 ;
28961 wxSize *arg2 = 0 ;
28962 wxSize result;
28963 wxSize temp2 ;
28964 PyObject * obj0 = 0 ;
28965 PyObject * obj1 = 0 ;
28966 char *kwnames[] = {
28967 (char *) "self",(char *) "sz", NULL
28968 };
28969
28970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28972 if (SWIG_arg_fail(1)) SWIG_fail;
28973 {
28974 arg2 = &temp2;
28975 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28976 }
28977 {
28978 PyThreadState* __tstate = wxPyBeginAllowThreads();
28979 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28980
28981 wxPyEndAllowThreads(__tstate);
28982 if (PyErr_Occurred()) SWIG_fail;
28983 }
28984 {
28985 wxSize * resultptr;
28986 resultptr = new wxSize((wxSize &)(result));
28987 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28988 }
28989 return resultobj;
28990 fail:
28991 return NULL;
28992 }
28993
28994
28995 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28996 PyObject *resultobj;
28997 wxWindow *arg1 = (wxWindow *) 0 ;
28998 wxPoint *arg2 = 0 ;
28999 wxPoint result;
29000 wxPoint temp2 ;
29001 PyObject * obj0 = 0 ;
29002 PyObject * obj1 = 0 ;
29003 char *kwnames[] = {
29004 (char *) "self",(char *) "pt", NULL
29005 };
29006
29007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29009 if (SWIG_arg_fail(1)) SWIG_fail;
29010 {
29011 arg2 = &temp2;
29012 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29013 }
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29017
29018 wxPyEndAllowThreads(__tstate);
29019 if (PyErr_Occurred()) SWIG_fail;
29020 }
29021 {
29022 wxPoint * resultptr;
29023 resultptr = new wxPoint((wxPoint &)(result));
29024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29025 }
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj;
29034 wxWindow *arg1 = (wxWindow *) 0 ;
29035 wxSize *arg2 = 0 ;
29036 wxSize result;
29037 wxSize temp2 ;
29038 PyObject * obj0 = 0 ;
29039 PyObject * obj1 = 0 ;
29040 char *kwnames[] = {
29041 (char *) "self",(char *) "sz", NULL
29042 };
29043
29044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29046 if (SWIG_arg_fail(1)) SWIG_fail;
29047 {
29048 arg2 = &temp2;
29049 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29050 }
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29054
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 {
29059 wxSize * resultptr;
29060 resultptr = new wxSize((wxSize &)(result));
29061 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29062 }
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29070 PyObject *resultobj;
29071 wxWindow *arg1 = (wxWindow *) 0 ;
29072 wxPoint *arg2 = 0 ;
29073 wxPoint result;
29074 wxPoint temp2 ;
29075 PyObject * obj0 = 0 ;
29076 PyObject * obj1 = 0 ;
29077 char *kwnames[] = {
29078 (char *) "self",(char *) "pt", NULL
29079 };
29080
29081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29083 if (SWIG_arg_fail(1)) SWIG_fail;
29084 {
29085 arg2 = &temp2;
29086 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29087 }
29088 {
29089 PyThreadState* __tstate = wxPyBeginAllowThreads();
29090 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29091
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 {
29096 wxPoint * resultptr;
29097 resultptr = new wxPoint((wxPoint &)(result));
29098 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29099 }
29100 return resultobj;
29101 fail:
29102 return NULL;
29103 }
29104
29105
29106 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29107 PyObject *resultobj;
29108 wxWindow *arg1 = (wxWindow *) 0 ;
29109 wxSize *arg2 = 0 ;
29110 wxSize result;
29111 wxSize temp2 ;
29112 PyObject * obj0 = 0 ;
29113 PyObject * obj1 = 0 ;
29114 char *kwnames[] = {
29115 (char *) "self",(char *) "sz", NULL
29116 };
29117
29118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29120 if (SWIG_arg_fail(1)) SWIG_fail;
29121 {
29122 arg2 = &temp2;
29123 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29124 }
29125 {
29126 PyThreadState* __tstate = wxPyBeginAllowThreads();
29127 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29128
29129 wxPyEndAllowThreads(__tstate);
29130 if (PyErr_Occurred()) SWIG_fail;
29131 }
29132 {
29133 wxSize * resultptr;
29134 resultptr = new wxSize((wxSize &)(result));
29135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29136 }
29137 return resultobj;
29138 fail:
29139 return NULL;
29140 }
29141
29142
29143 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29144 PyObject *resultobj;
29145 wxWindow *arg1 = (wxWindow *) 0 ;
29146 int arg2 ;
29147 int arg3 ;
29148 PyObject * obj0 = 0 ;
29149 PyObject * obj1 = 0 ;
29150 PyObject * obj2 = 0 ;
29151 char *kwnames[] = {
29152 (char *) "self",(char *) "x",(char *) "y", NULL
29153 };
29154
29155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29157 if (SWIG_arg_fail(1)) SWIG_fail;
29158 {
29159 arg2 = (int)(SWIG_As_int(obj1));
29160 if (SWIG_arg_fail(2)) SWIG_fail;
29161 }
29162 {
29163 arg3 = (int)(SWIG_As_int(obj2));
29164 if (SWIG_arg_fail(3)) SWIG_fail;
29165 }
29166 {
29167 PyThreadState* __tstate = wxPyBeginAllowThreads();
29168 (arg1)->WarpPointer(arg2,arg3);
29169
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 Py_INCREF(Py_None); resultobj = Py_None;
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29181 PyObject *resultobj;
29182 wxWindow *arg1 = (wxWindow *) 0 ;
29183 PyObject * obj0 = 0 ;
29184 char *kwnames[] = {
29185 (char *) "self", NULL
29186 };
29187
29188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29190 if (SWIG_arg_fail(1)) SWIG_fail;
29191 {
29192 PyThreadState* __tstate = wxPyBeginAllowThreads();
29193 (arg1)->CaptureMouse();
29194
29195 wxPyEndAllowThreads(__tstate);
29196 if (PyErr_Occurred()) SWIG_fail;
29197 }
29198 Py_INCREF(Py_None); resultobj = Py_None;
29199 return resultobj;
29200 fail:
29201 return NULL;
29202 }
29203
29204
29205 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29206 PyObject *resultobj;
29207 wxWindow *arg1 = (wxWindow *) 0 ;
29208 PyObject * obj0 = 0 ;
29209 char *kwnames[] = {
29210 (char *) "self", NULL
29211 };
29212
29213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29215 if (SWIG_arg_fail(1)) SWIG_fail;
29216 {
29217 PyThreadState* __tstate = wxPyBeginAllowThreads();
29218 (arg1)->ReleaseMouse();
29219
29220 wxPyEndAllowThreads(__tstate);
29221 if (PyErr_Occurred()) SWIG_fail;
29222 }
29223 Py_INCREF(Py_None); resultobj = Py_None;
29224 return resultobj;
29225 fail:
29226 return NULL;
29227 }
29228
29229
29230 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29231 PyObject *resultobj;
29232 wxWindow *result;
29233 char *kwnames[] = {
29234 NULL
29235 };
29236
29237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29238 {
29239 if (!wxPyCheckForApp()) SWIG_fail;
29240 PyThreadState* __tstate = wxPyBeginAllowThreads();
29241 result = (wxWindow *)wxWindow::GetCapture();
29242
29243 wxPyEndAllowThreads(__tstate);
29244 if (PyErr_Occurred()) SWIG_fail;
29245 }
29246 {
29247 resultobj = wxPyMake_wxObject(result, 0);
29248 }
29249 return resultobj;
29250 fail:
29251 return NULL;
29252 }
29253
29254
29255 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29256 PyObject *resultobj;
29257 wxWindow *arg1 = (wxWindow *) 0 ;
29258 bool result;
29259 PyObject * obj0 = 0 ;
29260 char *kwnames[] = {
29261 (char *) "self", NULL
29262 };
29263
29264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29266 if (SWIG_arg_fail(1)) SWIG_fail;
29267 {
29268 PyThreadState* __tstate = wxPyBeginAllowThreads();
29269 result = (bool)((wxWindow const *)arg1)->HasCapture();
29270
29271 wxPyEndAllowThreads(__tstate);
29272 if (PyErr_Occurred()) SWIG_fail;
29273 }
29274 {
29275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29276 }
29277 return resultobj;
29278 fail:
29279 return NULL;
29280 }
29281
29282
29283 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29284 PyObject *resultobj;
29285 wxWindow *arg1 = (wxWindow *) 0 ;
29286 bool arg2 = (bool) true ;
29287 wxRect *arg3 = (wxRect *) NULL ;
29288 PyObject * obj0 = 0 ;
29289 PyObject * obj1 = 0 ;
29290 PyObject * obj2 = 0 ;
29291 char *kwnames[] = {
29292 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29293 };
29294
29295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29297 if (SWIG_arg_fail(1)) SWIG_fail;
29298 if (obj1) {
29299 {
29300 arg2 = (bool)(SWIG_As_bool(obj1));
29301 if (SWIG_arg_fail(2)) SWIG_fail;
29302 }
29303 }
29304 if (obj2) {
29305 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29306 if (SWIG_arg_fail(3)) SWIG_fail;
29307 }
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29311
29312 wxPyEndAllowThreads(__tstate);
29313 if (PyErr_Occurred()) SWIG_fail;
29314 }
29315 Py_INCREF(Py_None); resultobj = Py_None;
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj;
29324 wxWindow *arg1 = (wxWindow *) 0 ;
29325 wxRect *arg2 = 0 ;
29326 bool arg3 = (bool) true ;
29327 wxRect temp2 ;
29328 PyObject * obj0 = 0 ;
29329 PyObject * obj1 = 0 ;
29330 PyObject * obj2 = 0 ;
29331 char *kwnames[] = {
29332 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29333 };
29334
29335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29337 if (SWIG_arg_fail(1)) SWIG_fail;
29338 {
29339 arg2 = &temp2;
29340 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29341 }
29342 if (obj2) {
29343 {
29344 arg3 = (bool)(SWIG_As_bool(obj2));
29345 if (SWIG_arg_fail(3)) SWIG_fail;
29346 }
29347 }
29348 {
29349 PyThreadState* __tstate = wxPyBeginAllowThreads();
29350 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29351
29352 wxPyEndAllowThreads(__tstate);
29353 if (PyErr_Occurred()) SWIG_fail;
29354 }
29355 Py_INCREF(Py_None); resultobj = Py_None;
29356 return resultobj;
29357 fail:
29358 return NULL;
29359 }
29360
29361
29362 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29363 PyObject *resultobj;
29364 wxWindow *arg1 = (wxWindow *) 0 ;
29365 PyObject * obj0 = 0 ;
29366 char *kwnames[] = {
29367 (char *) "self", NULL
29368 };
29369
29370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29372 if (SWIG_arg_fail(1)) SWIG_fail;
29373 {
29374 PyThreadState* __tstate = wxPyBeginAllowThreads();
29375 (arg1)->Update();
29376
29377 wxPyEndAllowThreads(__tstate);
29378 if (PyErr_Occurred()) SWIG_fail;
29379 }
29380 Py_INCREF(Py_None); resultobj = Py_None;
29381 return resultobj;
29382 fail:
29383 return NULL;
29384 }
29385
29386
29387 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29388 PyObject *resultobj;
29389 wxWindow *arg1 = (wxWindow *) 0 ;
29390 PyObject * obj0 = 0 ;
29391 char *kwnames[] = {
29392 (char *) "self", NULL
29393 };
29394
29395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29397 if (SWIG_arg_fail(1)) SWIG_fail;
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 (arg1)->ClearBackground();
29401
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 Py_INCREF(Py_None); resultobj = Py_None;
29406 return resultobj;
29407 fail:
29408 return NULL;
29409 }
29410
29411
29412 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29413 PyObject *resultobj;
29414 wxWindow *arg1 = (wxWindow *) 0 ;
29415 PyObject * obj0 = 0 ;
29416 char *kwnames[] = {
29417 (char *) "self", NULL
29418 };
29419
29420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29422 if (SWIG_arg_fail(1)) SWIG_fail;
29423 {
29424 PyThreadState* __tstate = wxPyBeginAllowThreads();
29425 (arg1)->Freeze();
29426
29427 wxPyEndAllowThreads(__tstate);
29428 if (PyErr_Occurred()) SWIG_fail;
29429 }
29430 Py_INCREF(Py_None); resultobj = Py_None;
29431 return resultobj;
29432 fail:
29433 return NULL;
29434 }
29435
29436
29437 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29438 PyObject *resultobj;
29439 wxWindow *arg1 = (wxWindow *) 0 ;
29440 PyObject * obj0 = 0 ;
29441 char *kwnames[] = {
29442 (char *) "self", NULL
29443 };
29444
29445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",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 (arg1)->Thaw();
29451
29452 wxPyEndAllowThreads(__tstate);
29453 if (PyErr_Occurred()) SWIG_fail;
29454 }
29455 Py_INCREF(Py_None); resultobj = Py_None;
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj;
29464 wxWindow *arg1 = (wxWindow *) 0 ;
29465 wxDC *arg2 = 0 ;
29466 PyObject * obj0 = 0 ;
29467 PyObject * obj1 = 0 ;
29468 char *kwnames[] = {
29469 (char *) "self",(char *) "dc", NULL
29470 };
29471
29472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29474 if (SWIG_arg_fail(1)) SWIG_fail;
29475 {
29476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29477 if (SWIG_arg_fail(2)) SWIG_fail;
29478 if (arg2 == NULL) {
29479 SWIG_null_ref("wxDC");
29480 }
29481 if (SWIG_arg_fail(2)) SWIG_fail;
29482 }
29483 {
29484 PyThreadState* __tstate = wxPyBeginAllowThreads();
29485 (arg1)->PrepareDC(*arg2);
29486
29487 wxPyEndAllowThreads(__tstate);
29488 if (PyErr_Occurred()) SWIG_fail;
29489 }
29490 Py_INCREF(Py_None); resultobj = Py_None;
29491 return resultobj;
29492 fail:
29493 return NULL;
29494 }
29495
29496
29497 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29498 PyObject *resultobj;
29499 wxWindow *arg1 = (wxWindow *) 0 ;
29500 wxRegion *result;
29501 PyObject * obj0 = 0 ;
29502 char *kwnames[] = {
29503 (char *) "self", NULL
29504 };
29505
29506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29508 if (SWIG_arg_fail(1)) SWIG_fail;
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 {
29512 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29513 result = (wxRegion *) &_result_ref;
29514 }
29515
29516 wxPyEndAllowThreads(__tstate);
29517 if (PyErr_Occurred()) SWIG_fail;
29518 }
29519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29520 return resultobj;
29521 fail:
29522 return NULL;
29523 }
29524
29525
29526 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29527 PyObject *resultobj;
29528 wxWindow *arg1 = (wxWindow *) 0 ;
29529 wxRect result;
29530 PyObject * obj0 = 0 ;
29531 char *kwnames[] = {
29532 (char *) "self", NULL
29533 };
29534
29535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",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 = ((wxWindow const *)arg1)->GetUpdateClientRect();
29541
29542 wxPyEndAllowThreads(__tstate);
29543 if (PyErr_Occurred()) SWIG_fail;
29544 }
29545 {
29546 wxRect * resultptr;
29547 resultptr = new wxRect((wxRect &)(result));
29548 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29549 }
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29557 PyObject *resultobj;
29558 wxWindow *arg1 = (wxWindow *) 0 ;
29559 int arg2 ;
29560 int arg3 ;
29561 int arg4 = (int) 1 ;
29562 int arg5 = (int) 1 ;
29563 bool result;
29564 PyObject * obj0 = 0 ;
29565 PyObject * obj1 = 0 ;
29566 PyObject * obj2 = 0 ;
29567 PyObject * obj3 = 0 ;
29568 PyObject * obj4 = 0 ;
29569 char *kwnames[] = {
29570 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29571 };
29572
29573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29575 if (SWIG_arg_fail(1)) SWIG_fail;
29576 {
29577 arg2 = (int)(SWIG_As_int(obj1));
29578 if (SWIG_arg_fail(2)) SWIG_fail;
29579 }
29580 {
29581 arg3 = (int)(SWIG_As_int(obj2));
29582 if (SWIG_arg_fail(3)) SWIG_fail;
29583 }
29584 if (obj3) {
29585 {
29586 arg4 = (int)(SWIG_As_int(obj3));
29587 if (SWIG_arg_fail(4)) SWIG_fail;
29588 }
29589 }
29590 if (obj4) {
29591 {
29592 arg5 = (int)(SWIG_As_int(obj4));
29593 if (SWIG_arg_fail(5)) SWIG_fail;
29594 }
29595 }
29596 {
29597 PyThreadState* __tstate = wxPyBeginAllowThreads();
29598 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29599
29600 wxPyEndAllowThreads(__tstate);
29601 if (PyErr_Occurred()) SWIG_fail;
29602 }
29603 {
29604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29605 }
29606 return resultobj;
29607 fail:
29608 return NULL;
29609 }
29610
29611
29612 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29613 PyObject *resultobj;
29614 wxWindow *arg1 = (wxWindow *) 0 ;
29615 wxPoint *arg2 = 0 ;
29616 bool result;
29617 wxPoint temp2 ;
29618 PyObject * obj0 = 0 ;
29619 PyObject * obj1 = 0 ;
29620 char *kwnames[] = {
29621 (char *) "self",(char *) "pt", NULL
29622 };
29623
29624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29626 if (SWIG_arg_fail(1)) SWIG_fail;
29627 {
29628 arg2 = &temp2;
29629 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29630 }
29631 {
29632 PyThreadState* __tstate = wxPyBeginAllowThreads();
29633 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29634
29635 wxPyEndAllowThreads(__tstate);
29636 if (PyErr_Occurred()) SWIG_fail;
29637 }
29638 {
29639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29640 }
29641 return resultobj;
29642 fail:
29643 return NULL;
29644 }
29645
29646
29647 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29648 PyObject *resultobj;
29649 wxWindow *arg1 = (wxWindow *) 0 ;
29650 wxRect *arg2 = 0 ;
29651 bool result;
29652 wxRect temp2 ;
29653 PyObject * obj0 = 0 ;
29654 PyObject * obj1 = 0 ;
29655 char *kwnames[] = {
29656 (char *) "self",(char *) "rect", NULL
29657 };
29658
29659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",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 arg2 = &temp2;
29664 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29665 }
29666 {
29667 PyThreadState* __tstate = wxPyBeginAllowThreads();
29668 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29669
29670 wxPyEndAllowThreads(__tstate);
29671 if (PyErr_Occurred()) SWIG_fail;
29672 }
29673 {
29674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29675 }
29676 return resultobj;
29677 fail:
29678 return NULL;
29679 }
29680
29681
29682 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29683 PyObject *resultobj;
29684 wxWindow *arg1 = (wxWindow *) 0 ;
29685 wxVisualAttributes result;
29686 PyObject * obj0 = 0 ;
29687 char *kwnames[] = {
29688 (char *) "self", NULL
29689 };
29690
29691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29693 if (SWIG_arg_fail(1)) SWIG_fail;
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29697
29698 wxPyEndAllowThreads(__tstate);
29699 if (PyErr_Occurred()) SWIG_fail;
29700 }
29701 {
29702 wxVisualAttributes * resultptr;
29703 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29704 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29705 }
29706 return resultobj;
29707 fail:
29708 return NULL;
29709 }
29710
29711
29712 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29713 PyObject *resultobj;
29714 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29715 wxVisualAttributes result;
29716 PyObject * obj0 = 0 ;
29717 char *kwnames[] = {
29718 (char *) "variant", NULL
29719 };
29720
29721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29722 if (obj0) {
29723 {
29724 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29725 if (SWIG_arg_fail(1)) SWIG_fail;
29726 }
29727 }
29728 {
29729 if (!wxPyCheckForApp()) SWIG_fail;
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29732
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 {
29737 wxVisualAttributes * resultptr;
29738 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29739 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29740 }
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29748 PyObject *resultobj;
29749 wxWindow *arg1 = (wxWindow *) 0 ;
29750 wxColour *arg2 = 0 ;
29751 bool result;
29752 wxColour temp2 ;
29753 PyObject * obj0 = 0 ;
29754 PyObject * obj1 = 0 ;
29755 char *kwnames[] = {
29756 (char *) "self",(char *) "colour", NULL
29757 };
29758
29759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29761 if (SWIG_arg_fail(1)) SWIG_fail;
29762 {
29763 arg2 = &temp2;
29764 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29765 }
29766 {
29767 PyThreadState* __tstate = wxPyBeginAllowThreads();
29768 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29769
29770 wxPyEndAllowThreads(__tstate);
29771 if (PyErr_Occurred()) SWIG_fail;
29772 }
29773 {
29774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29775 }
29776 return resultobj;
29777 fail:
29778 return NULL;
29779 }
29780
29781
29782 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29783 PyObject *resultobj;
29784 wxWindow *arg1 = (wxWindow *) 0 ;
29785 wxColour *arg2 = 0 ;
29786 wxColour temp2 ;
29787 PyObject * obj0 = 0 ;
29788 PyObject * obj1 = 0 ;
29789 char *kwnames[] = {
29790 (char *) "self",(char *) "colour", NULL
29791 };
29792
29793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29795 if (SWIG_arg_fail(1)) SWIG_fail;
29796 {
29797 arg2 = &temp2;
29798 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29799 }
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29803
29804 wxPyEndAllowThreads(__tstate);
29805 if (PyErr_Occurred()) SWIG_fail;
29806 }
29807 Py_INCREF(Py_None); resultobj = Py_None;
29808 return resultobj;
29809 fail:
29810 return NULL;
29811 }
29812
29813
29814 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29815 PyObject *resultobj;
29816 wxWindow *arg1 = (wxWindow *) 0 ;
29817 wxColour *arg2 = 0 ;
29818 bool result;
29819 wxColour temp2 ;
29820 PyObject * obj0 = 0 ;
29821 PyObject * obj1 = 0 ;
29822 char *kwnames[] = {
29823 (char *) "self",(char *) "colour", NULL
29824 };
29825
29826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29828 if (SWIG_arg_fail(1)) SWIG_fail;
29829 {
29830 arg2 = &temp2;
29831 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29832 }
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29836
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 {
29841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29842 }
29843 return resultobj;
29844 fail:
29845 return NULL;
29846 }
29847
29848
29849 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29850 PyObject *resultobj;
29851 wxWindow *arg1 = (wxWindow *) 0 ;
29852 wxColour *arg2 = 0 ;
29853 wxColour temp2 ;
29854 PyObject * obj0 = 0 ;
29855 PyObject * obj1 = 0 ;
29856 char *kwnames[] = {
29857 (char *) "self",(char *) "colour", NULL
29858 };
29859
29860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29862 if (SWIG_arg_fail(1)) SWIG_fail;
29863 {
29864 arg2 = &temp2;
29865 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29866 }
29867 {
29868 PyThreadState* __tstate = wxPyBeginAllowThreads();
29869 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29870
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 Py_INCREF(Py_None); resultobj = Py_None;
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29882 PyObject *resultobj;
29883 wxWindow *arg1 = (wxWindow *) 0 ;
29884 wxColour result;
29885 PyObject * obj0 = 0 ;
29886 char *kwnames[] = {
29887 (char *) "self", NULL
29888 };
29889
29890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29892 if (SWIG_arg_fail(1)) SWIG_fail;
29893 {
29894 PyThreadState* __tstate = wxPyBeginAllowThreads();
29895 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29896
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 {
29901 wxColour * resultptr;
29902 resultptr = new wxColour((wxColour &)(result));
29903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29904 }
29905 return resultobj;
29906 fail:
29907 return NULL;
29908 }
29909
29910
29911 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29912 PyObject *resultobj;
29913 wxWindow *arg1 = (wxWindow *) 0 ;
29914 wxColour result;
29915 PyObject * obj0 = 0 ;
29916 char *kwnames[] = {
29917 (char *) "self", NULL
29918 };
29919
29920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29922 if (SWIG_arg_fail(1)) SWIG_fail;
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 result = ((wxWindow const *)arg1)->GetForegroundColour();
29926
29927 wxPyEndAllowThreads(__tstate);
29928 if (PyErr_Occurred()) SWIG_fail;
29929 }
29930 {
29931 wxColour * resultptr;
29932 resultptr = new wxColour((wxColour &)(result));
29933 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29934 }
29935 return resultobj;
29936 fail:
29937 return NULL;
29938 }
29939
29940
29941 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29942 PyObject *resultobj;
29943 wxWindow *arg1 = (wxWindow *) 0 ;
29944 bool result;
29945 PyObject * obj0 = 0 ;
29946 char *kwnames[] = {
29947 (char *) "self", NULL
29948 };
29949
29950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29952 if (SWIG_arg_fail(1)) SWIG_fail;
29953 {
29954 PyThreadState* __tstate = wxPyBeginAllowThreads();
29955 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29956
29957 wxPyEndAllowThreads(__tstate);
29958 if (PyErr_Occurred()) SWIG_fail;
29959 }
29960 {
29961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29962 }
29963 return resultobj;
29964 fail:
29965 return NULL;
29966 }
29967
29968
29969 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29970 PyObject *resultobj;
29971 wxWindow *arg1 = (wxWindow *) 0 ;
29972 bool result;
29973 PyObject * obj0 = 0 ;
29974 char *kwnames[] = {
29975 (char *) "self", NULL
29976 };
29977
29978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29980 if (SWIG_arg_fail(1)) SWIG_fail;
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29984
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 {
29989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29990 }
29991 return resultobj;
29992 fail:
29993 return NULL;
29994 }
29995
29996
29997 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29998 PyObject *resultobj;
29999 wxWindow *arg1 = (wxWindow *) 0 ;
30000 wxBackgroundStyle arg2 ;
30001 bool result;
30002 PyObject * obj0 = 0 ;
30003 PyObject * obj1 = 0 ;
30004 char *kwnames[] = {
30005 (char *) "self",(char *) "style", NULL
30006 };
30007
30008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30010 if (SWIG_arg_fail(1)) SWIG_fail;
30011 {
30012 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
30013 if (SWIG_arg_fail(2)) SWIG_fail;
30014 }
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
30018
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 {
30023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30024 }
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30032 PyObject *resultobj;
30033 wxWindow *arg1 = (wxWindow *) 0 ;
30034 wxBackgroundStyle result;
30035 PyObject * obj0 = 0 ;
30036 char *kwnames[] = {
30037 (char *) "self", NULL
30038 };
30039
30040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30042 if (SWIG_arg_fail(1)) SWIG_fail;
30043 {
30044 PyThreadState* __tstate = wxPyBeginAllowThreads();
30045 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30046
30047 wxPyEndAllowThreads(__tstate);
30048 if (PyErr_Occurred()) SWIG_fail;
30049 }
30050 resultobj = SWIG_From_int((result));
30051 return resultobj;
30052 fail:
30053 return NULL;
30054 }
30055
30056
30057 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30058 PyObject *resultobj;
30059 wxWindow *arg1 = (wxWindow *) 0 ;
30060 bool result;
30061 PyObject * obj0 = 0 ;
30062 char *kwnames[] = {
30063 (char *) "self", NULL
30064 };
30065
30066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30068 if (SWIG_arg_fail(1)) SWIG_fail;
30069 {
30070 PyThreadState* __tstate = wxPyBeginAllowThreads();
30071 result = (bool)(arg1)->HasTransparentBackground();
30072
30073 wxPyEndAllowThreads(__tstate);
30074 if (PyErr_Occurred()) SWIG_fail;
30075 }
30076 {
30077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30078 }
30079 return resultobj;
30080 fail:
30081 return NULL;
30082 }
30083
30084
30085 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30086 PyObject *resultobj;
30087 wxWindow *arg1 = (wxWindow *) 0 ;
30088 wxCursor *arg2 = 0 ;
30089 bool result;
30090 PyObject * obj0 = 0 ;
30091 PyObject * obj1 = 0 ;
30092 char *kwnames[] = {
30093 (char *) "self",(char *) "cursor", NULL
30094 };
30095
30096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30098 if (SWIG_arg_fail(1)) SWIG_fail;
30099 {
30100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30101 if (SWIG_arg_fail(2)) SWIG_fail;
30102 if (arg2 == NULL) {
30103 SWIG_null_ref("wxCursor");
30104 }
30105 if (SWIG_arg_fail(2)) SWIG_fail;
30106 }
30107 {
30108 PyThreadState* __tstate = wxPyBeginAllowThreads();
30109 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30110
30111 wxPyEndAllowThreads(__tstate);
30112 if (PyErr_Occurred()) SWIG_fail;
30113 }
30114 {
30115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30116 }
30117 return resultobj;
30118 fail:
30119 return NULL;
30120 }
30121
30122
30123 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30124 PyObject *resultobj;
30125 wxWindow *arg1 = (wxWindow *) 0 ;
30126 wxCursor result;
30127 PyObject * obj0 = 0 ;
30128 char *kwnames[] = {
30129 (char *) "self", NULL
30130 };
30131
30132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30134 if (SWIG_arg_fail(1)) SWIG_fail;
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 result = (arg1)->GetCursor();
30138
30139 wxPyEndAllowThreads(__tstate);
30140 if (PyErr_Occurred()) SWIG_fail;
30141 }
30142 {
30143 wxCursor * resultptr;
30144 resultptr = new wxCursor((wxCursor &)(result));
30145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30146 }
30147 return resultobj;
30148 fail:
30149 return NULL;
30150 }
30151
30152
30153 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30154 PyObject *resultobj;
30155 wxWindow *arg1 = (wxWindow *) 0 ;
30156 wxFont *arg2 = 0 ;
30157 bool result;
30158 PyObject * obj0 = 0 ;
30159 PyObject * obj1 = 0 ;
30160 char *kwnames[] = {
30161 (char *) "self",(char *) "font", NULL
30162 };
30163
30164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30166 if (SWIG_arg_fail(1)) SWIG_fail;
30167 {
30168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30169 if (SWIG_arg_fail(2)) SWIG_fail;
30170 if (arg2 == NULL) {
30171 SWIG_null_ref("wxFont");
30172 }
30173 if (SWIG_arg_fail(2)) SWIG_fail;
30174 }
30175 {
30176 PyThreadState* __tstate = wxPyBeginAllowThreads();
30177 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30178
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 {
30183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30184 }
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj;
30193 wxWindow *arg1 = (wxWindow *) 0 ;
30194 wxFont *arg2 = 0 ;
30195 PyObject * obj0 = 0 ;
30196 PyObject * obj1 = 0 ;
30197 char *kwnames[] = {
30198 (char *) "self",(char *) "font", NULL
30199 };
30200
30201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30203 if (SWIG_arg_fail(1)) SWIG_fail;
30204 {
30205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30206 if (SWIG_arg_fail(2)) SWIG_fail;
30207 if (arg2 == NULL) {
30208 SWIG_null_ref("wxFont");
30209 }
30210 if (SWIG_arg_fail(2)) SWIG_fail;
30211 }
30212 {
30213 PyThreadState* __tstate = wxPyBeginAllowThreads();
30214 (arg1)->SetOwnFont((wxFont const &)*arg2);
30215
30216 wxPyEndAllowThreads(__tstate);
30217 if (PyErr_Occurred()) SWIG_fail;
30218 }
30219 Py_INCREF(Py_None); resultobj = Py_None;
30220 return resultobj;
30221 fail:
30222 return NULL;
30223 }
30224
30225
30226 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30227 PyObject *resultobj;
30228 wxWindow *arg1 = (wxWindow *) 0 ;
30229 wxFont result;
30230 PyObject * obj0 = 0 ;
30231 char *kwnames[] = {
30232 (char *) "self", NULL
30233 };
30234
30235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30237 if (SWIG_arg_fail(1)) SWIG_fail;
30238 {
30239 PyThreadState* __tstate = wxPyBeginAllowThreads();
30240 result = (arg1)->GetFont();
30241
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 {
30246 wxFont * resultptr;
30247 resultptr = new wxFont((wxFont &)(result));
30248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30249 }
30250 return resultobj;
30251 fail:
30252 return NULL;
30253 }
30254
30255
30256 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30257 PyObject *resultobj;
30258 wxWindow *arg1 = (wxWindow *) 0 ;
30259 wxCaret *arg2 = (wxCaret *) 0 ;
30260 PyObject * obj0 = 0 ;
30261 PyObject * obj1 = 0 ;
30262 char *kwnames[] = {
30263 (char *) "self",(char *) "caret", NULL
30264 };
30265
30266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30268 if (SWIG_arg_fail(1)) SWIG_fail;
30269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(2)) SWIG_fail;
30271 {
30272 PyThreadState* __tstate = wxPyBeginAllowThreads();
30273 (arg1)->SetCaret(arg2);
30274
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 Py_INCREF(Py_None); resultobj = Py_None;
30279 return resultobj;
30280 fail:
30281 return NULL;
30282 }
30283
30284
30285 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30286 PyObject *resultobj;
30287 wxWindow *arg1 = (wxWindow *) 0 ;
30288 wxCaret *result;
30289 PyObject * obj0 = 0 ;
30290 char *kwnames[] = {
30291 (char *) "self", NULL
30292 };
30293
30294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30296 if (SWIG_arg_fail(1)) SWIG_fail;
30297 {
30298 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30300
30301 wxPyEndAllowThreads(__tstate);
30302 if (PyErr_Occurred()) SWIG_fail;
30303 }
30304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30305 return resultobj;
30306 fail:
30307 return NULL;
30308 }
30309
30310
30311 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30312 PyObject *resultobj;
30313 wxWindow *arg1 = (wxWindow *) 0 ;
30314 int result;
30315 PyObject * obj0 = 0 ;
30316 char *kwnames[] = {
30317 (char *) "self", NULL
30318 };
30319
30320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30322 if (SWIG_arg_fail(1)) SWIG_fail;
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30326
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 {
30331 resultobj = SWIG_From_int((int)(result));
30332 }
30333 return resultobj;
30334 fail:
30335 return NULL;
30336 }
30337
30338
30339 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30340 PyObject *resultobj;
30341 wxWindow *arg1 = (wxWindow *) 0 ;
30342 int result;
30343 PyObject * obj0 = 0 ;
30344 char *kwnames[] = {
30345 (char *) "self", NULL
30346 };
30347
30348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30350 if (SWIG_arg_fail(1)) SWIG_fail;
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30354
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 {
30359 resultobj = SWIG_From_int((int)(result));
30360 }
30361 return resultobj;
30362 fail:
30363 return NULL;
30364 }
30365
30366
30367 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30368 PyObject *resultobj;
30369 wxWindow *arg1 = (wxWindow *) 0 ;
30370 wxString *arg2 = 0 ;
30371 int *arg3 = (int *) 0 ;
30372 int *arg4 = (int *) 0 ;
30373 bool temp2 = false ;
30374 int temp3 ;
30375 int res3 = 0 ;
30376 int temp4 ;
30377 int res4 = 0 ;
30378 PyObject * obj0 = 0 ;
30379 PyObject * obj1 = 0 ;
30380 char *kwnames[] = {
30381 (char *) "self",(char *) "string", NULL
30382 };
30383
30384 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30385 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30388 if (SWIG_arg_fail(1)) SWIG_fail;
30389 {
30390 arg2 = wxString_in_helper(obj1);
30391 if (arg2 == NULL) SWIG_fail;
30392 temp2 = true;
30393 }
30394 {
30395 PyThreadState* __tstate = wxPyBeginAllowThreads();
30396 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30397
30398 wxPyEndAllowThreads(__tstate);
30399 if (PyErr_Occurred()) SWIG_fail;
30400 }
30401 Py_INCREF(Py_None); resultobj = Py_None;
30402 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30403 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30404 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30405 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30406 {
30407 if (temp2)
30408 delete arg2;
30409 }
30410 return resultobj;
30411 fail:
30412 {
30413 if (temp2)
30414 delete arg2;
30415 }
30416 return NULL;
30417 }
30418
30419
30420 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30421 PyObject *resultobj;
30422 wxWindow *arg1 = (wxWindow *) 0 ;
30423 wxString *arg2 = 0 ;
30424 int *arg3 = (int *) 0 ;
30425 int *arg4 = (int *) 0 ;
30426 int *arg5 = (int *) 0 ;
30427 int *arg6 = (int *) 0 ;
30428 wxFont *arg7 = (wxFont *) NULL ;
30429 bool temp2 = false ;
30430 int temp3 ;
30431 int res3 = 0 ;
30432 int temp4 ;
30433 int res4 = 0 ;
30434 int temp5 ;
30435 int res5 = 0 ;
30436 int temp6 ;
30437 int res6 = 0 ;
30438 PyObject * obj0 = 0 ;
30439 PyObject * obj1 = 0 ;
30440 PyObject * obj2 = 0 ;
30441 char *kwnames[] = {
30442 (char *) "self",(char *) "string",(char *) "font", NULL
30443 };
30444
30445 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30446 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30447 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30448 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30451 if (SWIG_arg_fail(1)) SWIG_fail;
30452 {
30453 arg2 = wxString_in_helper(obj1);
30454 if (arg2 == NULL) SWIG_fail;
30455 temp2 = true;
30456 }
30457 if (obj2) {
30458 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30459 if (SWIG_arg_fail(7)) SWIG_fail;
30460 }
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30464
30465 wxPyEndAllowThreads(__tstate);
30466 if (PyErr_Occurred()) SWIG_fail;
30467 }
30468 Py_INCREF(Py_None); resultobj = Py_None;
30469 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30470 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30471 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30472 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30473 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30474 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30475 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30476 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30477 {
30478 if (temp2)
30479 delete arg2;
30480 }
30481 return resultobj;
30482 fail:
30483 {
30484 if (temp2)
30485 delete arg2;
30486 }
30487 return NULL;
30488 }
30489
30490
30491 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30492 PyObject *resultobj;
30493 wxWindow *arg1 = (wxWindow *) 0 ;
30494 int *arg2 = (int *) 0 ;
30495 int *arg3 = (int *) 0 ;
30496 int temp2 ;
30497 int res2 = 0 ;
30498 int temp3 ;
30499 int res3 = 0 ;
30500 PyObject * obj0 = 0 ;
30501 PyObject * obj1 = 0 ;
30502 PyObject * obj2 = 0 ;
30503 char *kwnames[] = {
30504 (char *) "self",(char *) "x",(char *) "y", NULL
30505 };
30506
30507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30509 if (SWIG_arg_fail(1)) SWIG_fail;
30510 {
30511 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30512 temp2 = SWIG_As_int(obj1);
30513 if (SWIG_arg_fail(2)) SWIG_fail;
30514 arg2 = &temp2;
30515 res2 = SWIG_NEWOBJ;
30516 }
30517 }
30518 {
30519 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30520 temp3 = SWIG_As_int(obj2);
30521 if (SWIG_arg_fail(3)) SWIG_fail;
30522 arg3 = &temp3;
30523 res3 = SWIG_NEWOBJ;
30524 }
30525 }
30526 {
30527 PyThreadState* __tstate = wxPyBeginAllowThreads();
30528 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30529
30530 wxPyEndAllowThreads(__tstate);
30531 if (PyErr_Occurred()) SWIG_fail;
30532 }
30533 Py_INCREF(Py_None); resultobj = Py_None;
30534 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30535 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30536 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30537 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj;
30546 wxWindow *arg1 = (wxWindow *) 0 ;
30547 int *arg2 = (int *) 0 ;
30548 int *arg3 = (int *) 0 ;
30549 int temp2 ;
30550 int res2 = 0 ;
30551 int temp3 ;
30552 int res3 = 0 ;
30553 PyObject * obj0 = 0 ;
30554 PyObject * obj1 = 0 ;
30555 PyObject * obj2 = 0 ;
30556 char *kwnames[] = {
30557 (char *) "self",(char *) "x",(char *) "y", NULL
30558 };
30559
30560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30562 if (SWIG_arg_fail(1)) SWIG_fail;
30563 {
30564 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30565 temp2 = SWIG_As_int(obj1);
30566 if (SWIG_arg_fail(2)) SWIG_fail;
30567 arg2 = &temp2;
30568 res2 = SWIG_NEWOBJ;
30569 }
30570 }
30571 {
30572 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30573 temp3 = SWIG_As_int(obj2);
30574 if (SWIG_arg_fail(3)) SWIG_fail;
30575 arg3 = &temp3;
30576 res3 = SWIG_NEWOBJ;
30577 }
30578 }
30579 {
30580 PyThreadState* __tstate = wxPyBeginAllowThreads();
30581 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30582
30583 wxPyEndAllowThreads(__tstate);
30584 if (PyErr_Occurred()) SWIG_fail;
30585 }
30586 Py_INCREF(Py_None); resultobj = Py_None;
30587 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30588 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30589 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30590 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30591 return resultobj;
30592 fail:
30593 return NULL;
30594 }
30595
30596
30597 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30598 PyObject *resultobj;
30599 wxWindow *arg1 = (wxWindow *) 0 ;
30600 wxPoint *arg2 = 0 ;
30601 wxPoint result;
30602 wxPoint temp2 ;
30603 PyObject * obj0 = 0 ;
30604 PyObject * obj1 = 0 ;
30605 char *kwnames[] = {
30606 (char *) "self",(char *) "pt", NULL
30607 };
30608
30609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30611 if (SWIG_arg_fail(1)) SWIG_fail;
30612 {
30613 arg2 = &temp2;
30614 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30615 }
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30619
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 {
30624 wxPoint * resultptr;
30625 resultptr = new wxPoint((wxPoint &)(result));
30626 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30627 }
30628 return resultobj;
30629 fail:
30630 return NULL;
30631 }
30632
30633
30634 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30635 PyObject *resultobj;
30636 wxWindow *arg1 = (wxWindow *) 0 ;
30637 wxPoint *arg2 = 0 ;
30638 wxPoint result;
30639 wxPoint temp2 ;
30640 PyObject * obj0 = 0 ;
30641 PyObject * obj1 = 0 ;
30642 char *kwnames[] = {
30643 (char *) "self",(char *) "pt", NULL
30644 };
30645
30646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30648 if (SWIG_arg_fail(1)) SWIG_fail;
30649 {
30650 arg2 = &temp2;
30651 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30652 }
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30656
30657 wxPyEndAllowThreads(__tstate);
30658 if (PyErr_Occurred()) SWIG_fail;
30659 }
30660 {
30661 wxPoint * resultptr;
30662 resultptr = new wxPoint((wxPoint &)(result));
30663 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30664 }
30665 return resultobj;
30666 fail:
30667 return NULL;
30668 }
30669
30670
30671 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30672 PyObject *resultobj;
30673 wxWindow *arg1 = (wxWindow *) 0 ;
30674 int arg2 ;
30675 int arg3 ;
30676 wxHitTest result;
30677 PyObject * obj0 = 0 ;
30678 PyObject * obj1 = 0 ;
30679 PyObject * obj2 = 0 ;
30680 char *kwnames[] = {
30681 (char *) "self",(char *) "x",(char *) "y", NULL
30682 };
30683
30684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) 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 {
30696 PyThreadState* __tstate = wxPyBeginAllowThreads();
30697 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30698
30699 wxPyEndAllowThreads(__tstate);
30700 if (PyErr_Occurred()) SWIG_fail;
30701 }
30702 resultobj = SWIG_From_int((result));
30703 return resultobj;
30704 fail:
30705 return NULL;
30706 }
30707
30708
30709 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30710 PyObject *resultobj;
30711 wxWindow *arg1 = (wxWindow *) 0 ;
30712 wxPoint *arg2 = 0 ;
30713 wxHitTest result;
30714 wxPoint temp2 ;
30715 PyObject * obj0 = 0 ;
30716 PyObject * obj1 = 0 ;
30717 char *kwnames[] = {
30718 (char *) "self",(char *) "pt", NULL
30719 };
30720
30721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30723 if (SWIG_arg_fail(1)) SWIG_fail;
30724 {
30725 arg2 = &temp2;
30726 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30727 }
30728 {
30729 PyThreadState* __tstate = wxPyBeginAllowThreads();
30730 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30731
30732 wxPyEndAllowThreads(__tstate);
30733 if (PyErr_Occurred()) SWIG_fail;
30734 }
30735 resultobj = SWIG_From_int((result));
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30743 PyObject *resultobj;
30744 wxWindow *arg1 = (wxWindow *) 0 ;
30745 long arg2 ;
30746 wxBorder result;
30747 PyObject * obj0 = 0 ;
30748 PyObject * obj1 = 0 ;
30749
30750 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30752 if (SWIG_arg_fail(1)) SWIG_fail;
30753 {
30754 arg2 = (long)(SWIG_As_long(obj1));
30755 if (SWIG_arg_fail(2)) SWIG_fail;
30756 }
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_From_int((result));
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30772 PyObject *resultobj;
30773 wxWindow *arg1 = (wxWindow *) 0 ;
30774 wxBorder result;
30775 PyObject * obj0 = 0 ;
30776
30777 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30779 if (SWIG_arg_fail(1)) SWIG_fail;
30780 {
30781 PyThreadState* __tstate = wxPyBeginAllowThreads();
30782 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30783
30784 wxPyEndAllowThreads(__tstate);
30785 if (PyErr_Occurred()) SWIG_fail;
30786 }
30787 resultobj = SWIG_From_int((result));
30788 return resultobj;
30789 fail:
30790 return NULL;
30791 }
30792
30793
30794 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30795 int argc;
30796 PyObject *argv[3];
30797 int ii;
30798
30799 argc = PyObject_Length(args);
30800 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30801 argv[ii] = PyTuple_GetItem(args,ii);
30802 }
30803 if (argc == 1) {
30804 int _v;
30805 {
30806 void *ptr;
30807 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30808 _v = 0;
30809 PyErr_Clear();
30810 } else {
30811 _v = 1;
30812 }
30813 }
30814 if (_v) {
30815 return _wrap_Window_GetBorder__SWIG_1(self,args);
30816 }
30817 }
30818 if (argc == 2) {
30819 int _v;
30820 {
30821 void *ptr;
30822 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30823 _v = 0;
30824 PyErr_Clear();
30825 } else {
30826 _v = 1;
30827 }
30828 }
30829 if (_v) {
30830 _v = SWIG_Check_long(argv[1]);
30831 if (_v) {
30832 return _wrap_Window_GetBorder__SWIG_0(self,args);
30833 }
30834 }
30835 }
30836
30837 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30838 return NULL;
30839 }
30840
30841
30842 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30843 PyObject *resultobj;
30844 wxWindow *arg1 = (wxWindow *) 0 ;
30845 long arg2 = (long) wxUPDATE_UI_NONE ;
30846 PyObject * obj0 = 0 ;
30847 PyObject * obj1 = 0 ;
30848 char *kwnames[] = {
30849 (char *) "self",(char *) "flags", NULL
30850 };
30851
30852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30854 if (SWIG_arg_fail(1)) SWIG_fail;
30855 if (obj1) {
30856 {
30857 arg2 = (long)(SWIG_As_long(obj1));
30858 if (SWIG_arg_fail(2)) SWIG_fail;
30859 }
30860 }
30861 {
30862 PyThreadState* __tstate = wxPyBeginAllowThreads();
30863 (arg1)->UpdateWindowUI(arg2);
30864
30865 wxPyEndAllowThreads(__tstate);
30866 if (PyErr_Occurred()) SWIG_fail;
30867 }
30868 Py_INCREF(Py_None); resultobj = Py_None;
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30876 PyObject *resultobj;
30877 wxWindow *arg1 = (wxWindow *) 0 ;
30878 wxMenu *arg2 = (wxMenu *) 0 ;
30879 int arg3 = (int) -1 ;
30880 int arg4 = (int) -1 ;
30881 bool result;
30882 PyObject * obj0 = 0 ;
30883 PyObject * obj1 = 0 ;
30884 PyObject * obj2 = 0 ;
30885 PyObject * obj3 = 0 ;
30886 char *kwnames[] = {
30887 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30888 };
30889
30890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30892 if (SWIG_arg_fail(1)) SWIG_fail;
30893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30894 if (SWIG_arg_fail(2)) SWIG_fail;
30895 if (obj2) {
30896 {
30897 arg3 = (int)(SWIG_As_int(obj2));
30898 if (SWIG_arg_fail(3)) SWIG_fail;
30899 }
30900 }
30901 if (obj3) {
30902 {
30903 arg4 = (int)(SWIG_As_int(obj3));
30904 if (SWIG_arg_fail(4)) SWIG_fail;
30905 }
30906 }
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30910
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 {
30915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30916 }
30917 return resultobj;
30918 fail:
30919 return NULL;
30920 }
30921
30922
30923 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30924 PyObject *resultobj;
30925 wxWindow *arg1 = (wxWindow *) 0 ;
30926 wxMenu *arg2 = (wxMenu *) 0 ;
30927 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30928 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30929 bool result;
30930 wxPoint temp3 ;
30931 PyObject * obj0 = 0 ;
30932 PyObject * obj1 = 0 ;
30933 PyObject * obj2 = 0 ;
30934 char *kwnames[] = {
30935 (char *) "self",(char *) "menu",(char *) "pos", NULL
30936 };
30937
30938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30940 if (SWIG_arg_fail(1)) SWIG_fail;
30941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30942 if (SWIG_arg_fail(2)) SWIG_fail;
30943 if (obj2) {
30944 {
30945 arg3 = &temp3;
30946 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30947 }
30948 }
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30952
30953 wxPyEndAllowThreads(__tstate);
30954 if (PyErr_Occurred()) SWIG_fail;
30955 }
30956 {
30957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30958 }
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 long result;
30969 PyObject * obj0 = 0 ;
30970 char *kwnames[] = {
30971 (char *) "self", NULL
30972 };
30973
30974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30976 if (SWIG_arg_fail(1)) SWIG_fail;
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 result = (long)wxWindow_GetHandle(arg1);
30980
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 {
30985 resultobj = SWIG_From_long((long)(result));
30986 }
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30994 PyObject *resultobj;
30995 wxWindow *arg1 = (wxWindow *) 0 ;
30996 long arg2 ;
30997 PyObject * obj0 = 0 ;
30998 PyObject * obj1 = 0 ;
30999 char *kwnames[] = {
31000 (char *) "self",(char *) "handle", NULL
31001 };
31002
31003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31005 if (SWIG_arg_fail(1)) SWIG_fail;
31006 {
31007 arg2 = (long)(SWIG_As_long(obj1));
31008 if (SWIG_arg_fail(2)) SWIG_fail;
31009 }
31010 {
31011 PyThreadState* __tstate = wxPyBeginAllowThreads();
31012 wxWindow_AssociateHandle(arg1,arg2);
31013
31014 wxPyEndAllowThreads(__tstate);
31015 if (PyErr_Occurred()) SWIG_fail;
31016 }
31017 Py_INCREF(Py_None); resultobj = Py_None;
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj;
31026 wxWindow *arg1 = (wxWindow *) 0 ;
31027 PyObject * obj0 = 0 ;
31028 char *kwnames[] = {
31029 (char *) "self", NULL
31030 };
31031
31032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31034 if (SWIG_arg_fail(1)) SWIG_fail;
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 (arg1)->DissociateHandle();
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 Py_INCREF(Py_None); resultobj = Py_None;
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31050 PyObject *resultobj;
31051 wxWindow *arg1 = (wxWindow *) 0 ;
31052 int arg2 ;
31053 bool result;
31054 PyObject * obj0 = 0 ;
31055 PyObject * obj1 = 0 ;
31056 char *kwnames[] = {
31057 (char *) "self",(char *) "orient", NULL
31058 };
31059
31060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31062 if (SWIG_arg_fail(1)) SWIG_fail;
31063 {
31064 arg2 = (int)(SWIG_As_int(obj1));
31065 if (SWIG_arg_fail(2)) SWIG_fail;
31066 }
31067 {
31068 PyThreadState* __tstate = wxPyBeginAllowThreads();
31069 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31070
31071 wxPyEndAllowThreads(__tstate);
31072 if (PyErr_Occurred()) SWIG_fail;
31073 }
31074 {
31075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31076 }
31077 return resultobj;
31078 fail:
31079 return NULL;
31080 }
31081
31082
31083 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31084 PyObject *resultobj;
31085 wxWindow *arg1 = (wxWindow *) 0 ;
31086 int arg2 ;
31087 int arg3 ;
31088 int arg4 ;
31089 int arg5 ;
31090 bool arg6 = (bool) true ;
31091 PyObject * obj0 = 0 ;
31092 PyObject * obj1 = 0 ;
31093 PyObject * obj2 = 0 ;
31094 PyObject * obj3 = 0 ;
31095 PyObject * obj4 = 0 ;
31096 PyObject * obj5 = 0 ;
31097 char *kwnames[] = {
31098 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31099 };
31100
31101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31103 if (SWIG_arg_fail(1)) SWIG_fail;
31104 {
31105 arg2 = (int)(SWIG_As_int(obj1));
31106 if (SWIG_arg_fail(2)) SWIG_fail;
31107 }
31108 {
31109 arg3 = (int)(SWIG_As_int(obj2));
31110 if (SWIG_arg_fail(3)) SWIG_fail;
31111 }
31112 {
31113 arg4 = (int)(SWIG_As_int(obj3));
31114 if (SWIG_arg_fail(4)) SWIG_fail;
31115 }
31116 {
31117 arg5 = (int)(SWIG_As_int(obj4));
31118 if (SWIG_arg_fail(5)) SWIG_fail;
31119 }
31120 if (obj5) {
31121 {
31122 arg6 = (bool)(SWIG_As_bool(obj5));
31123 if (SWIG_arg_fail(6)) SWIG_fail;
31124 }
31125 }
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31129
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 Py_INCREF(Py_None); resultobj = Py_None;
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj;
31142 wxWindow *arg1 = (wxWindow *) 0 ;
31143 int arg2 ;
31144 int arg3 ;
31145 bool arg4 = (bool) true ;
31146 PyObject * obj0 = 0 ;
31147 PyObject * obj1 = 0 ;
31148 PyObject * obj2 = 0 ;
31149 PyObject * obj3 = 0 ;
31150 char *kwnames[] = {
31151 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31152 };
31153
31154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31156 if (SWIG_arg_fail(1)) SWIG_fail;
31157 {
31158 arg2 = (int)(SWIG_As_int(obj1));
31159 if (SWIG_arg_fail(2)) SWIG_fail;
31160 }
31161 {
31162 arg3 = (int)(SWIG_As_int(obj2));
31163 if (SWIG_arg_fail(3)) SWIG_fail;
31164 }
31165 if (obj3) {
31166 {
31167 arg4 = (bool)(SWIG_As_bool(obj3));
31168 if (SWIG_arg_fail(4)) SWIG_fail;
31169 }
31170 }
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 (arg1)->SetScrollPos(arg2,arg3,arg4);
31174
31175 wxPyEndAllowThreads(__tstate);
31176 if (PyErr_Occurred()) SWIG_fail;
31177 }
31178 Py_INCREF(Py_None); resultobj = Py_None;
31179 return resultobj;
31180 fail:
31181 return NULL;
31182 }
31183
31184
31185 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31186 PyObject *resultobj;
31187 wxWindow *arg1 = (wxWindow *) 0 ;
31188 int arg2 ;
31189 int result;
31190 PyObject * obj0 = 0 ;
31191 PyObject * obj1 = 0 ;
31192 char *kwnames[] = {
31193 (char *) "self",(char *) "orientation", NULL
31194 };
31195
31196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31198 if (SWIG_arg_fail(1)) SWIG_fail;
31199 {
31200 arg2 = (int)(SWIG_As_int(obj1));
31201 if (SWIG_arg_fail(2)) SWIG_fail;
31202 }
31203 {
31204 PyThreadState* __tstate = wxPyBeginAllowThreads();
31205 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31206
31207 wxPyEndAllowThreads(__tstate);
31208 if (PyErr_Occurred()) SWIG_fail;
31209 }
31210 {
31211 resultobj = SWIG_From_int((int)(result));
31212 }
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31220 PyObject *resultobj;
31221 wxWindow *arg1 = (wxWindow *) 0 ;
31222 int arg2 ;
31223 int result;
31224 PyObject * obj0 = 0 ;
31225 PyObject * obj1 = 0 ;
31226 char *kwnames[] = {
31227 (char *) "self",(char *) "orientation", NULL
31228 };
31229
31230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31232 if (SWIG_arg_fail(1)) SWIG_fail;
31233 {
31234 arg2 = (int)(SWIG_As_int(obj1));
31235 if (SWIG_arg_fail(2)) SWIG_fail;
31236 }
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31240
31241 wxPyEndAllowThreads(__tstate);
31242 if (PyErr_Occurred()) SWIG_fail;
31243 }
31244 {
31245 resultobj = SWIG_From_int((int)(result));
31246 }
31247 return resultobj;
31248 fail:
31249 return NULL;
31250 }
31251
31252
31253 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31254 PyObject *resultobj;
31255 wxWindow *arg1 = (wxWindow *) 0 ;
31256 int arg2 ;
31257 int result;
31258 PyObject * obj0 = 0 ;
31259 PyObject * obj1 = 0 ;
31260 char *kwnames[] = {
31261 (char *) "self",(char *) "orientation", NULL
31262 };
31263
31264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31266 if (SWIG_arg_fail(1)) SWIG_fail;
31267 {
31268 arg2 = (int)(SWIG_As_int(obj1));
31269 if (SWIG_arg_fail(2)) SWIG_fail;
31270 }
31271 {
31272 PyThreadState* __tstate = wxPyBeginAllowThreads();
31273 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31274
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 {
31279 resultobj = SWIG_From_int((int)(result));
31280 }
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31288 PyObject *resultobj;
31289 wxWindow *arg1 = (wxWindow *) 0 ;
31290 int arg2 ;
31291 int arg3 ;
31292 wxRect *arg4 = (wxRect *) NULL ;
31293 PyObject * obj0 = 0 ;
31294 PyObject * obj1 = 0 ;
31295 PyObject * obj2 = 0 ;
31296 PyObject * obj3 = 0 ;
31297 char *kwnames[] = {
31298 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31299 };
31300
31301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31303 if (SWIG_arg_fail(1)) SWIG_fail;
31304 {
31305 arg2 = (int)(SWIG_As_int(obj1));
31306 if (SWIG_arg_fail(2)) SWIG_fail;
31307 }
31308 {
31309 arg3 = (int)(SWIG_As_int(obj2));
31310 if (SWIG_arg_fail(3)) SWIG_fail;
31311 }
31312 if (obj3) {
31313 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31314 if (SWIG_arg_fail(4)) SWIG_fail;
31315 }
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31319
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 Py_INCREF(Py_None); resultobj = Py_None;
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31331 PyObject *resultobj;
31332 wxWindow *arg1 = (wxWindow *) 0 ;
31333 int arg2 ;
31334 bool result;
31335 PyObject * obj0 = 0 ;
31336 PyObject * obj1 = 0 ;
31337 char *kwnames[] = {
31338 (char *) "self",(char *) "lines", NULL
31339 };
31340
31341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31343 if (SWIG_arg_fail(1)) SWIG_fail;
31344 {
31345 arg2 = (int)(SWIG_As_int(obj1));
31346 if (SWIG_arg_fail(2)) SWIG_fail;
31347 }
31348 {
31349 PyThreadState* __tstate = wxPyBeginAllowThreads();
31350 result = (bool)(arg1)->ScrollLines(arg2);
31351
31352 wxPyEndAllowThreads(__tstate);
31353 if (PyErr_Occurred()) SWIG_fail;
31354 }
31355 {
31356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31357 }
31358 return resultobj;
31359 fail:
31360 return NULL;
31361 }
31362
31363
31364 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31365 PyObject *resultobj;
31366 wxWindow *arg1 = (wxWindow *) 0 ;
31367 int arg2 ;
31368 bool result;
31369 PyObject * obj0 = 0 ;
31370 PyObject * obj1 = 0 ;
31371 char *kwnames[] = {
31372 (char *) "self",(char *) "pages", NULL
31373 };
31374
31375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31377 if (SWIG_arg_fail(1)) SWIG_fail;
31378 {
31379 arg2 = (int)(SWIG_As_int(obj1));
31380 if (SWIG_arg_fail(2)) SWIG_fail;
31381 }
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 result = (bool)(arg1)->ScrollPages(arg2);
31385
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 {
31390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31391 }
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31399 PyObject *resultobj;
31400 wxWindow *arg1 = (wxWindow *) 0 ;
31401 bool result;
31402 PyObject * obj0 = 0 ;
31403 char *kwnames[] = {
31404 (char *) "self", NULL
31405 };
31406
31407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31409 if (SWIG_arg_fail(1)) SWIG_fail;
31410 {
31411 PyThreadState* __tstate = wxPyBeginAllowThreads();
31412 result = (bool)(arg1)->LineUp();
31413
31414 wxPyEndAllowThreads(__tstate);
31415 if (PyErr_Occurred()) SWIG_fail;
31416 }
31417 {
31418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31419 }
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31427 PyObject *resultobj;
31428 wxWindow *arg1 = (wxWindow *) 0 ;
31429 bool result;
31430 PyObject * obj0 = 0 ;
31431 char *kwnames[] = {
31432 (char *) "self", NULL
31433 };
31434
31435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31437 if (SWIG_arg_fail(1)) SWIG_fail;
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 result = (bool)(arg1)->LineDown();
31441
31442 wxPyEndAllowThreads(__tstate);
31443 if (PyErr_Occurred()) SWIG_fail;
31444 }
31445 {
31446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31447 }
31448 return resultobj;
31449 fail:
31450 return NULL;
31451 }
31452
31453
31454 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31455 PyObject *resultobj;
31456 wxWindow *arg1 = (wxWindow *) 0 ;
31457 bool result;
31458 PyObject * obj0 = 0 ;
31459 char *kwnames[] = {
31460 (char *) "self", NULL
31461 };
31462
31463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31465 if (SWIG_arg_fail(1)) SWIG_fail;
31466 {
31467 PyThreadState* __tstate = wxPyBeginAllowThreads();
31468 result = (bool)(arg1)->PageUp();
31469
31470 wxPyEndAllowThreads(__tstate);
31471 if (PyErr_Occurred()) SWIG_fail;
31472 }
31473 {
31474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31475 }
31476 return resultobj;
31477 fail:
31478 return NULL;
31479 }
31480
31481
31482 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31483 PyObject *resultobj;
31484 wxWindow *arg1 = (wxWindow *) 0 ;
31485 bool result;
31486 PyObject * obj0 = 0 ;
31487 char *kwnames[] = {
31488 (char *) "self", NULL
31489 };
31490
31491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31493 if (SWIG_arg_fail(1)) SWIG_fail;
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 result = (bool)(arg1)->PageDown();
31497
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 {
31502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31503 }
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31511 PyObject *resultobj;
31512 wxWindow *arg1 = (wxWindow *) 0 ;
31513 wxString *arg2 = 0 ;
31514 bool temp2 = false ;
31515 PyObject * obj0 = 0 ;
31516 PyObject * obj1 = 0 ;
31517 char *kwnames[] = {
31518 (char *) "self",(char *) "text", NULL
31519 };
31520
31521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31523 if (SWIG_arg_fail(1)) SWIG_fail;
31524 {
31525 arg2 = wxString_in_helper(obj1);
31526 if (arg2 == NULL) SWIG_fail;
31527 temp2 = true;
31528 }
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 (arg1)->SetHelpText((wxString const &)*arg2);
31532
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 Py_INCREF(Py_None); resultobj = Py_None;
31537 {
31538 if (temp2)
31539 delete arg2;
31540 }
31541 return resultobj;
31542 fail:
31543 {
31544 if (temp2)
31545 delete arg2;
31546 }
31547 return NULL;
31548 }
31549
31550
31551 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31552 PyObject *resultobj;
31553 wxWindow *arg1 = (wxWindow *) 0 ;
31554 wxString *arg2 = 0 ;
31555 bool temp2 = false ;
31556 PyObject * obj0 = 0 ;
31557 PyObject * obj1 = 0 ;
31558 char *kwnames[] = {
31559 (char *) "self",(char *) "text", NULL
31560 };
31561
31562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31564 if (SWIG_arg_fail(1)) SWIG_fail;
31565 {
31566 arg2 = wxString_in_helper(obj1);
31567 if (arg2 == NULL) SWIG_fail;
31568 temp2 = true;
31569 }
31570 {
31571 PyThreadState* __tstate = wxPyBeginAllowThreads();
31572 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31573
31574 wxPyEndAllowThreads(__tstate);
31575 if (PyErr_Occurred()) SWIG_fail;
31576 }
31577 Py_INCREF(Py_None); resultobj = Py_None;
31578 {
31579 if (temp2)
31580 delete arg2;
31581 }
31582 return resultobj;
31583 fail:
31584 {
31585 if (temp2)
31586 delete arg2;
31587 }
31588 return NULL;
31589 }
31590
31591
31592 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31593 PyObject *resultobj;
31594 wxWindow *arg1 = (wxWindow *) 0 ;
31595 wxString result;
31596 PyObject * obj0 = 0 ;
31597 char *kwnames[] = {
31598 (char *) "self", NULL
31599 };
31600
31601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31603 if (SWIG_arg_fail(1)) SWIG_fail;
31604 {
31605 PyThreadState* __tstate = wxPyBeginAllowThreads();
31606 result = ((wxWindow const *)arg1)->GetHelpText();
31607
31608 wxPyEndAllowThreads(__tstate);
31609 if (PyErr_Occurred()) SWIG_fail;
31610 }
31611 {
31612 #if wxUSE_UNICODE
31613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31614 #else
31615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31616 #endif
31617 }
31618 return resultobj;
31619 fail:
31620 return NULL;
31621 }
31622
31623
31624 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31625 PyObject *resultobj;
31626 wxWindow *arg1 = (wxWindow *) 0 ;
31627 wxString *arg2 = 0 ;
31628 bool temp2 = false ;
31629 PyObject * obj0 = 0 ;
31630 PyObject * obj1 = 0 ;
31631 char *kwnames[] = {
31632 (char *) "self",(char *) "tip", NULL
31633 };
31634
31635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31637 if (SWIG_arg_fail(1)) SWIG_fail;
31638 {
31639 arg2 = wxString_in_helper(obj1);
31640 if (arg2 == NULL) SWIG_fail;
31641 temp2 = true;
31642 }
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 (arg1)->SetToolTip((wxString const &)*arg2);
31646
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 Py_INCREF(Py_None); resultobj = Py_None;
31651 {
31652 if (temp2)
31653 delete arg2;
31654 }
31655 return resultobj;
31656 fail:
31657 {
31658 if (temp2)
31659 delete arg2;
31660 }
31661 return NULL;
31662 }
31663
31664
31665 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31666 PyObject *resultobj;
31667 wxWindow *arg1 = (wxWindow *) 0 ;
31668 wxToolTip *arg2 = (wxToolTip *) 0 ;
31669 PyObject * obj0 = 0 ;
31670 PyObject * obj1 = 0 ;
31671 char *kwnames[] = {
31672 (char *) "self",(char *) "tip", NULL
31673 };
31674
31675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31677 if (SWIG_arg_fail(1)) SWIG_fail;
31678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31679 if (SWIG_arg_fail(2)) SWIG_fail;
31680 {
31681 PyThreadState* __tstate = wxPyBeginAllowThreads();
31682 (arg1)->SetToolTip(arg2);
31683
31684 wxPyEndAllowThreads(__tstate);
31685 if (PyErr_Occurred()) SWIG_fail;
31686 }
31687 Py_INCREF(Py_None); resultobj = Py_None;
31688 return resultobj;
31689 fail:
31690 return NULL;
31691 }
31692
31693
31694 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31695 PyObject *resultobj;
31696 wxWindow *arg1 = (wxWindow *) 0 ;
31697 wxToolTip *result;
31698 PyObject * obj0 = 0 ;
31699 char *kwnames[] = {
31700 (char *) "self", NULL
31701 };
31702
31703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31705 if (SWIG_arg_fail(1)) SWIG_fail;
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31709
31710 wxPyEndAllowThreads(__tstate);
31711 if (PyErr_Occurred()) SWIG_fail;
31712 }
31713 {
31714 resultobj = wxPyMake_wxObject(result, 0);
31715 }
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31723 PyObject *resultobj;
31724 wxWindow *arg1 = (wxWindow *) 0 ;
31725 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31726 PyObject * obj0 = 0 ;
31727 PyObject * obj1 = 0 ;
31728 char *kwnames[] = {
31729 (char *) "self",(char *) "dropTarget", NULL
31730 };
31731
31732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31734 if (SWIG_arg_fail(1)) SWIG_fail;
31735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31736 if (SWIG_arg_fail(2)) SWIG_fail;
31737 {
31738 PyThreadState* __tstate = wxPyBeginAllowThreads();
31739 (arg1)->SetDropTarget(arg2);
31740
31741 wxPyEndAllowThreads(__tstate);
31742 if (PyErr_Occurred()) SWIG_fail;
31743 }
31744 Py_INCREF(Py_None); resultobj = Py_None;
31745 return resultobj;
31746 fail:
31747 return NULL;
31748 }
31749
31750
31751 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31752 PyObject *resultobj;
31753 wxWindow *arg1 = (wxWindow *) 0 ;
31754 wxPyDropTarget *result;
31755 PyObject * obj0 = 0 ;
31756 char *kwnames[] = {
31757 (char *) "self", NULL
31758 };
31759
31760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31762 if (SWIG_arg_fail(1)) SWIG_fail;
31763 {
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31766
31767 wxPyEndAllowThreads(__tstate);
31768 if (PyErr_Occurred()) SWIG_fail;
31769 }
31770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31771 return resultobj;
31772 fail:
31773 return NULL;
31774 }
31775
31776
31777 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31778 PyObject *resultobj;
31779 wxWindow *arg1 = (wxWindow *) 0 ;
31780 bool arg2 ;
31781 PyObject * obj0 = 0 ;
31782 PyObject * obj1 = 0 ;
31783 char *kwnames[] = {
31784 (char *) "self",(char *) "accept", NULL
31785 };
31786
31787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31789 if (SWIG_arg_fail(1)) SWIG_fail;
31790 {
31791 arg2 = (bool)(SWIG_As_bool(obj1));
31792 if (SWIG_arg_fail(2)) SWIG_fail;
31793 }
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 wxWindow_DragAcceptFiles(arg1,arg2);
31797
31798 wxPyEndAllowThreads(__tstate);
31799 if (PyErr_Occurred()) SWIG_fail;
31800 }
31801 Py_INCREF(Py_None); resultobj = Py_None;
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31809 PyObject *resultobj;
31810 wxWindow *arg1 = (wxWindow *) 0 ;
31811 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31812 PyObject * obj0 = 0 ;
31813 PyObject * obj1 = 0 ;
31814 char *kwnames[] = {
31815 (char *) "self",(char *) "constraints", NULL
31816 };
31817
31818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31820 if (SWIG_arg_fail(1)) SWIG_fail;
31821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31822 if (SWIG_arg_fail(2)) SWIG_fail;
31823 {
31824 PyThreadState* __tstate = wxPyBeginAllowThreads();
31825 (arg1)->SetConstraints(arg2);
31826
31827 wxPyEndAllowThreads(__tstate);
31828 if (PyErr_Occurred()) SWIG_fail;
31829 }
31830 Py_INCREF(Py_None); resultobj = Py_None;
31831 return resultobj;
31832 fail:
31833 return NULL;
31834 }
31835
31836
31837 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31838 PyObject *resultobj;
31839 wxWindow *arg1 = (wxWindow *) 0 ;
31840 wxLayoutConstraints *result;
31841 PyObject * obj0 = 0 ;
31842 char *kwnames[] = {
31843 (char *) "self", NULL
31844 };
31845
31846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31848 if (SWIG_arg_fail(1)) SWIG_fail;
31849 {
31850 PyThreadState* __tstate = wxPyBeginAllowThreads();
31851 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31852
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 bool arg2 ;
31867 PyObject * obj0 = 0 ;
31868 PyObject * obj1 = 0 ;
31869 char *kwnames[] = {
31870 (char *) "self",(char *) "autoLayout", NULL
31871 };
31872
31873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31875 if (SWIG_arg_fail(1)) SWIG_fail;
31876 {
31877 arg2 = (bool)(SWIG_As_bool(obj1));
31878 if (SWIG_arg_fail(2)) SWIG_fail;
31879 }
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 (arg1)->SetAutoLayout(arg2);
31883
31884 wxPyEndAllowThreads(__tstate);
31885 if (PyErr_Occurred()) SWIG_fail;
31886 }
31887 Py_INCREF(Py_None); resultobj = Py_None;
31888 return resultobj;
31889 fail:
31890 return NULL;
31891 }
31892
31893
31894 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31895 PyObject *resultobj;
31896 wxWindow *arg1 = (wxWindow *) 0 ;
31897 bool result;
31898 PyObject * obj0 = 0 ;
31899 char *kwnames[] = {
31900 (char *) "self", NULL
31901 };
31902
31903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31905 if (SWIG_arg_fail(1)) SWIG_fail;
31906 {
31907 PyThreadState* __tstate = wxPyBeginAllowThreads();
31908 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31909
31910 wxPyEndAllowThreads(__tstate);
31911 if (PyErr_Occurred()) SWIG_fail;
31912 }
31913 {
31914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31915 }
31916 return resultobj;
31917 fail:
31918 return NULL;
31919 }
31920
31921
31922 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31923 PyObject *resultobj;
31924 wxWindow *arg1 = (wxWindow *) 0 ;
31925 bool result;
31926 PyObject * obj0 = 0 ;
31927 char *kwnames[] = {
31928 (char *) "self", NULL
31929 };
31930
31931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31933 if (SWIG_arg_fail(1)) SWIG_fail;
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 result = (bool)(arg1)->Layout();
31937
31938 wxPyEndAllowThreads(__tstate);
31939 if (PyErr_Occurred()) SWIG_fail;
31940 }
31941 {
31942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31943 }
31944 return resultobj;
31945 fail:
31946 return NULL;
31947 }
31948
31949
31950 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31951 PyObject *resultobj;
31952 wxWindow *arg1 = (wxWindow *) 0 ;
31953 wxSizer *arg2 = (wxSizer *) 0 ;
31954 bool arg3 = (bool) true ;
31955 PyObject * obj0 = 0 ;
31956 PyObject * obj1 = 0 ;
31957 PyObject * obj2 = 0 ;
31958 char *kwnames[] = {
31959 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31960 };
31961
31962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31964 if (SWIG_arg_fail(1)) SWIG_fail;
31965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31966 if (SWIG_arg_fail(2)) SWIG_fail;
31967 if (obj2) {
31968 {
31969 arg3 = (bool)(SWIG_As_bool(obj2));
31970 if (SWIG_arg_fail(3)) SWIG_fail;
31971 }
31972 }
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 (arg1)->SetSizer(arg2,arg3);
31976
31977 wxPyEndAllowThreads(__tstate);
31978 if (PyErr_Occurred()) SWIG_fail;
31979 }
31980 Py_INCREF(Py_None); resultobj = Py_None;
31981 return resultobj;
31982 fail:
31983 return NULL;
31984 }
31985
31986
31987 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31988 PyObject *resultobj;
31989 wxWindow *arg1 = (wxWindow *) 0 ;
31990 wxSizer *arg2 = (wxSizer *) 0 ;
31991 bool arg3 = (bool) true ;
31992 PyObject * obj0 = 0 ;
31993 PyObject * obj1 = 0 ;
31994 PyObject * obj2 = 0 ;
31995 char *kwnames[] = {
31996 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31997 };
31998
31999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32001 if (SWIG_arg_fail(1)) SWIG_fail;
32002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32003 if (SWIG_arg_fail(2)) SWIG_fail;
32004 if (obj2) {
32005 {
32006 arg3 = (bool)(SWIG_As_bool(obj2));
32007 if (SWIG_arg_fail(3)) SWIG_fail;
32008 }
32009 }
32010 {
32011 PyThreadState* __tstate = wxPyBeginAllowThreads();
32012 (arg1)->SetSizerAndFit(arg2,arg3);
32013
32014 wxPyEndAllowThreads(__tstate);
32015 if (PyErr_Occurred()) SWIG_fail;
32016 }
32017 Py_INCREF(Py_None); resultobj = Py_None;
32018 return resultobj;
32019 fail:
32020 return NULL;
32021 }
32022
32023
32024 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32025 PyObject *resultobj;
32026 wxWindow *arg1 = (wxWindow *) 0 ;
32027 wxSizer *result;
32028 PyObject * obj0 = 0 ;
32029 char *kwnames[] = {
32030 (char *) "self", NULL
32031 };
32032
32033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32035 if (SWIG_arg_fail(1)) SWIG_fail;
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32039
32040 wxPyEndAllowThreads(__tstate);
32041 if (PyErr_Occurred()) SWIG_fail;
32042 }
32043 {
32044 resultobj = wxPyMake_wxObject(result, 0);
32045 }
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32053 PyObject *resultobj;
32054 wxWindow *arg1 = (wxWindow *) 0 ;
32055 wxSizer *arg2 = (wxSizer *) 0 ;
32056 PyObject * obj0 = 0 ;
32057 PyObject * obj1 = 0 ;
32058 char *kwnames[] = {
32059 (char *) "self",(char *) "sizer", NULL
32060 };
32061
32062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32064 if (SWIG_arg_fail(1)) SWIG_fail;
32065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32066 if (SWIG_arg_fail(2)) SWIG_fail;
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 (arg1)->SetContainingSizer(arg2);
32070
32071 wxPyEndAllowThreads(__tstate);
32072 if (PyErr_Occurred()) SWIG_fail;
32073 }
32074 Py_INCREF(Py_None); resultobj = Py_None;
32075 return resultobj;
32076 fail:
32077 return NULL;
32078 }
32079
32080
32081 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32082 PyObject *resultobj;
32083 wxWindow *arg1 = (wxWindow *) 0 ;
32084 wxSizer *result;
32085 PyObject * obj0 = 0 ;
32086 char *kwnames[] = {
32087 (char *) "self", NULL
32088 };
32089
32090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32092 if (SWIG_arg_fail(1)) SWIG_fail;
32093 {
32094 PyThreadState* __tstate = wxPyBeginAllowThreads();
32095 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32096
32097 wxPyEndAllowThreads(__tstate);
32098 if (PyErr_Occurred()) SWIG_fail;
32099 }
32100 {
32101 resultobj = wxPyMake_wxObject(result, 0);
32102 }
32103 return resultobj;
32104 fail:
32105 return NULL;
32106 }
32107
32108
32109 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32110 PyObject *resultobj;
32111 wxWindow *arg1 = (wxWindow *) 0 ;
32112 PyObject * obj0 = 0 ;
32113 char *kwnames[] = {
32114 (char *) "self", NULL
32115 };
32116
32117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32119 if (SWIG_arg_fail(1)) SWIG_fail;
32120 {
32121 PyThreadState* __tstate = wxPyBeginAllowThreads();
32122 (arg1)->InheritAttributes();
32123
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 Py_INCREF(Py_None); resultobj = Py_None;
32128 return resultobj;
32129 fail:
32130 return NULL;
32131 }
32132
32133
32134 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32135 PyObject *resultobj;
32136 wxWindow *arg1 = (wxWindow *) 0 ;
32137 bool result;
32138 PyObject * obj0 = 0 ;
32139 char *kwnames[] = {
32140 (char *) "self", NULL
32141 };
32142
32143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32145 if (SWIG_arg_fail(1)) SWIG_fail;
32146 {
32147 PyThreadState* __tstate = wxPyBeginAllowThreads();
32148 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32149
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 {
32154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32155 }
32156 return resultobj;
32157 fail:
32158 return NULL;
32159 }
32160
32161
32162 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32163 PyObject *obj;
32164 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32165 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32166 Py_INCREF(obj);
32167 return Py_BuildValue((char *)"");
32168 }
32169 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32170 PyObject *resultobj;
32171 long arg1 ;
32172 wxWindow *arg2 = (wxWindow *) NULL ;
32173 wxWindow *result;
32174 PyObject * obj0 = 0 ;
32175 PyObject * obj1 = 0 ;
32176 char *kwnames[] = {
32177 (char *) "id",(char *) "parent", NULL
32178 };
32179
32180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32181 {
32182 arg1 = (long)(SWIG_As_long(obj0));
32183 if (SWIG_arg_fail(1)) SWIG_fail;
32184 }
32185 if (obj1) {
32186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32187 if (SWIG_arg_fail(2)) SWIG_fail;
32188 }
32189 {
32190 if (!wxPyCheckForApp()) SWIG_fail;
32191 PyThreadState* __tstate = wxPyBeginAllowThreads();
32192 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32193
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 {
32198 resultobj = wxPyMake_wxObject(result, 0);
32199 }
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32207 PyObject *resultobj;
32208 wxString *arg1 = 0 ;
32209 wxWindow *arg2 = (wxWindow *) NULL ;
32210 wxWindow *result;
32211 bool temp1 = false ;
32212 PyObject * obj0 = 0 ;
32213 PyObject * obj1 = 0 ;
32214 char *kwnames[] = {
32215 (char *) "name",(char *) "parent", NULL
32216 };
32217
32218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32219 {
32220 arg1 = wxString_in_helper(obj0);
32221 if (arg1 == NULL) SWIG_fail;
32222 temp1 = true;
32223 }
32224 if (obj1) {
32225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32226 if (SWIG_arg_fail(2)) SWIG_fail;
32227 }
32228 {
32229 if (!wxPyCheckForApp()) SWIG_fail;
32230 PyThreadState* __tstate = wxPyBeginAllowThreads();
32231 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32232
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 {
32237 resultobj = wxPyMake_wxObject(result, 0);
32238 }
32239 {
32240 if (temp1)
32241 delete arg1;
32242 }
32243 return resultobj;
32244 fail:
32245 {
32246 if (temp1)
32247 delete arg1;
32248 }
32249 return NULL;
32250 }
32251
32252
32253 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32254 PyObject *resultobj;
32255 wxString *arg1 = 0 ;
32256 wxWindow *arg2 = (wxWindow *) NULL ;
32257 wxWindow *result;
32258 bool temp1 = false ;
32259 PyObject * obj0 = 0 ;
32260 PyObject * obj1 = 0 ;
32261 char *kwnames[] = {
32262 (char *) "label",(char *) "parent", NULL
32263 };
32264
32265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32266 {
32267 arg1 = wxString_in_helper(obj0);
32268 if (arg1 == NULL) SWIG_fail;
32269 temp1 = true;
32270 }
32271 if (obj1) {
32272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32273 if (SWIG_arg_fail(2)) SWIG_fail;
32274 }
32275 {
32276 if (!wxPyCheckForApp()) SWIG_fail;
32277 PyThreadState* __tstate = wxPyBeginAllowThreads();
32278 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32279
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 resultobj = wxPyMake_wxObject(result, 0);
32285 }
32286 {
32287 if (temp1)
32288 delete arg1;
32289 }
32290 return resultobj;
32291 fail:
32292 {
32293 if (temp1)
32294 delete arg1;
32295 }
32296 return NULL;
32297 }
32298
32299
32300 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32301 PyObject *resultobj;
32302 wxWindow *arg1 = (wxWindow *) 0 ;
32303 unsigned long arg2 ;
32304 wxWindow *result;
32305 PyObject * obj0 = 0 ;
32306 PyObject * obj1 = 0 ;
32307 char *kwnames[] = {
32308 (char *) "parent",(char *) "_hWnd", NULL
32309 };
32310
32311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32313 if (SWIG_arg_fail(1)) SWIG_fail;
32314 {
32315 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32316 if (SWIG_arg_fail(2)) SWIG_fail;
32317 }
32318 {
32319 PyThreadState* __tstate = wxPyBeginAllowThreads();
32320 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32321
32322 wxPyEndAllowThreads(__tstate);
32323 if (PyErr_Occurred()) SWIG_fail;
32324 }
32325 {
32326 resultobj = wxPyMake_wxObject(result, 0);
32327 }
32328 return resultobj;
32329 fail:
32330 return NULL;
32331 }
32332
32333
32334 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32335 PyObject *resultobj;
32336 PyObject *result;
32337 char *kwnames[] = {
32338 NULL
32339 };
32340
32341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32342 {
32343 PyThreadState* __tstate = wxPyBeginAllowThreads();
32344 result = (PyObject *)GetTopLevelWindows();
32345
32346 wxPyEndAllowThreads(__tstate);
32347 if (PyErr_Occurred()) SWIG_fail;
32348 }
32349 resultobj = result;
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj;
32358 wxValidator *result;
32359 char *kwnames[] = {
32360 NULL
32361 };
32362
32363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 result = (wxValidator *)new wxValidator();
32367
32368 wxPyEndAllowThreads(__tstate);
32369 if (PyErr_Occurred()) SWIG_fail;
32370 }
32371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32372 return resultobj;
32373 fail:
32374 return NULL;
32375 }
32376
32377
32378 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32379 PyObject *resultobj;
32380 wxValidator *arg1 = (wxValidator *) 0 ;
32381 wxValidator *result;
32382 PyObject * obj0 = 0 ;
32383 char *kwnames[] = {
32384 (char *) "self", NULL
32385 };
32386
32387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32389 if (SWIG_arg_fail(1)) SWIG_fail;
32390 {
32391 PyThreadState* __tstate = wxPyBeginAllowThreads();
32392 result = (wxValidator *)(arg1)->Clone();
32393
32394 wxPyEndAllowThreads(__tstate);
32395 if (PyErr_Occurred()) SWIG_fail;
32396 }
32397 {
32398 resultobj = wxPyMake_wxObject(result, 0);
32399 }
32400 return resultobj;
32401 fail:
32402 return NULL;
32403 }
32404
32405
32406 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32407 PyObject *resultobj;
32408 wxValidator *arg1 = (wxValidator *) 0 ;
32409 wxWindow *arg2 = (wxWindow *) 0 ;
32410 bool result;
32411 PyObject * obj0 = 0 ;
32412 PyObject * obj1 = 0 ;
32413 char *kwnames[] = {
32414 (char *) "self",(char *) "parent", NULL
32415 };
32416
32417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32419 if (SWIG_arg_fail(1)) SWIG_fail;
32420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32421 if (SWIG_arg_fail(2)) SWIG_fail;
32422 {
32423 PyThreadState* __tstate = wxPyBeginAllowThreads();
32424 result = (bool)(arg1)->Validate(arg2);
32425
32426 wxPyEndAllowThreads(__tstate);
32427 if (PyErr_Occurred()) SWIG_fail;
32428 }
32429 {
32430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32431 }
32432 return resultobj;
32433 fail:
32434 return NULL;
32435 }
32436
32437
32438 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32439 PyObject *resultobj;
32440 wxValidator *arg1 = (wxValidator *) 0 ;
32441 bool result;
32442 PyObject * obj0 = 0 ;
32443 char *kwnames[] = {
32444 (char *) "self", NULL
32445 };
32446
32447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32449 if (SWIG_arg_fail(1)) SWIG_fail;
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 result = (bool)(arg1)->TransferToWindow();
32453
32454 wxPyEndAllowThreads(__tstate);
32455 if (PyErr_Occurred()) SWIG_fail;
32456 }
32457 {
32458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32459 }
32460 return resultobj;
32461 fail:
32462 return NULL;
32463 }
32464
32465
32466 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32467 PyObject *resultobj;
32468 wxValidator *arg1 = (wxValidator *) 0 ;
32469 bool result;
32470 PyObject * obj0 = 0 ;
32471 char *kwnames[] = {
32472 (char *) "self", NULL
32473 };
32474
32475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32477 if (SWIG_arg_fail(1)) SWIG_fail;
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 result = (bool)(arg1)->TransferFromWindow();
32481
32482 wxPyEndAllowThreads(__tstate);
32483 if (PyErr_Occurred()) SWIG_fail;
32484 }
32485 {
32486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32487 }
32488 return resultobj;
32489 fail:
32490 return NULL;
32491 }
32492
32493
32494 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32495 PyObject *resultobj;
32496 wxValidator *arg1 = (wxValidator *) 0 ;
32497 wxWindow *result;
32498 PyObject * obj0 = 0 ;
32499 char *kwnames[] = {
32500 (char *) "self", NULL
32501 };
32502
32503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32505 if (SWIG_arg_fail(1)) SWIG_fail;
32506 {
32507 PyThreadState* __tstate = wxPyBeginAllowThreads();
32508 result = (wxWindow *)(arg1)->GetWindow();
32509
32510 wxPyEndAllowThreads(__tstate);
32511 if (PyErr_Occurred()) SWIG_fail;
32512 }
32513 {
32514 resultobj = wxPyMake_wxObject(result, 0);
32515 }
32516 return resultobj;
32517 fail:
32518 return NULL;
32519 }
32520
32521
32522 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32523 PyObject *resultobj;
32524 wxValidator *arg1 = (wxValidator *) 0 ;
32525 wxWindow *arg2 = (wxWindow *) 0 ;
32526 PyObject * obj0 = 0 ;
32527 PyObject * obj1 = 0 ;
32528 char *kwnames[] = {
32529 (char *) "self",(char *) "window", NULL
32530 };
32531
32532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32534 if (SWIG_arg_fail(1)) SWIG_fail;
32535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32536 if (SWIG_arg_fail(2)) SWIG_fail;
32537 {
32538 PyThreadState* __tstate = wxPyBeginAllowThreads();
32539 (arg1)->SetWindow(arg2);
32540
32541 wxPyEndAllowThreads(__tstate);
32542 if (PyErr_Occurred()) SWIG_fail;
32543 }
32544 Py_INCREF(Py_None); resultobj = Py_None;
32545 return resultobj;
32546 fail:
32547 return NULL;
32548 }
32549
32550
32551 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32552 PyObject *resultobj;
32553 bool result;
32554 char *kwnames[] = {
32555 NULL
32556 };
32557
32558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32559 {
32560 PyThreadState* __tstate = wxPyBeginAllowThreads();
32561 result = (bool)wxValidator::IsSilent();
32562
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 {
32567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32568 }
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32576 PyObject *resultobj;
32577 int arg1 = (int) true ;
32578 PyObject * obj0 = 0 ;
32579 char *kwnames[] = {
32580 (char *) "doIt", NULL
32581 };
32582
32583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32584 if (obj0) {
32585 {
32586 arg1 = (int)(SWIG_As_int(obj0));
32587 if (SWIG_arg_fail(1)) SWIG_fail;
32588 }
32589 }
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 wxValidator::SetBellOnError(arg1);
32593
32594 wxPyEndAllowThreads(__tstate);
32595 if (PyErr_Occurred()) SWIG_fail;
32596 }
32597 Py_INCREF(Py_None); resultobj = Py_None;
32598 return resultobj;
32599 fail:
32600 return NULL;
32601 }
32602
32603
32604 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32605 PyObject *obj;
32606 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32607 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32608 Py_INCREF(obj);
32609 return Py_BuildValue((char *)"");
32610 }
32611 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32612 PyObject *resultobj;
32613 wxPyValidator *result;
32614 char *kwnames[] = {
32615 NULL
32616 };
32617
32618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32619 {
32620 PyThreadState* __tstate = wxPyBeginAllowThreads();
32621 result = (wxPyValidator *)new wxPyValidator();
32622
32623 wxPyEndAllowThreads(__tstate);
32624 if (PyErr_Occurred()) SWIG_fail;
32625 }
32626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32627 return resultobj;
32628 fail:
32629 return NULL;
32630 }
32631
32632
32633 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32634 PyObject *resultobj;
32635 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32636 PyObject *arg2 = (PyObject *) 0 ;
32637 PyObject *arg3 = (PyObject *) 0 ;
32638 int arg4 = (int) true ;
32639 PyObject * obj0 = 0 ;
32640 PyObject * obj1 = 0 ;
32641 PyObject * obj2 = 0 ;
32642 PyObject * obj3 = 0 ;
32643 char *kwnames[] = {
32644 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32645 };
32646
32647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32649 if (SWIG_arg_fail(1)) SWIG_fail;
32650 arg2 = obj1;
32651 arg3 = obj2;
32652 if (obj3) {
32653 {
32654 arg4 = (int)(SWIG_As_int(obj3));
32655 if (SWIG_arg_fail(4)) SWIG_fail;
32656 }
32657 }
32658 {
32659 PyThreadState* __tstate = wxPyBeginAllowThreads();
32660 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32661
32662 wxPyEndAllowThreads(__tstate);
32663 if (PyErr_Occurred()) SWIG_fail;
32664 }
32665 Py_INCREF(Py_None); resultobj = Py_None;
32666 return resultobj;
32667 fail:
32668 return NULL;
32669 }
32670
32671
32672 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32673 PyObject *obj;
32674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32675 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32676 Py_INCREF(obj);
32677 return Py_BuildValue((char *)"");
32678 }
32679 static int _wrap_DefaultValidator_set(PyObject *) {
32680 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32681 return 1;
32682 }
32683
32684
32685 static PyObject *_wrap_DefaultValidator_get(void) {
32686 PyObject *pyobj;
32687
32688 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32689 return pyobj;
32690 }
32691
32692
32693 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32694 PyObject *resultobj;
32695 wxString const &arg1_defvalue = wxPyEmptyString ;
32696 wxString *arg1 = (wxString *) &arg1_defvalue ;
32697 long arg2 = (long) 0 ;
32698 wxMenu *result;
32699 bool temp1 = false ;
32700 PyObject * obj0 = 0 ;
32701 PyObject * obj1 = 0 ;
32702 char *kwnames[] = {
32703 (char *) "title",(char *) "style", NULL
32704 };
32705
32706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32707 if (obj0) {
32708 {
32709 arg1 = wxString_in_helper(obj0);
32710 if (arg1 == NULL) SWIG_fail;
32711 temp1 = true;
32712 }
32713 }
32714 if (obj1) {
32715 {
32716 arg2 = (long)(SWIG_As_long(obj1));
32717 if (SWIG_arg_fail(2)) SWIG_fail;
32718 }
32719 }
32720 {
32721 if (!wxPyCheckForApp()) SWIG_fail;
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32724
32725 wxPyEndAllowThreads(__tstate);
32726 if (PyErr_Occurred()) SWIG_fail;
32727 }
32728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32729 {
32730 if (temp1)
32731 delete arg1;
32732 }
32733 return resultobj;
32734 fail:
32735 {
32736 if (temp1)
32737 delete arg1;
32738 }
32739 return NULL;
32740 }
32741
32742
32743 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32744 PyObject *resultobj;
32745 wxMenu *arg1 = (wxMenu *) 0 ;
32746 int arg2 ;
32747 wxString *arg3 = 0 ;
32748 wxString const &arg4_defvalue = wxPyEmptyString ;
32749 wxString *arg4 = (wxString *) &arg4_defvalue ;
32750 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32751 wxMenuItem *result;
32752 bool temp3 = false ;
32753 bool temp4 = false ;
32754 PyObject * obj0 = 0 ;
32755 PyObject * obj1 = 0 ;
32756 PyObject * obj2 = 0 ;
32757 PyObject * obj3 = 0 ;
32758 PyObject * obj4 = 0 ;
32759 char *kwnames[] = {
32760 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32761 };
32762
32763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32765 if (SWIG_arg_fail(1)) SWIG_fail;
32766 {
32767 arg2 = (int)(SWIG_As_int(obj1));
32768 if (SWIG_arg_fail(2)) SWIG_fail;
32769 }
32770 {
32771 arg3 = wxString_in_helper(obj2);
32772 if (arg3 == NULL) SWIG_fail;
32773 temp3 = true;
32774 }
32775 if (obj3) {
32776 {
32777 arg4 = wxString_in_helper(obj3);
32778 if (arg4 == NULL) SWIG_fail;
32779 temp4 = true;
32780 }
32781 }
32782 if (obj4) {
32783 {
32784 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32785 if (SWIG_arg_fail(5)) SWIG_fail;
32786 }
32787 }
32788 {
32789 PyThreadState* __tstate = wxPyBeginAllowThreads();
32790 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32791
32792 wxPyEndAllowThreads(__tstate);
32793 if (PyErr_Occurred()) SWIG_fail;
32794 }
32795 {
32796 resultobj = wxPyMake_wxObject(result, 0);
32797 }
32798 {
32799 if (temp3)
32800 delete arg3;
32801 }
32802 {
32803 if (temp4)
32804 delete arg4;
32805 }
32806 return resultobj;
32807 fail:
32808 {
32809 if (temp3)
32810 delete arg3;
32811 }
32812 {
32813 if (temp4)
32814 delete arg4;
32815 }
32816 return NULL;
32817 }
32818
32819
32820 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32821 PyObject *resultobj;
32822 wxMenu *arg1 = (wxMenu *) 0 ;
32823 wxMenuItem *result;
32824 PyObject * obj0 = 0 ;
32825 char *kwnames[] = {
32826 (char *) "self", NULL
32827 };
32828
32829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32831 if (SWIG_arg_fail(1)) SWIG_fail;
32832 {
32833 PyThreadState* __tstate = wxPyBeginAllowThreads();
32834 result = (wxMenuItem *)(arg1)->AppendSeparator();
32835
32836 wxPyEndAllowThreads(__tstate);
32837 if (PyErr_Occurred()) SWIG_fail;
32838 }
32839 {
32840 resultobj = wxPyMake_wxObject(result, 0);
32841 }
32842 return resultobj;
32843 fail:
32844 return NULL;
32845 }
32846
32847
32848 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32849 PyObject *resultobj;
32850 wxMenu *arg1 = (wxMenu *) 0 ;
32851 int arg2 ;
32852 wxString *arg3 = 0 ;
32853 wxString const &arg4_defvalue = wxPyEmptyString ;
32854 wxString *arg4 = (wxString *) &arg4_defvalue ;
32855 wxMenuItem *result;
32856 bool temp3 = false ;
32857 bool temp4 = false ;
32858 PyObject * obj0 = 0 ;
32859 PyObject * obj1 = 0 ;
32860 PyObject * obj2 = 0 ;
32861 PyObject * obj3 = 0 ;
32862 char *kwnames[] = {
32863 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32864 };
32865
32866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32868 if (SWIG_arg_fail(1)) SWIG_fail;
32869 {
32870 arg2 = (int)(SWIG_As_int(obj1));
32871 if (SWIG_arg_fail(2)) SWIG_fail;
32872 }
32873 {
32874 arg3 = wxString_in_helper(obj2);
32875 if (arg3 == NULL) SWIG_fail;
32876 temp3 = true;
32877 }
32878 if (obj3) {
32879 {
32880 arg4 = wxString_in_helper(obj3);
32881 if (arg4 == NULL) SWIG_fail;
32882 temp4 = true;
32883 }
32884 }
32885 {
32886 PyThreadState* __tstate = wxPyBeginAllowThreads();
32887 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32888
32889 wxPyEndAllowThreads(__tstate);
32890 if (PyErr_Occurred()) SWIG_fail;
32891 }
32892 {
32893 resultobj = wxPyMake_wxObject(result, 0);
32894 }
32895 {
32896 if (temp3)
32897 delete arg3;
32898 }
32899 {
32900 if (temp4)
32901 delete arg4;
32902 }
32903 return resultobj;
32904 fail:
32905 {
32906 if (temp3)
32907 delete arg3;
32908 }
32909 {
32910 if (temp4)
32911 delete arg4;
32912 }
32913 return NULL;
32914 }
32915
32916
32917 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32918 PyObject *resultobj;
32919 wxMenu *arg1 = (wxMenu *) 0 ;
32920 int arg2 ;
32921 wxString *arg3 = 0 ;
32922 wxString const &arg4_defvalue = wxPyEmptyString ;
32923 wxString *arg4 = (wxString *) &arg4_defvalue ;
32924 wxMenuItem *result;
32925 bool temp3 = false ;
32926 bool temp4 = false ;
32927 PyObject * obj0 = 0 ;
32928 PyObject * obj1 = 0 ;
32929 PyObject * obj2 = 0 ;
32930 PyObject * obj3 = 0 ;
32931 char *kwnames[] = {
32932 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32933 };
32934
32935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32937 if (SWIG_arg_fail(1)) SWIG_fail;
32938 {
32939 arg2 = (int)(SWIG_As_int(obj1));
32940 if (SWIG_arg_fail(2)) SWIG_fail;
32941 }
32942 {
32943 arg3 = wxString_in_helper(obj2);
32944 if (arg3 == NULL) SWIG_fail;
32945 temp3 = true;
32946 }
32947 if (obj3) {
32948 {
32949 arg4 = wxString_in_helper(obj3);
32950 if (arg4 == NULL) SWIG_fail;
32951 temp4 = true;
32952 }
32953 }
32954 {
32955 PyThreadState* __tstate = wxPyBeginAllowThreads();
32956 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32957
32958 wxPyEndAllowThreads(__tstate);
32959 if (PyErr_Occurred()) SWIG_fail;
32960 }
32961 {
32962 resultobj = wxPyMake_wxObject(result, 0);
32963 }
32964 {
32965 if (temp3)
32966 delete arg3;
32967 }
32968 {
32969 if (temp4)
32970 delete arg4;
32971 }
32972 return resultobj;
32973 fail:
32974 {
32975 if (temp3)
32976 delete arg3;
32977 }
32978 {
32979 if (temp4)
32980 delete arg4;
32981 }
32982 return NULL;
32983 }
32984
32985
32986 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32987 PyObject *resultobj;
32988 wxMenu *arg1 = (wxMenu *) 0 ;
32989 int arg2 ;
32990 wxString *arg3 = 0 ;
32991 wxMenu *arg4 = (wxMenu *) 0 ;
32992 wxString const &arg5_defvalue = wxPyEmptyString ;
32993 wxString *arg5 = (wxString *) &arg5_defvalue ;
32994 wxMenuItem *result;
32995 bool temp3 = false ;
32996 bool temp5 = false ;
32997 PyObject * obj0 = 0 ;
32998 PyObject * obj1 = 0 ;
32999 PyObject * obj2 = 0 ;
33000 PyObject * obj3 = 0 ;
33001 PyObject * obj4 = 0 ;
33002 char *kwnames[] = {
33003 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33004 };
33005
33006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33008 if (SWIG_arg_fail(1)) SWIG_fail;
33009 {
33010 arg2 = (int)(SWIG_As_int(obj1));
33011 if (SWIG_arg_fail(2)) SWIG_fail;
33012 }
33013 {
33014 arg3 = wxString_in_helper(obj2);
33015 if (arg3 == NULL) SWIG_fail;
33016 temp3 = true;
33017 }
33018 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33019 if (SWIG_arg_fail(4)) SWIG_fail;
33020 if (obj4) {
33021 {
33022 arg5 = wxString_in_helper(obj4);
33023 if (arg5 == NULL) SWIG_fail;
33024 temp5 = true;
33025 }
33026 }
33027 {
33028 PyThreadState* __tstate = wxPyBeginAllowThreads();
33029 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33030
33031 wxPyEndAllowThreads(__tstate);
33032 if (PyErr_Occurred()) SWIG_fail;
33033 }
33034 {
33035 resultobj = wxPyMake_wxObject(result, 0);
33036 }
33037 {
33038 if (temp3)
33039 delete arg3;
33040 }
33041 {
33042 if (temp5)
33043 delete arg5;
33044 }
33045 return resultobj;
33046 fail:
33047 {
33048 if (temp3)
33049 delete arg3;
33050 }
33051 {
33052 if (temp5)
33053 delete arg5;
33054 }
33055 return NULL;
33056 }
33057
33058
33059 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33060 PyObject *resultobj;
33061 wxMenu *arg1 = (wxMenu *) 0 ;
33062 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33063 wxMenuItem *result;
33064 PyObject * obj0 = 0 ;
33065 PyObject * obj1 = 0 ;
33066 char *kwnames[] = {
33067 (char *) "self",(char *) "item", NULL
33068 };
33069
33070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33072 if (SWIG_arg_fail(1)) SWIG_fail;
33073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33074 if (SWIG_arg_fail(2)) SWIG_fail;
33075 {
33076 PyThreadState* __tstate = wxPyBeginAllowThreads();
33077 result = (wxMenuItem *)(arg1)->Append(arg2);
33078
33079 wxPyEndAllowThreads(__tstate);
33080 if (PyErr_Occurred()) SWIG_fail;
33081 }
33082 {
33083 resultobj = wxPyMake_wxObject(result, 0);
33084 }
33085 return resultobj;
33086 fail:
33087 return NULL;
33088 }
33089
33090
33091 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33092 PyObject *resultobj;
33093 wxMenu *arg1 = (wxMenu *) 0 ;
33094 PyObject * obj0 = 0 ;
33095 char *kwnames[] = {
33096 (char *) "self", NULL
33097 };
33098
33099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33101 if (SWIG_arg_fail(1)) SWIG_fail;
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 (arg1)->Break();
33105
33106 wxPyEndAllowThreads(__tstate);
33107 if (PyErr_Occurred()) SWIG_fail;
33108 }
33109 Py_INCREF(Py_None); resultobj = Py_None;
33110 return resultobj;
33111 fail:
33112 return NULL;
33113 }
33114
33115
33116 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33117 PyObject *resultobj;
33118 wxMenu *arg1 = (wxMenu *) 0 ;
33119 size_t arg2 ;
33120 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33121 wxMenuItem *result;
33122 PyObject * obj0 = 0 ;
33123 PyObject * obj1 = 0 ;
33124 PyObject * obj2 = 0 ;
33125 char *kwnames[] = {
33126 (char *) "self",(char *) "pos",(char *) "item", NULL
33127 };
33128
33129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33131 if (SWIG_arg_fail(1)) SWIG_fail;
33132 {
33133 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33134 if (SWIG_arg_fail(2)) SWIG_fail;
33135 }
33136 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33137 if (SWIG_arg_fail(3)) SWIG_fail;
33138 {
33139 PyThreadState* __tstate = wxPyBeginAllowThreads();
33140 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33141
33142 wxPyEndAllowThreads(__tstate);
33143 if (PyErr_Occurred()) SWIG_fail;
33144 }
33145 {
33146 resultobj = wxPyMake_wxObject(result, 0);
33147 }
33148 return resultobj;
33149 fail:
33150 return NULL;
33151 }
33152
33153
33154 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33155 PyObject *resultobj;
33156 wxMenu *arg1 = (wxMenu *) 0 ;
33157 size_t arg2 ;
33158 int arg3 ;
33159 wxString *arg4 = 0 ;
33160 wxString const &arg5_defvalue = wxPyEmptyString ;
33161 wxString *arg5 = (wxString *) &arg5_defvalue ;
33162 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33163 wxMenuItem *result;
33164 bool temp4 = false ;
33165 bool temp5 = false ;
33166 PyObject * obj0 = 0 ;
33167 PyObject * obj1 = 0 ;
33168 PyObject * obj2 = 0 ;
33169 PyObject * obj3 = 0 ;
33170 PyObject * obj4 = 0 ;
33171 PyObject * obj5 = 0 ;
33172 char *kwnames[] = {
33173 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33174 };
33175
33176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33178 if (SWIG_arg_fail(1)) SWIG_fail;
33179 {
33180 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33181 if (SWIG_arg_fail(2)) SWIG_fail;
33182 }
33183 {
33184 arg3 = (int)(SWIG_As_int(obj2));
33185 if (SWIG_arg_fail(3)) SWIG_fail;
33186 }
33187 {
33188 arg4 = wxString_in_helper(obj3);
33189 if (arg4 == NULL) SWIG_fail;
33190 temp4 = true;
33191 }
33192 if (obj4) {
33193 {
33194 arg5 = wxString_in_helper(obj4);
33195 if (arg5 == NULL) SWIG_fail;
33196 temp5 = true;
33197 }
33198 }
33199 if (obj5) {
33200 {
33201 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33202 if (SWIG_arg_fail(6)) SWIG_fail;
33203 }
33204 }
33205 {
33206 PyThreadState* __tstate = wxPyBeginAllowThreads();
33207 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33208
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 {
33213 resultobj = wxPyMake_wxObject(result, 0);
33214 }
33215 {
33216 if (temp4)
33217 delete arg4;
33218 }
33219 {
33220 if (temp5)
33221 delete arg5;
33222 }
33223 return resultobj;
33224 fail:
33225 {
33226 if (temp4)
33227 delete arg4;
33228 }
33229 {
33230 if (temp5)
33231 delete arg5;
33232 }
33233 return NULL;
33234 }
33235
33236
33237 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33238 PyObject *resultobj;
33239 wxMenu *arg1 = (wxMenu *) 0 ;
33240 size_t arg2 ;
33241 wxMenuItem *result;
33242 PyObject * obj0 = 0 ;
33243 PyObject * obj1 = 0 ;
33244 char *kwnames[] = {
33245 (char *) "self",(char *) "pos", NULL
33246 };
33247
33248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33250 if (SWIG_arg_fail(1)) SWIG_fail;
33251 {
33252 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33253 if (SWIG_arg_fail(2)) SWIG_fail;
33254 }
33255 {
33256 PyThreadState* __tstate = wxPyBeginAllowThreads();
33257 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33258
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 {
33263 resultobj = wxPyMake_wxObject(result, 0);
33264 }
33265 return resultobj;
33266 fail:
33267 return NULL;
33268 }
33269
33270
33271 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33272 PyObject *resultobj;
33273 wxMenu *arg1 = (wxMenu *) 0 ;
33274 size_t arg2 ;
33275 int arg3 ;
33276 wxString *arg4 = 0 ;
33277 wxString const &arg5_defvalue = wxPyEmptyString ;
33278 wxString *arg5 = (wxString *) &arg5_defvalue ;
33279 wxMenuItem *result;
33280 bool temp4 = false ;
33281 bool temp5 = false ;
33282 PyObject * obj0 = 0 ;
33283 PyObject * obj1 = 0 ;
33284 PyObject * obj2 = 0 ;
33285 PyObject * obj3 = 0 ;
33286 PyObject * obj4 = 0 ;
33287 char *kwnames[] = {
33288 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33289 };
33290
33291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33293 if (SWIG_arg_fail(1)) SWIG_fail;
33294 {
33295 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33296 if (SWIG_arg_fail(2)) SWIG_fail;
33297 }
33298 {
33299 arg3 = (int)(SWIG_As_int(obj2));
33300 if (SWIG_arg_fail(3)) SWIG_fail;
33301 }
33302 {
33303 arg4 = wxString_in_helper(obj3);
33304 if (arg4 == NULL) SWIG_fail;
33305 temp4 = true;
33306 }
33307 if (obj4) {
33308 {
33309 arg5 = wxString_in_helper(obj4);
33310 if (arg5 == NULL) SWIG_fail;
33311 temp5 = true;
33312 }
33313 }
33314 {
33315 PyThreadState* __tstate = wxPyBeginAllowThreads();
33316 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33317
33318 wxPyEndAllowThreads(__tstate);
33319 if (PyErr_Occurred()) SWIG_fail;
33320 }
33321 {
33322 resultobj = wxPyMake_wxObject(result, 0);
33323 }
33324 {
33325 if (temp4)
33326 delete arg4;
33327 }
33328 {
33329 if (temp5)
33330 delete arg5;
33331 }
33332 return resultobj;
33333 fail:
33334 {
33335 if (temp4)
33336 delete arg4;
33337 }
33338 {
33339 if (temp5)
33340 delete arg5;
33341 }
33342 return NULL;
33343 }
33344
33345
33346 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33347 PyObject *resultobj;
33348 wxMenu *arg1 = (wxMenu *) 0 ;
33349 size_t arg2 ;
33350 int arg3 ;
33351 wxString *arg4 = 0 ;
33352 wxString const &arg5_defvalue = wxPyEmptyString ;
33353 wxString *arg5 = (wxString *) &arg5_defvalue ;
33354 wxMenuItem *result;
33355 bool temp4 = false ;
33356 bool temp5 = false ;
33357 PyObject * obj0 = 0 ;
33358 PyObject * obj1 = 0 ;
33359 PyObject * obj2 = 0 ;
33360 PyObject * obj3 = 0 ;
33361 PyObject * obj4 = 0 ;
33362 char *kwnames[] = {
33363 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33364 };
33365
33366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33368 if (SWIG_arg_fail(1)) SWIG_fail;
33369 {
33370 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33371 if (SWIG_arg_fail(2)) SWIG_fail;
33372 }
33373 {
33374 arg3 = (int)(SWIG_As_int(obj2));
33375 if (SWIG_arg_fail(3)) SWIG_fail;
33376 }
33377 {
33378 arg4 = wxString_in_helper(obj3);
33379 if (arg4 == NULL) SWIG_fail;
33380 temp4 = true;
33381 }
33382 if (obj4) {
33383 {
33384 arg5 = wxString_in_helper(obj4);
33385 if (arg5 == NULL) SWIG_fail;
33386 temp5 = true;
33387 }
33388 }
33389 {
33390 PyThreadState* __tstate = wxPyBeginAllowThreads();
33391 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33392
33393 wxPyEndAllowThreads(__tstate);
33394 if (PyErr_Occurred()) SWIG_fail;
33395 }
33396 {
33397 resultobj = wxPyMake_wxObject(result, 0);
33398 }
33399 {
33400 if (temp4)
33401 delete arg4;
33402 }
33403 {
33404 if (temp5)
33405 delete arg5;
33406 }
33407 return resultobj;
33408 fail:
33409 {
33410 if (temp4)
33411 delete arg4;
33412 }
33413 {
33414 if (temp5)
33415 delete arg5;
33416 }
33417 return NULL;
33418 }
33419
33420
33421 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33422 PyObject *resultobj;
33423 wxMenu *arg1 = (wxMenu *) 0 ;
33424 size_t arg2 ;
33425 int arg3 ;
33426 wxString *arg4 = 0 ;
33427 wxMenu *arg5 = (wxMenu *) 0 ;
33428 wxString const &arg6_defvalue = wxPyEmptyString ;
33429 wxString *arg6 = (wxString *) &arg6_defvalue ;
33430 wxMenuItem *result;
33431 bool temp4 = false ;
33432 bool temp6 = false ;
33433 PyObject * obj0 = 0 ;
33434 PyObject * obj1 = 0 ;
33435 PyObject * obj2 = 0 ;
33436 PyObject * obj3 = 0 ;
33437 PyObject * obj4 = 0 ;
33438 PyObject * obj5 = 0 ;
33439 char *kwnames[] = {
33440 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33441 };
33442
33443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33445 if (SWIG_arg_fail(1)) SWIG_fail;
33446 {
33447 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33448 if (SWIG_arg_fail(2)) SWIG_fail;
33449 }
33450 {
33451 arg3 = (int)(SWIG_As_int(obj2));
33452 if (SWIG_arg_fail(3)) SWIG_fail;
33453 }
33454 {
33455 arg4 = wxString_in_helper(obj3);
33456 if (arg4 == NULL) SWIG_fail;
33457 temp4 = true;
33458 }
33459 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33460 if (SWIG_arg_fail(5)) SWIG_fail;
33461 if (obj5) {
33462 {
33463 arg6 = wxString_in_helper(obj5);
33464 if (arg6 == NULL) SWIG_fail;
33465 temp6 = true;
33466 }
33467 }
33468 {
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33471
33472 wxPyEndAllowThreads(__tstate);
33473 if (PyErr_Occurred()) SWIG_fail;
33474 }
33475 {
33476 resultobj = wxPyMake_wxObject(result, 0);
33477 }
33478 {
33479 if (temp4)
33480 delete arg4;
33481 }
33482 {
33483 if (temp6)
33484 delete arg6;
33485 }
33486 return resultobj;
33487 fail:
33488 {
33489 if (temp4)
33490 delete arg4;
33491 }
33492 {
33493 if (temp6)
33494 delete arg6;
33495 }
33496 return NULL;
33497 }
33498
33499
33500 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33501 PyObject *resultobj;
33502 wxMenu *arg1 = (wxMenu *) 0 ;
33503 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33504 wxMenuItem *result;
33505 PyObject * obj0 = 0 ;
33506 PyObject * obj1 = 0 ;
33507 char *kwnames[] = {
33508 (char *) "self",(char *) "item", NULL
33509 };
33510
33511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33513 if (SWIG_arg_fail(1)) SWIG_fail;
33514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33515 if (SWIG_arg_fail(2)) SWIG_fail;
33516 {
33517 PyThreadState* __tstate = wxPyBeginAllowThreads();
33518 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33519
33520 wxPyEndAllowThreads(__tstate);
33521 if (PyErr_Occurred()) SWIG_fail;
33522 }
33523 {
33524 resultobj = wxPyMake_wxObject(result, 0);
33525 }
33526 return resultobj;
33527 fail:
33528 return NULL;
33529 }
33530
33531
33532 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33533 PyObject *resultobj;
33534 wxMenu *arg1 = (wxMenu *) 0 ;
33535 int arg2 ;
33536 wxString *arg3 = 0 ;
33537 wxString const &arg4_defvalue = wxPyEmptyString ;
33538 wxString *arg4 = (wxString *) &arg4_defvalue ;
33539 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33540 wxMenuItem *result;
33541 bool temp3 = false ;
33542 bool temp4 = false ;
33543 PyObject * obj0 = 0 ;
33544 PyObject * obj1 = 0 ;
33545 PyObject * obj2 = 0 ;
33546 PyObject * obj3 = 0 ;
33547 PyObject * obj4 = 0 ;
33548 char *kwnames[] = {
33549 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33550 };
33551
33552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33554 if (SWIG_arg_fail(1)) SWIG_fail;
33555 {
33556 arg2 = (int)(SWIG_As_int(obj1));
33557 if (SWIG_arg_fail(2)) SWIG_fail;
33558 }
33559 {
33560 arg3 = wxString_in_helper(obj2);
33561 if (arg3 == NULL) SWIG_fail;
33562 temp3 = true;
33563 }
33564 if (obj3) {
33565 {
33566 arg4 = wxString_in_helper(obj3);
33567 if (arg4 == NULL) SWIG_fail;
33568 temp4 = true;
33569 }
33570 }
33571 if (obj4) {
33572 {
33573 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33574 if (SWIG_arg_fail(5)) SWIG_fail;
33575 }
33576 }
33577 {
33578 PyThreadState* __tstate = wxPyBeginAllowThreads();
33579 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33580
33581 wxPyEndAllowThreads(__tstate);
33582 if (PyErr_Occurred()) SWIG_fail;
33583 }
33584 {
33585 resultobj = wxPyMake_wxObject(result, 0);
33586 }
33587 {
33588 if (temp3)
33589 delete arg3;
33590 }
33591 {
33592 if (temp4)
33593 delete arg4;
33594 }
33595 return resultobj;
33596 fail:
33597 {
33598 if (temp3)
33599 delete arg3;
33600 }
33601 {
33602 if (temp4)
33603 delete arg4;
33604 }
33605 return NULL;
33606 }
33607
33608
33609 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33610 PyObject *resultobj;
33611 wxMenu *arg1 = (wxMenu *) 0 ;
33612 wxMenuItem *result;
33613 PyObject * obj0 = 0 ;
33614 char *kwnames[] = {
33615 (char *) "self", NULL
33616 };
33617
33618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33620 if (SWIG_arg_fail(1)) SWIG_fail;
33621 {
33622 PyThreadState* __tstate = wxPyBeginAllowThreads();
33623 result = (wxMenuItem *)(arg1)->PrependSeparator();
33624
33625 wxPyEndAllowThreads(__tstate);
33626 if (PyErr_Occurred()) SWIG_fail;
33627 }
33628 {
33629 resultobj = wxPyMake_wxObject(result, 0);
33630 }
33631 return resultobj;
33632 fail:
33633 return NULL;
33634 }
33635
33636
33637 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33638 PyObject *resultobj;
33639 wxMenu *arg1 = (wxMenu *) 0 ;
33640 int arg2 ;
33641 wxString *arg3 = 0 ;
33642 wxString const &arg4_defvalue = wxPyEmptyString ;
33643 wxString *arg4 = (wxString *) &arg4_defvalue ;
33644 wxMenuItem *result;
33645 bool temp3 = false ;
33646 bool temp4 = false ;
33647 PyObject * obj0 = 0 ;
33648 PyObject * obj1 = 0 ;
33649 PyObject * obj2 = 0 ;
33650 PyObject * obj3 = 0 ;
33651 char *kwnames[] = {
33652 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33653 };
33654
33655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33657 if (SWIG_arg_fail(1)) SWIG_fail;
33658 {
33659 arg2 = (int)(SWIG_As_int(obj1));
33660 if (SWIG_arg_fail(2)) SWIG_fail;
33661 }
33662 {
33663 arg3 = wxString_in_helper(obj2);
33664 if (arg3 == NULL) SWIG_fail;
33665 temp3 = true;
33666 }
33667 if (obj3) {
33668 {
33669 arg4 = wxString_in_helper(obj3);
33670 if (arg4 == NULL) SWIG_fail;
33671 temp4 = true;
33672 }
33673 }
33674 {
33675 PyThreadState* __tstate = wxPyBeginAllowThreads();
33676 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33677
33678 wxPyEndAllowThreads(__tstate);
33679 if (PyErr_Occurred()) SWIG_fail;
33680 }
33681 {
33682 resultobj = wxPyMake_wxObject(result, 0);
33683 }
33684 {
33685 if (temp3)
33686 delete arg3;
33687 }
33688 {
33689 if (temp4)
33690 delete arg4;
33691 }
33692 return resultobj;
33693 fail:
33694 {
33695 if (temp3)
33696 delete arg3;
33697 }
33698 {
33699 if (temp4)
33700 delete arg4;
33701 }
33702 return NULL;
33703 }
33704
33705
33706 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33707 PyObject *resultobj;
33708 wxMenu *arg1 = (wxMenu *) 0 ;
33709 int arg2 ;
33710 wxString *arg3 = 0 ;
33711 wxString const &arg4_defvalue = wxPyEmptyString ;
33712 wxString *arg4 = (wxString *) &arg4_defvalue ;
33713 wxMenuItem *result;
33714 bool temp3 = false ;
33715 bool temp4 = false ;
33716 PyObject * obj0 = 0 ;
33717 PyObject * obj1 = 0 ;
33718 PyObject * obj2 = 0 ;
33719 PyObject * obj3 = 0 ;
33720 char *kwnames[] = {
33721 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33722 };
33723
33724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33726 if (SWIG_arg_fail(1)) SWIG_fail;
33727 {
33728 arg2 = (int)(SWIG_As_int(obj1));
33729 if (SWIG_arg_fail(2)) SWIG_fail;
33730 }
33731 {
33732 arg3 = wxString_in_helper(obj2);
33733 if (arg3 == NULL) SWIG_fail;
33734 temp3 = true;
33735 }
33736 if (obj3) {
33737 {
33738 arg4 = wxString_in_helper(obj3);
33739 if (arg4 == NULL) SWIG_fail;
33740 temp4 = true;
33741 }
33742 }
33743 {
33744 PyThreadState* __tstate = wxPyBeginAllowThreads();
33745 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33746
33747 wxPyEndAllowThreads(__tstate);
33748 if (PyErr_Occurred()) SWIG_fail;
33749 }
33750 {
33751 resultobj = wxPyMake_wxObject(result, 0);
33752 }
33753 {
33754 if (temp3)
33755 delete arg3;
33756 }
33757 {
33758 if (temp4)
33759 delete arg4;
33760 }
33761 return resultobj;
33762 fail:
33763 {
33764 if (temp3)
33765 delete arg3;
33766 }
33767 {
33768 if (temp4)
33769 delete arg4;
33770 }
33771 return NULL;
33772 }
33773
33774
33775 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33776 PyObject *resultobj;
33777 wxMenu *arg1 = (wxMenu *) 0 ;
33778 int arg2 ;
33779 wxString *arg3 = 0 ;
33780 wxMenu *arg4 = (wxMenu *) 0 ;
33781 wxString const &arg5_defvalue = wxPyEmptyString ;
33782 wxString *arg5 = (wxString *) &arg5_defvalue ;
33783 wxMenuItem *result;
33784 bool temp3 = false ;
33785 bool temp5 = false ;
33786 PyObject * obj0 = 0 ;
33787 PyObject * obj1 = 0 ;
33788 PyObject * obj2 = 0 ;
33789 PyObject * obj3 = 0 ;
33790 PyObject * obj4 = 0 ;
33791 char *kwnames[] = {
33792 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33793 };
33794
33795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33797 if (SWIG_arg_fail(1)) SWIG_fail;
33798 {
33799 arg2 = (int)(SWIG_As_int(obj1));
33800 if (SWIG_arg_fail(2)) SWIG_fail;
33801 }
33802 {
33803 arg3 = wxString_in_helper(obj2);
33804 if (arg3 == NULL) SWIG_fail;
33805 temp3 = true;
33806 }
33807 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33808 if (SWIG_arg_fail(4)) SWIG_fail;
33809 if (obj4) {
33810 {
33811 arg5 = wxString_in_helper(obj4);
33812 if (arg5 == NULL) SWIG_fail;
33813 temp5 = true;
33814 }
33815 }
33816 {
33817 PyThreadState* __tstate = wxPyBeginAllowThreads();
33818 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33819
33820 wxPyEndAllowThreads(__tstate);
33821 if (PyErr_Occurred()) SWIG_fail;
33822 }
33823 {
33824 resultobj = wxPyMake_wxObject(result, 0);
33825 }
33826 {
33827 if (temp3)
33828 delete arg3;
33829 }
33830 {
33831 if (temp5)
33832 delete arg5;
33833 }
33834 return resultobj;
33835 fail:
33836 {
33837 if (temp3)
33838 delete arg3;
33839 }
33840 {
33841 if (temp5)
33842 delete arg5;
33843 }
33844 return NULL;
33845 }
33846
33847
33848 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33849 PyObject *resultobj;
33850 wxMenu *arg1 = (wxMenu *) 0 ;
33851 int arg2 ;
33852 wxMenuItem *result;
33853 PyObject * obj0 = 0 ;
33854 PyObject * obj1 = 0 ;
33855 char *kwnames[] = {
33856 (char *) "self",(char *) "id", NULL
33857 };
33858
33859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33861 if (SWIG_arg_fail(1)) SWIG_fail;
33862 {
33863 arg2 = (int)(SWIG_As_int(obj1));
33864 if (SWIG_arg_fail(2)) SWIG_fail;
33865 }
33866 {
33867 PyThreadState* __tstate = wxPyBeginAllowThreads();
33868 result = (wxMenuItem *)(arg1)->Remove(arg2);
33869
33870 wxPyEndAllowThreads(__tstate);
33871 if (PyErr_Occurred()) SWIG_fail;
33872 }
33873 {
33874 resultobj = wxPyMake_wxObject(result, 0);
33875 }
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj;
33884 wxMenu *arg1 = (wxMenu *) 0 ;
33885 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33886 wxMenuItem *result;
33887 PyObject * obj0 = 0 ;
33888 PyObject * obj1 = 0 ;
33889 char *kwnames[] = {
33890 (char *) "self",(char *) "item", NULL
33891 };
33892
33893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33895 if (SWIG_arg_fail(1)) SWIG_fail;
33896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33897 if (SWIG_arg_fail(2)) SWIG_fail;
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (wxMenuItem *)(arg1)->Remove(arg2);
33901
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 {
33906 resultobj = wxPyMake_wxObject(result, 0);
33907 }
33908 return resultobj;
33909 fail:
33910 return NULL;
33911 }
33912
33913
33914 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33915 PyObject *resultobj;
33916 wxMenu *arg1 = (wxMenu *) 0 ;
33917 int arg2 ;
33918 bool result;
33919 PyObject * obj0 = 0 ;
33920 PyObject * obj1 = 0 ;
33921 char *kwnames[] = {
33922 (char *) "self",(char *) "id", NULL
33923 };
33924
33925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33927 if (SWIG_arg_fail(1)) SWIG_fail;
33928 {
33929 arg2 = (int)(SWIG_As_int(obj1));
33930 if (SWIG_arg_fail(2)) SWIG_fail;
33931 }
33932 {
33933 PyThreadState* __tstate = wxPyBeginAllowThreads();
33934 result = (bool)(arg1)->Delete(arg2);
33935
33936 wxPyEndAllowThreads(__tstate);
33937 if (PyErr_Occurred()) SWIG_fail;
33938 }
33939 {
33940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33941 }
33942 return resultobj;
33943 fail:
33944 return NULL;
33945 }
33946
33947
33948 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33949 PyObject *resultobj;
33950 wxMenu *arg1 = (wxMenu *) 0 ;
33951 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33952 bool result;
33953 PyObject * obj0 = 0 ;
33954 PyObject * obj1 = 0 ;
33955 char *kwnames[] = {
33956 (char *) "self",(char *) "item", NULL
33957 };
33958
33959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33961 if (SWIG_arg_fail(1)) SWIG_fail;
33962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33963 if (SWIG_arg_fail(2)) SWIG_fail;
33964 {
33965 PyThreadState* __tstate = wxPyBeginAllowThreads();
33966 result = (bool)(arg1)->Delete(arg2);
33967
33968 wxPyEndAllowThreads(__tstate);
33969 if (PyErr_Occurred()) SWIG_fail;
33970 }
33971 {
33972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33973 }
33974 return resultobj;
33975 fail:
33976 return NULL;
33977 }
33978
33979
33980 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33981 PyObject *resultobj;
33982 wxMenu *arg1 = (wxMenu *) 0 ;
33983 PyObject * obj0 = 0 ;
33984 char *kwnames[] = {
33985 (char *) "self", NULL
33986 };
33987
33988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33990 if (SWIG_arg_fail(1)) SWIG_fail;
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 wxMenu_Destroy(arg1);
33994
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 Py_INCREF(Py_None); resultobj = Py_None;
33999 return resultobj;
34000 fail:
34001 return NULL;
34002 }
34003
34004
34005 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34006 PyObject *resultobj;
34007 wxMenu *arg1 = (wxMenu *) 0 ;
34008 int arg2 ;
34009 bool result;
34010 PyObject * obj0 = 0 ;
34011 PyObject * obj1 = 0 ;
34012 char *kwnames[] = {
34013 (char *) "self",(char *) "id", NULL
34014 };
34015
34016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34018 if (SWIG_arg_fail(1)) SWIG_fail;
34019 {
34020 arg2 = (int)(SWIG_As_int(obj1));
34021 if (SWIG_arg_fail(2)) SWIG_fail;
34022 }
34023 {
34024 PyThreadState* __tstate = wxPyBeginAllowThreads();
34025 result = (bool)(arg1)->Destroy(arg2);
34026
34027 wxPyEndAllowThreads(__tstate);
34028 if (PyErr_Occurred()) SWIG_fail;
34029 }
34030 {
34031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34032 }
34033 return resultobj;
34034 fail:
34035 return NULL;
34036 }
34037
34038
34039 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 wxMenu *arg1 = (wxMenu *) 0 ;
34042 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34043 bool result;
34044 PyObject * obj0 = 0 ;
34045 PyObject * obj1 = 0 ;
34046 char *kwnames[] = {
34047 (char *) "self",(char *) "item", NULL
34048 };
34049
34050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34052 if (SWIG_arg_fail(1)) SWIG_fail;
34053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34054 if (SWIG_arg_fail(2)) SWIG_fail;
34055 {
34056 PyThreadState* __tstate = wxPyBeginAllowThreads();
34057 result = (bool)(arg1)->Destroy(arg2);
34058
34059 wxPyEndAllowThreads(__tstate);
34060 if (PyErr_Occurred()) SWIG_fail;
34061 }
34062 {
34063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34064 }
34065 return resultobj;
34066 fail:
34067 return NULL;
34068 }
34069
34070
34071 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34072 PyObject *resultobj;
34073 wxMenu *arg1 = (wxMenu *) 0 ;
34074 size_t result;
34075 PyObject * obj0 = 0 ;
34076 char *kwnames[] = {
34077 (char *) "self", NULL
34078 };
34079
34080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34082 if (SWIG_arg_fail(1)) SWIG_fail;
34083 {
34084 PyThreadState* __tstate = wxPyBeginAllowThreads();
34085 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34086
34087 wxPyEndAllowThreads(__tstate);
34088 if (PyErr_Occurred()) SWIG_fail;
34089 }
34090 {
34091 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34092 }
34093 return resultobj;
34094 fail:
34095 return NULL;
34096 }
34097
34098
34099 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34100 PyObject *resultobj;
34101 wxMenu *arg1 = (wxMenu *) 0 ;
34102 PyObject *result;
34103 PyObject * obj0 = 0 ;
34104 char *kwnames[] = {
34105 (char *) "self", NULL
34106 };
34107
34108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34110 if (SWIG_arg_fail(1)) SWIG_fail;
34111 {
34112 PyThreadState* __tstate = wxPyBeginAllowThreads();
34113 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34114
34115 wxPyEndAllowThreads(__tstate);
34116 if (PyErr_Occurred()) SWIG_fail;
34117 }
34118 resultobj = result;
34119 return resultobj;
34120 fail:
34121 return NULL;
34122 }
34123
34124
34125 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34126 PyObject *resultobj;
34127 wxMenu *arg1 = (wxMenu *) 0 ;
34128 wxString *arg2 = 0 ;
34129 int result;
34130 bool temp2 = false ;
34131 PyObject * obj0 = 0 ;
34132 PyObject * obj1 = 0 ;
34133 char *kwnames[] = {
34134 (char *) "self",(char *) "item", NULL
34135 };
34136
34137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34139 if (SWIG_arg_fail(1)) SWIG_fail;
34140 {
34141 arg2 = wxString_in_helper(obj1);
34142 if (arg2 == NULL) SWIG_fail;
34143 temp2 = true;
34144 }
34145 {
34146 PyThreadState* __tstate = wxPyBeginAllowThreads();
34147 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34148
34149 wxPyEndAllowThreads(__tstate);
34150 if (PyErr_Occurred()) SWIG_fail;
34151 }
34152 {
34153 resultobj = SWIG_From_int((int)(result));
34154 }
34155 {
34156 if (temp2)
34157 delete arg2;
34158 }
34159 return resultobj;
34160 fail:
34161 {
34162 if (temp2)
34163 delete arg2;
34164 }
34165 return NULL;
34166 }
34167
34168
34169 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34170 PyObject *resultobj;
34171 wxMenu *arg1 = (wxMenu *) 0 ;
34172 int arg2 ;
34173 wxMenuItem *result;
34174 PyObject * obj0 = 0 ;
34175 PyObject * obj1 = 0 ;
34176 char *kwnames[] = {
34177 (char *) "self",(char *) "id", NULL
34178 };
34179
34180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34182 if (SWIG_arg_fail(1)) SWIG_fail;
34183 {
34184 arg2 = (int)(SWIG_As_int(obj1));
34185 if (SWIG_arg_fail(2)) SWIG_fail;
34186 }
34187 {
34188 PyThreadState* __tstate = wxPyBeginAllowThreads();
34189 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34190
34191 wxPyEndAllowThreads(__tstate);
34192 if (PyErr_Occurred()) SWIG_fail;
34193 }
34194 {
34195 resultobj = wxPyMake_wxObject(result, 0);
34196 }
34197 return resultobj;
34198 fail:
34199 return NULL;
34200 }
34201
34202
34203 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34204 PyObject *resultobj;
34205 wxMenu *arg1 = (wxMenu *) 0 ;
34206 size_t arg2 ;
34207 wxMenuItem *result;
34208 PyObject * obj0 = 0 ;
34209 PyObject * obj1 = 0 ;
34210 char *kwnames[] = {
34211 (char *) "self",(char *) "position", NULL
34212 };
34213
34214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34216 if (SWIG_arg_fail(1)) SWIG_fail;
34217 {
34218 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34219 if (SWIG_arg_fail(2)) SWIG_fail;
34220 }
34221 {
34222 PyThreadState* __tstate = wxPyBeginAllowThreads();
34223 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34224
34225 wxPyEndAllowThreads(__tstate);
34226 if (PyErr_Occurred()) SWIG_fail;
34227 }
34228 {
34229 resultobj = wxPyMake_wxObject(result, 0);
34230 }
34231 return resultobj;
34232 fail:
34233 return NULL;
34234 }
34235
34236
34237 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34238 PyObject *resultobj;
34239 wxMenu *arg1 = (wxMenu *) 0 ;
34240 int arg2 ;
34241 bool arg3 ;
34242 PyObject * obj0 = 0 ;
34243 PyObject * obj1 = 0 ;
34244 PyObject * obj2 = 0 ;
34245 char *kwnames[] = {
34246 (char *) "self",(char *) "id",(char *) "enable", NULL
34247 };
34248
34249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34251 if (SWIG_arg_fail(1)) SWIG_fail;
34252 {
34253 arg2 = (int)(SWIG_As_int(obj1));
34254 if (SWIG_arg_fail(2)) SWIG_fail;
34255 }
34256 {
34257 arg3 = (bool)(SWIG_As_bool(obj2));
34258 if (SWIG_arg_fail(3)) SWIG_fail;
34259 }
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 (arg1)->Enable(arg2,arg3);
34263
34264 wxPyEndAllowThreads(__tstate);
34265 if (PyErr_Occurred()) SWIG_fail;
34266 }
34267 Py_INCREF(Py_None); resultobj = Py_None;
34268 return resultobj;
34269 fail:
34270 return NULL;
34271 }
34272
34273
34274 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34275 PyObject *resultobj;
34276 wxMenu *arg1 = (wxMenu *) 0 ;
34277 int arg2 ;
34278 bool result;
34279 PyObject * obj0 = 0 ;
34280 PyObject * obj1 = 0 ;
34281 char *kwnames[] = {
34282 (char *) "self",(char *) "id", NULL
34283 };
34284
34285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34287 if (SWIG_arg_fail(1)) SWIG_fail;
34288 {
34289 arg2 = (int)(SWIG_As_int(obj1));
34290 if (SWIG_arg_fail(2)) SWIG_fail;
34291 }
34292 {
34293 PyThreadState* __tstate = wxPyBeginAllowThreads();
34294 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34295
34296 wxPyEndAllowThreads(__tstate);
34297 if (PyErr_Occurred()) SWIG_fail;
34298 }
34299 {
34300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34301 }
34302 return resultobj;
34303 fail:
34304 return NULL;
34305 }
34306
34307
34308 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34309 PyObject *resultobj;
34310 wxMenu *arg1 = (wxMenu *) 0 ;
34311 int arg2 ;
34312 bool arg3 ;
34313 PyObject * obj0 = 0 ;
34314 PyObject * obj1 = 0 ;
34315 PyObject * obj2 = 0 ;
34316 char *kwnames[] = {
34317 (char *) "self",(char *) "id",(char *) "check", NULL
34318 };
34319
34320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34322 if (SWIG_arg_fail(1)) SWIG_fail;
34323 {
34324 arg2 = (int)(SWIG_As_int(obj1));
34325 if (SWIG_arg_fail(2)) SWIG_fail;
34326 }
34327 {
34328 arg3 = (bool)(SWIG_As_bool(obj2));
34329 if (SWIG_arg_fail(3)) SWIG_fail;
34330 }
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 (arg1)->Check(arg2,arg3);
34334
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 Py_INCREF(Py_None); resultobj = Py_None;
34339 return resultobj;
34340 fail:
34341 return NULL;
34342 }
34343
34344
34345 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34346 PyObject *resultobj;
34347 wxMenu *arg1 = (wxMenu *) 0 ;
34348 int arg2 ;
34349 bool result;
34350 PyObject * obj0 = 0 ;
34351 PyObject * obj1 = 0 ;
34352 char *kwnames[] = {
34353 (char *) "self",(char *) "id", NULL
34354 };
34355
34356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34358 if (SWIG_arg_fail(1)) SWIG_fail;
34359 {
34360 arg2 = (int)(SWIG_As_int(obj1));
34361 if (SWIG_arg_fail(2)) SWIG_fail;
34362 }
34363 {
34364 PyThreadState* __tstate = wxPyBeginAllowThreads();
34365 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34366
34367 wxPyEndAllowThreads(__tstate);
34368 if (PyErr_Occurred()) SWIG_fail;
34369 }
34370 {
34371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34372 }
34373 return resultobj;
34374 fail:
34375 return NULL;
34376 }
34377
34378
34379 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34380 PyObject *resultobj;
34381 wxMenu *arg1 = (wxMenu *) 0 ;
34382 int arg2 ;
34383 wxString *arg3 = 0 ;
34384 bool temp3 = false ;
34385 PyObject * obj0 = 0 ;
34386 PyObject * obj1 = 0 ;
34387 PyObject * obj2 = 0 ;
34388 char *kwnames[] = {
34389 (char *) "self",(char *) "id",(char *) "label", NULL
34390 };
34391
34392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34394 if (SWIG_arg_fail(1)) SWIG_fail;
34395 {
34396 arg2 = (int)(SWIG_As_int(obj1));
34397 if (SWIG_arg_fail(2)) SWIG_fail;
34398 }
34399 {
34400 arg3 = wxString_in_helper(obj2);
34401 if (arg3 == NULL) SWIG_fail;
34402 temp3 = true;
34403 }
34404 {
34405 PyThreadState* __tstate = wxPyBeginAllowThreads();
34406 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34407
34408 wxPyEndAllowThreads(__tstate);
34409 if (PyErr_Occurred()) SWIG_fail;
34410 }
34411 Py_INCREF(Py_None); resultobj = Py_None;
34412 {
34413 if (temp3)
34414 delete arg3;
34415 }
34416 return resultobj;
34417 fail:
34418 {
34419 if (temp3)
34420 delete arg3;
34421 }
34422 return NULL;
34423 }
34424
34425
34426 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34427 PyObject *resultobj;
34428 wxMenu *arg1 = (wxMenu *) 0 ;
34429 int arg2 ;
34430 wxString result;
34431 PyObject * obj0 = 0 ;
34432 PyObject * obj1 = 0 ;
34433 char *kwnames[] = {
34434 (char *) "self",(char *) "id", NULL
34435 };
34436
34437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34439 if (SWIG_arg_fail(1)) SWIG_fail;
34440 {
34441 arg2 = (int)(SWIG_As_int(obj1));
34442 if (SWIG_arg_fail(2)) SWIG_fail;
34443 }
34444 {
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34447
34448 wxPyEndAllowThreads(__tstate);
34449 if (PyErr_Occurred()) SWIG_fail;
34450 }
34451 {
34452 #if wxUSE_UNICODE
34453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34454 #else
34455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34456 #endif
34457 }
34458 return resultobj;
34459 fail:
34460 return NULL;
34461 }
34462
34463
34464 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34465 PyObject *resultobj;
34466 wxMenu *arg1 = (wxMenu *) 0 ;
34467 int arg2 ;
34468 wxString *arg3 = 0 ;
34469 bool temp3 = false ;
34470 PyObject * obj0 = 0 ;
34471 PyObject * obj1 = 0 ;
34472 PyObject * obj2 = 0 ;
34473 char *kwnames[] = {
34474 (char *) "self",(char *) "id",(char *) "helpString", NULL
34475 };
34476
34477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34479 if (SWIG_arg_fail(1)) SWIG_fail;
34480 {
34481 arg2 = (int)(SWIG_As_int(obj1));
34482 if (SWIG_arg_fail(2)) SWIG_fail;
34483 }
34484 {
34485 arg3 = wxString_in_helper(obj2);
34486 if (arg3 == NULL) SWIG_fail;
34487 temp3 = true;
34488 }
34489 {
34490 PyThreadState* __tstate = wxPyBeginAllowThreads();
34491 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34492
34493 wxPyEndAllowThreads(__tstate);
34494 if (PyErr_Occurred()) SWIG_fail;
34495 }
34496 Py_INCREF(Py_None); resultobj = Py_None;
34497 {
34498 if (temp3)
34499 delete arg3;
34500 }
34501 return resultobj;
34502 fail:
34503 {
34504 if (temp3)
34505 delete arg3;
34506 }
34507 return NULL;
34508 }
34509
34510
34511 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34512 PyObject *resultobj;
34513 wxMenu *arg1 = (wxMenu *) 0 ;
34514 int arg2 ;
34515 wxString result;
34516 PyObject * obj0 = 0 ;
34517 PyObject * obj1 = 0 ;
34518 char *kwnames[] = {
34519 (char *) "self",(char *) "id", NULL
34520 };
34521
34522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34524 if (SWIG_arg_fail(1)) SWIG_fail;
34525 {
34526 arg2 = (int)(SWIG_As_int(obj1));
34527 if (SWIG_arg_fail(2)) SWIG_fail;
34528 }
34529 {
34530 PyThreadState* __tstate = wxPyBeginAllowThreads();
34531 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34532
34533 wxPyEndAllowThreads(__tstate);
34534 if (PyErr_Occurred()) SWIG_fail;
34535 }
34536 {
34537 #if wxUSE_UNICODE
34538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34539 #else
34540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34541 #endif
34542 }
34543 return resultobj;
34544 fail:
34545 return NULL;
34546 }
34547
34548
34549 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34550 PyObject *resultobj;
34551 wxMenu *arg1 = (wxMenu *) 0 ;
34552 wxString *arg2 = 0 ;
34553 bool temp2 = false ;
34554 PyObject * obj0 = 0 ;
34555 PyObject * obj1 = 0 ;
34556 char *kwnames[] = {
34557 (char *) "self",(char *) "title", NULL
34558 };
34559
34560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34562 if (SWIG_arg_fail(1)) SWIG_fail;
34563 {
34564 arg2 = wxString_in_helper(obj1);
34565 if (arg2 == NULL) SWIG_fail;
34566 temp2 = true;
34567 }
34568 {
34569 PyThreadState* __tstate = wxPyBeginAllowThreads();
34570 (arg1)->SetTitle((wxString const &)*arg2);
34571
34572 wxPyEndAllowThreads(__tstate);
34573 if (PyErr_Occurred()) SWIG_fail;
34574 }
34575 Py_INCREF(Py_None); resultobj = Py_None;
34576 {
34577 if (temp2)
34578 delete arg2;
34579 }
34580 return resultobj;
34581 fail:
34582 {
34583 if (temp2)
34584 delete arg2;
34585 }
34586 return NULL;
34587 }
34588
34589
34590 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34591 PyObject *resultobj;
34592 wxMenu *arg1 = (wxMenu *) 0 ;
34593 wxString result;
34594 PyObject * obj0 = 0 ;
34595 char *kwnames[] = {
34596 (char *) "self", NULL
34597 };
34598
34599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34601 if (SWIG_arg_fail(1)) SWIG_fail;
34602 {
34603 PyThreadState* __tstate = wxPyBeginAllowThreads();
34604 result = ((wxMenu const *)arg1)->GetTitle();
34605
34606 wxPyEndAllowThreads(__tstate);
34607 if (PyErr_Occurred()) SWIG_fail;
34608 }
34609 {
34610 #if wxUSE_UNICODE
34611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34612 #else
34613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34614 #endif
34615 }
34616 return resultobj;
34617 fail:
34618 return NULL;
34619 }
34620
34621
34622 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34623 PyObject *resultobj;
34624 wxMenu *arg1 = (wxMenu *) 0 ;
34625 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34626 PyObject * obj0 = 0 ;
34627 PyObject * obj1 = 0 ;
34628 char *kwnames[] = {
34629 (char *) "self",(char *) "handler", NULL
34630 };
34631
34632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34634 if (SWIG_arg_fail(1)) SWIG_fail;
34635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34636 if (SWIG_arg_fail(2)) SWIG_fail;
34637 {
34638 PyThreadState* __tstate = wxPyBeginAllowThreads();
34639 (arg1)->SetEventHandler(arg2);
34640
34641 wxPyEndAllowThreads(__tstate);
34642 if (PyErr_Occurred()) SWIG_fail;
34643 }
34644 Py_INCREF(Py_None); resultobj = Py_None;
34645 return resultobj;
34646 fail:
34647 return NULL;
34648 }
34649
34650
34651 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34652 PyObject *resultobj;
34653 wxMenu *arg1 = (wxMenu *) 0 ;
34654 wxEvtHandler *result;
34655 PyObject * obj0 = 0 ;
34656 char *kwnames[] = {
34657 (char *) "self", NULL
34658 };
34659
34660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34662 if (SWIG_arg_fail(1)) SWIG_fail;
34663 {
34664 PyThreadState* __tstate = wxPyBeginAllowThreads();
34665 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34666
34667 wxPyEndAllowThreads(__tstate);
34668 if (PyErr_Occurred()) SWIG_fail;
34669 }
34670 {
34671 resultobj = wxPyMake_wxObject(result, 0);
34672 }
34673 return resultobj;
34674 fail:
34675 return NULL;
34676 }
34677
34678
34679 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34680 PyObject *resultobj;
34681 wxMenu *arg1 = (wxMenu *) 0 ;
34682 wxWindow *arg2 = (wxWindow *) 0 ;
34683 PyObject * obj0 = 0 ;
34684 PyObject * obj1 = 0 ;
34685 char *kwnames[] = {
34686 (char *) "self",(char *) "win", NULL
34687 };
34688
34689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34691 if (SWIG_arg_fail(1)) SWIG_fail;
34692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34693 if (SWIG_arg_fail(2)) SWIG_fail;
34694 {
34695 PyThreadState* __tstate = wxPyBeginAllowThreads();
34696 (arg1)->SetInvokingWindow(arg2);
34697
34698 wxPyEndAllowThreads(__tstate);
34699 if (PyErr_Occurred()) SWIG_fail;
34700 }
34701 Py_INCREF(Py_None); resultobj = Py_None;
34702 return resultobj;
34703 fail:
34704 return NULL;
34705 }
34706
34707
34708 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34709 PyObject *resultobj;
34710 wxMenu *arg1 = (wxMenu *) 0 ;
34711 wxWindow *result;
34712 PyObject * obj0 = 0 ;
34713 char *kwnames[] = {
34714 (char *) "self", NULL
34715 };
34716
34717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34719 if (SWIG_arg_fail(1)) SWIG_fail;
34720 {
34721 PyThreadState* __tstate = wxPyBeginAllowThreads();
34722 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34723
34724 wxPyEndAllowThreads(__tstate);
34725 if (PyErr_Occurred()) SWIG_fail;
34726 }
34727 {
34728 resultobj = wxPyMake_wxObject(result, 0);
34729 }
34730 return resultobj;
34731 fail:
34732 return NULL;
34733 }
34734
34735
34736 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34737 PyObject *resultobj;
34738 wxMenu *arg1 = (wxMenu *) 0 ;
34739 long result;
34740 PyObject * obj0 = 0 ;
34741 char *kwnames[] = {
34742 (char *) "self", NULL
34743 };
34744
34745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34747 if (SWIG_arg_fail(1)) SWIG_fail;
34748 {
34749 PyThreadState* __tstate = wxPyBeginAllowThreads();
34750 result = (long)((wxMenu const *)arg1)->GetStyle();
34751
34752 wxPyEndAllowThreads(__tstate);
34753 if (PyErr_Occurred()) SWIG_fail;
34754 }
34755 {
34756 resultobj = SWIG_From_long((long)(result));
34757 }
34758 return resultobj;
34759 fail:
34760 return NULL;
34761 }
34762
34763
34764 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34765 PyObject *resultobj;
34766 wxMenu *arg1 = (wxMenu *) 0 ;
34767 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34768 PyObject * obj0 = 0 ;
34769 PyObject * obj1 = 0 ;
34770 char *kwnames[] = {
34771 (char *) "self",(char *) "source", NULL
34772 };
34773
34774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34776 if (SWIG_arg_fail(1)) SWIG_fail;
34777 if (obj1) {
34778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34779 if (SWIG_arg_fail(2)) SWIG_fail;
34780 }
34781 {
34782 PyThreadState* __tstate = wxPyBeginAllowThreads();
34783 (arg1)->UpdateUI(arg2);
34784
34785 wxPyEndAllowThreads(__tstate);
34786 if (PyErr_Occurred()) SWIG_fail;
34787 }
34788 Py_INCREF(Py_None); resultobj = Py_None;
34789 return resultobj;
34790 fail:
34791 return NULL;
34792 }
34793
34794
34795 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34796 PyObject *resultobj;
34797 wxMenu *arg1 = (wxMenu *) 0 ;
34798 wxMenuBar *result;
34799 PyObject * obj0 = 0 ;
34800 char *kwnames[] = {
34801 (char *) "self", NULL
34802 };
34803
34804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34806 if (SWIG_arg_fail(1)) SWIG_fail;
34807 {
34808 PyThreadState* __tstate = wxPyBeginAllowThreads();
34809 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34810
34811 wxPyEndAllowThreads(__tstate);
34812 if (PyErr_Occurred()) SWIG_fail;
34813 }
34814 {
34815 resultobj = wxPyMake_wxObject(result, 0);
34816 }
34817 return resultobj;
34818 fail:
34819 return NULL;
34820 }
34821
34822
34823 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34824 PyObject *resultobj;
34825 wxMenu *arg1 = (wxMenu *) 0 ;
34826 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34827 PyObject * obj0 = 0 ;
34828 PyObject * obj1 = 0 ;
34829 char *kwnames[] = {
34830 (char *) "self",(char *) "menubar", NULL
34831 };
34832
34833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34835 if (SWIG_arg_fail(1)) SWIG_fail;
34836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34837 if (SWIG_arg_fail(2)) SWIG_fail;
34838 {
34839 PyThreadState* __tstate = wxPyBeginAllowThreads();
34840 (arg1)->Attach(arg2);
34841
34842 wxPyEndAllowThreads(__tstate);
34843 if (PyErr_Occurred()) SWIG_fail;
34844 }
34845 Py_INCREF(Py_None); resultobj = Py_None;
34846 return resultobj;
34847 fail:
34848 return NULL;
34849 }
34850
34851
34852 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34853 PyObject *resultobj;
34854 wxMenu *arg1 = (wxMenu *) 0 ;
34855 PyObject * obj0 = 0 ;
34856 char *kwnames[] = {
34857 (char *) "self", NULL
34858 };
34859
34860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34862 if (SWIG_arg_fail(1)) SWIG_fail;
34863 {
34864 PyThreadState* __tstate = wxPyBeginAllowThreads();
34865 (arg1)->Detach();
34866
34867 wxPyEndAllowThreads(__tstate);
34868 if (PyErr_Occurred()) SWIG_fail;
34869 }
34870 Py_INCREF(Py_None); resultobj = Py_None;
34871 return resultobj;
34872 fail:
34873 return NULL;
34874 }
34875
34876
34877 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34878 PyObject *resultobj;
34879 wxMenu *arg1 = (wxMenu *) 0 ;
34880 bool result;
34881 PyObject * obj0 = 0 ;
34882 char *kwnames[] = {
34883 (char *) "self", NULL
34884 };
34885
34886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34888 if (SWIG_arg_fail(1)) SWIG_fail;
34889 {
34890 PyThreadState* __tstate = wxPyBeginAllowThreads();
34891 result = (bool)((wxMenu const *)arg1)->IsAttached();
34892
34893 wxPyEndAllowThreads(__tstate);
34894 if (PyErr_Occurred()) SWIG_fail;
34895 }
34896 {
34897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34898 }
34899 return resultobj;
34900 fail:
34901 return NULL;
34902 }
34903
34904
34905 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34906 PyObject *resultobj;
34907 wxMenu *arg1 = (wxMenu *) 0 ;
34908 wxMenu *arg2 = (wxMenu *) 0 ;
34909 PyObject * obj0 = 0 ;
34910 PyObject * obj1 = 0 ;
34911 char *kwnames[] = {
34912 (char *) "self",(char *) "parent", NULL
34913 };
34914
34915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34917 if (SWIG_arg_fail(1)) SWIG_fail;
34918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34919 if (SWIG_arg_fail(2)) SWIG_fail;
34920 {
34921 PyThreadState* __tstate = wxPyBeginAllowThreads();
34922 (arg1)->SetParent(arg2);
34923
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 Py_INCREF(Py_None); resultobj = Py_None;
34928 return resultobj;
34929 fail:
34930 return NULL;
34931 }
34932
34933
34934 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34935 PyObject *resultobj;
34936 wxMenu *arg1 = (wxMenu *) 0 ;
34937 wxMenu *result;
34938 PyObject * obj0 = 0 ;
34939 char *kwnames[] = {
34940 (char *) "self", NULL
34941 };
34942
34943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34945 if (SWIG_arg_fail(1)) SWIG_fail;
34946 {
34947 PyThreadState* __tstate = wxPyBeginAllowThreads();
34948 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34949
34950 wxPyEndAllowThreads(__tstate);
34951 if (PyErr_Occurred()) SWIG_fail;
34952 }
34953 {
34954 resultobj = wxPyMake_wxObject(result, 0);
34955 }
34956 return resultobj;
34957 fail:
34958 return NULL;
34959 }
34960
34961
34962 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34963 PyObject *obj;
34964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34965 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34966 Py_INCREF(obj);
34967 return Py_BuildValue((char *)"");
34968 }
34969 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34970 PyObject *resultobj;
34971 long arg1 = (long) 0 ;
34972 wxMenuBar *result;
34973 PyObject * obj0 = 0 ;
34974 char *kwnames[] = {
34975 (char *) "style", NULL
34976 };
34977
34978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34979 if (obj0) {
34980 {
34981 arg1 = (long)(SWIG_As_long(obj0));
34982 if (SWIG_arg_fail(1)) SWIG_fail;
34983 }
34984 }
34985 {
34986 if (!wxPyCheckForApp()) SWIG_fail;
34987 PyThreadState* __tstate = wxPyBeginAllowThreads();
34988 result = (wxMenuBar *)new wxMenuBar(arg1);
34989
34990 wxPyEndAllowThreads(__tstate);
34991 if (PyErr_Occurred()) SWIG_fail;
34992 }
34993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34994 return resultobj;
34995 fail:
34996 return NULL;
34997 }
34998
34999
35000 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35001 PyObject *resultobj;
35002 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35003 wxMenu *arg2 = (wxMenu *) 0 ;
35004 wxString *arg3 = 0 ;
35005 bool result;
35006 bool temp3 = false ;
35007 PyObject * obj0 = 0 ;
35008 PyObject * obj1 = 0 ;
35009 PyObject * obj2 = 0 ;
35010 char *kwnames[] = {
35011 (char *) "self",(char *) "menu",(char *) "title", NULL
35012 };
35013
35014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35016 if (SWIG_arg_fail(1)) SWIG_fail;
35017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35018 if (SWIG_arg_fail(2)) SWIG_fail;
35019 {
35020 arg3 = wxString_in_helper(obj2);
35021 if (arg3 == NULL) SWIG_fail;
35022 temp3 = true;
35023 }
35024 {
35025 PyThreadState* __tstate = wxPyBeginAllowThreads();
35026 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35027
35028 wxPyEndAllowThreads(__tstate);
35029 if (PyErr_Occurred()) SWIG_fail;
35030 }
35031 {
35032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35033 }
35034 {
35035 if (temp3)
35036 delete arg3;
35037 }
35038 return resultobj;
35039 fail:
35040 {
35041 if (temp3)
35042 delete arg3;
35043 }
35044 return NULL;
35045 }
35046
35047
35048 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35049 PyObject *resultobj;
35050 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35051 size_t arg2 ;
35052 wxMenu *arg3 = (wxMenu *) 0 ;
35053 wxString *arg4 = 0 ;
35054 bool result;
35055 bool temp4 = false ;
35056 PyObject * obj0 = 0 ;
35057 PyObject * obj1 = 0 ;
35058 PyObject * obj2 = 0 ;
35059 PyObject * obj3 = 0 ;
35060 char *kwnames[] = {
35061 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35062 };
35063
35064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35066 if (SWIG_arg_fail(1)) SWIG_fail;
35067 {
35068 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35069 if (SWIG_arg_fail(2)) SWIG_fail;
35070 }
35071 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35072 if (SWIG_arg_fail(3)) SWIG_fail;
35073 {
35074 arg4 = wxString_in_helper(obj3);
35075 if (arg4 == NULL) SWIG_fail;
35076 temp4 = true;
35077 }
35078 {
35079 PyThreadState* __tstate = wxPyBeginAllowThreads();
35080 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35081
35082 wxPyEndAllowThreads(__tstate);
35083 if (PyErr_Occurred()) SWIG_fail;
35084 }
35085 {
35086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35087 }
35088 {
35089 if (temp4)
35090 delete arg4;
35091 }
35092 return resultobj;
35093 fail:
35094 {
35095 if (temp4)
35096 delete arg4;
35097 }
35098 return NULL;
35099 }
35100
35101
35102 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35103 PyObject *resultobj;
35104 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35105 size_t result;
35106 PyObject * obj0 = 0 ;
35107 char *kwnames[] = {
35108 (char *) "self", NULL
35109 };
35110
35111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35113 if (SWIG_arg_fail(1)) SWIG_fail;
35114 {
35115 PyThreadState* __tstate = wxPyBeginAllowThreads();
35116 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35117
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 {
35122 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35123 }
35124 return resultobj;
35125 fail:
35126 return NULL;
35127 }
35128
35129
35130 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35131 PyObject *resultobj;
35132 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35133 size_t arg2 ;
35134 wxMenu *result;
35135 PyObject * obj0 = 0 ;
35136 PyObject * obj1 = 0 ;
35137 char *kwnames[] = {
35138 (char *) "self",(char *) "pos", NULL
35139 };
35140
35141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35143 if (SWIG_arg_fail(1)) SWIG_fail;
35144 {
35145 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35146 if (SWIG_arg_fail(2)) SWIG_fail;
35147 }
35148 {
35149 PyThreadState* __tstate = wxPyBeginAllowThreads();
35150 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35151
35152 wxPyEndAllowThreads(__tstate);
35153 if (PyErr_Occurred()) SWIG_fail;
35154 }
35155 {
35156 resultobj = wxPyMake_wxObject(result, 0);
35157 }
35158 return resultobj;
35159 fail:
35160 return NULL;
35161 }
35162
35163
35164 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35165 PyObject *resultobj;
35166 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35167 size_t arg2 ;
35168 wxMenu *arg3 = (wxMenu *) 0 ;
35169 wxString *arg4 = 0 ;
35170 wxMenu *result;
35171 bool temp4 = false ;
35172 PyObject * obj0 = 0 ;
35173 PyObject * obj1 = 0 ;
35174 PyObject * obj2 = 0 ;
35175 PyObject * obj3 = 0 ;
35176 char *kwnames[] = {
35177 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35178 };
35179
35180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35182 if (SWIG_arg_fail(1)) SWIG_fail;
35183 {
35184 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35185 if (SWIG_arg_fail(2)) SWIG_fail;
35186 }
35187 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35188 if (SWIG_arg_fail(3)) SWIG_fail;
35189 {
35190 arg4 = wxString_in_helper(obj3);
35191 if (arg4 == NULL) SWIG_fail;
35192 temp4 = true;
35193 }
35194 {
35195 PyThreadState* __tstate = wxPyBeginAllowThreads();
35196 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35197
35198 wxPyEndAllowThreads(__tstate);
35199 if (PyErr_Occurred()) SWIG_fail;
35200 }
35201 {
35202 resultobj = wxPyMake_wxObject(result, 0);
35203 }
35204 {
35205 if (temp4)
35206 delete arg4;
35207 }
35208 return resultobj;
35209 fail:
35210 {
35211 if (temp4)
35212 delete arg4;
35213 }
35214 return NULL;
35215 }
35216
35217
35218 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35219 PyObject *resultobj;
35220 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35221 size_t arg2 ;
35222 wxMenu *result;
35223 PyObject * obj0 = 0 ;
35224 PyObject * obj1 = 0 ;
35225 char *kwnames[] = {
35226 (char *) "self",(char *) "pos", NULL
35227 };
35228
35229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35231 if (SWIG_arg_fail(1)) SWIG_fail;
35232 {
35233 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35234 if (SWIG_arg_fail(2)) SWIG_fail;
35235 }
35236 {
35237 PyThreadState* __tstate = wxPyBeginAllowThreads();
35238 result = (wxMenu *)(arg1)->Remove(arg2);
35239
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 {
35244 resultobj = wxPyMake_wxObject(result, 0);
35245 }
35246 return resultobj;
35247 fail:
35248 return NULL;
35249 }
35250
35251
35252 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35253 PyObject *resultobj;
35254 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35255 size_t arg2 ;
35256 bool arg3 ;
35257 PyObject * obj0 = 0 ;
35258 PyObject * obj1 = 0 ;
35259 PyObject * obj2 = 0 ;
35260 char *kwnames[] = {
35261 (char *) "self",(char *) "pos",(char *) "enable", NULL
35262 };
35263
35264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35266 if (SWIG_arg_fail(1)) SWIG_fail;
35267 {
35268 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35269 if (SWIG_arg_fail(2)) SWIG_fail;
35270 }
35271 {
35272 arg3 = (bool)(SWIG_As_bool(obj2));
35273 if (SWIG_arg_fail(3)) SWIG_fail;
35274 }
35275 {
35276 PyThreadState* __tstate = wxPyBeginAllowThreads();
35277 (arg1)->EnableTop(arg2,arg3);
35278
35279 wxPyEndAllowThreads(__tstate);
35280 if (PyErr_Occurred()) SWIG_fail;
35281 }
35282 Py_INCREF(Py_None); resultobj = Py_None;
35283 return resultobj;
35284 fail:
35285 return NULL;
35286 }
35287
35288
35289 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35290 PyObject *resultobj;
35291 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35292 size_t arg2 ;
35293 bool result;
35294 PyObject * obj0 = 0 ;
35295 PyObject * obj1 = 0 ;
35296 char *kwnames[] = {
35297 (char *) "self",(char *) "pos", NULL
35298 };
35299
35300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35302 if (SWIG_arg_fail(1)) SWIG_fail;
35303 {
35304 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35305 if (SWIG_arg_fail(2)) SWIG_fail;
35306 }
35307 {
35308 PyThreadState* __tstate = wxPyBeginAllowThreads();
35309 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35310
35311 wxPyEndAllowThreads(__tstate);
35312 if (PyErr_Occurred()) SWIG_fail;
35313 }
35314 {
35315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35316 }
35317 return resultobj;
35318 fail:
35319 return NULL;
35320 }
35321
35322
35323 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35324 PyObject *resultobj;
35325 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35326 size_t arg2 ;
35327 wxString *arg3 = 0 ;
35328 bool temp3 = false ;
35329 PyObject * obj0 = 0 ;
35330 PyObject * obj1 = 0 ;
35331 PyObject * obj2 = 0 ;
35332 char *kwnames[] = {
35333 (char *) "self",(char *) "pos",(char *) "label", NULL
35334 };
35335
35336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35338 if (SWIG_arg_fail(1)) SWIG_fail;
35339 {
35340 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35341 if (SWIG_arg_fail(2)) SWIG_fail;
35342 }
35343 {
35344 arg3 = wxString_in_helper(obj2);
35345 if (arg3 == NULL) SWIG_fail;
35346 temp3 = true;
35347 }
35348 {
35349 PyThreadState* __tstate = wxPyBeginAllowThreads();
35350 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35351
35352 wxPyEndAllowThreads(__tstate);
35353 if (PyErr_Occurred()) SWIG_fail;
35354 }
35355 Py_INCREF(Py_None); resultobj = Py_None;
35356 {
35357 if (temp3)
35358 delete arg3;
35359 }
35360 return resultobj;
35361 fail:
35362 {
35363 if (temp3)
35364 delete arg3;
35365 }
35366 return NULL;
35367 }
35368
35369
35370 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35371 PyObject *resultobj;
35372 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35373 size_t arg2 ;
35374 wxString result;
35375 PyObject * obj0 = 0 ;
35376 PyObject * obj1 = 0 ;
35377 char *kwnames[] = {
35378 (char *) "self",(char *) "pos", NULL
35379 };
35380
35381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35383 if (SWIG_arg_fail(1)) SWIG_fail;
35384 {
35385 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35386 if (SWIG_arg_fail(2)) SWIG_fail;
35387 }
35388 {
35389 PyThreadState* __tstate = wxPyBeginAllowThreads();
35390 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35391
35392 wxPyEndAllowThreads(__tstate);
35393 if (PyErr_Occurred()) SWIG_fail;
35394 }
35395 {
35396 #if wxUSE_UNICODE
35397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35398 #else
35399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35400 #endif
35401 }
35402 return resultobj;
35403 fail:
35404 return NULL;
35405 }
35406
35407
35408 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35409 PyObject *resultobj;
35410 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35411 wxString *arg2 = 0 ;
35412 wxString *arg3 = 0 ;
35413 int result;
35414 bool temp2 = false ;
35415 bool temp3 = false ;
35416 PyObject * obj0 = 0 ;
35417 PyObject * obj1 = 0 ;
35418 PyObject * obj2 = 0 ;
35419 char *kwnames[] = {
35420 (char *) "self",(char *) "menu",(char *) "item", NULL
35421 };
35422
35423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35425 if (SWIG_arg_fail(1)) SWIG_fail;
35426 {
35427 arg2 = wxString_in_helper(obj1);
35428 if (arg2 == NULL) SWIG_fail;
35429 temp2 = true;
35430 }
35431 {
35432 arg3 = wxString_in_helper(obj2);
35433 if (arg3 == NULL) SWIG_fail;
35434 temp3 = true;
35435 }
35436 {
35437 PyThreadState* __tstate = wxPyBeginAllowThreads();
35438 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35439
35440 wxPyEndAllowThreads(__tstate);
35441 if (PyErr_Occurred()) SWIG_fail;
35442 }
35443 {
35444 resultobj = SWIG_From_int((int)(result));
35445 }
35446 {
35447 if (temp2)
35448 delete arg2;
35449 }
35450 {
35451 if (temp3)
35452 delete arg3;
35453 }
35454 return resultobj;
35455 fail:
35456 {
35457 if (temp2)
35458 delete arg2;
35459 }
35460 {
35461 if (temp3)
35462 delete arg3;
35463 }
35464 return NULL;
35465 }
35466
35467
35468 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35469 PyObject *resultobj;
35470 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35471 int arg2 ;
35472 wxMenuItem *result;
35473 PyObject * obj0 = 0 ;
35474 PyObject * obj1 = 0 ;
35475 char *kwnames[] = {
35476 (char *) "self",(char *) "id", NULL
35477 };
35478
35479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35481 if (SWIG_arg_fail(1)) SWIG_fail;
35482 {
35483 arg2 = (int)(SWIG_As_int(obj1));
35484 if (SWIG_arg_fail(2)) SWIG_fail;
35485 }
35486 {
35487 PyThreadState* __tstate = wxPyBeginAllowThreads();
35488 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35489
35490 wxPyEndAllowThreads(__tstate);
35491 if (PyErr_Occurred()) SWIG_fail;
35492 }
35493 {
35494 resultobj = wxPyMake_wxObject(result, 0);
35495 }
35496 return resultobj;
35497 fail:
35498 return NULL;
35499 }
35500
35501
35502 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35503 PyObject *resultobj;
35504 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35505 wxString *arg2 = 0 ;
35506 int result;
35507 bool temp2 = false ;
35508 PyObject * obj0 = 0 ;
35509 PyObject * obj1 = 0 ;
35510 char *kwnames[] = {
35511 (char *) "self",(char *) "title", NULL
35512 };
35513
35514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35516 if (SWIG_arg_fail(1)) SWIG_fail;
35517 {
35518 arg2 = wxString_in_helper(obj1);
35519 if (arg2 == NULL) SWIG_fail;
35520 temp2 = true;
35521 }
35522 {
35523 PyThreadState* __tstate = wxPyBeginAllowThreads();
35524 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
35525
35526 wxPyEndAllowThreads(__tstate);
35527 if (PyErr_Occurred()) SWIG_fail;
35528 }
35529 {
35530 resultobj = SWIG_From_int((int)(result));
35531 }
35532 {
35533 if (temp2)
35534 delete arg2;
35535 }
35536 return resultobj;
35537 fail:
35538 {
35539 if (temp2)
35540 delete arg2;
35541 }
35542 return NULL;
35543 }
35544
35545
35546 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35547 PyObject *resultobj;
35548 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35549 int arg2 ;
35550 bool arg3 ;
35551 PyObject * obj0 = 0 ;
35552 PyObject * obj1 = 0 ;
35553 PyObject * obj2 = 0 ;
35554 char *kwnames[] = {
35555 (char *) "self",(char *) "id",(char *) "enable", NULL
35556 };
35557
35558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35560 if (SWIG_arg_fail(1)) SWIG_fail;
35561 {
35562 arg2 = (int)(SWIG_As_int(obj1));
35563 if (SWIG_arg_fail(2)) SWIG_fail;
35564 }
35565 {
35566 arg3 = (bool)(SWIG_As_bool(obj2));
35567 if (SWIG_arg_fail(3)) SWIG_fail;
35568 }
35569 {
35570 PyThreadState* __tstate = wxPyBeginAllowThreads();
35571 (arg1)->Enable(arg2,arg3);
35572
35573 wxPyEndAllowThreads(__tstate);
35574 if (PyErr_Occurred()) SWIG_fail;
35575 }
35576 Py_INCREF(Py_None); resultobj = Py_None;
35577 return resultobj;
35578 fail:
35579 return NULL;
35580 }
35581
35582
35583 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35584 PyObject *resultobj;
35585 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35586 int arg2 ;
35587 bool arg3 ;
35588 PyObject * obj0 = 0 ;
35589 PyObject * obj1 = 0 ;
35590 PyObject * obj2 = 0 ;
35591 char *kwnames[] = {
35592 (char *) "self",(char *) "id",(char *) "check", NULL
35593 };
35594
35595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35597 if (SWIG_arg_fail(1)) SWIG_fail;
35598 {
35599 arg2 = (int)(SWIG_As_int(obj1));
35600 if (SWIG_arg_fail(2)) SWIG_fail;
35601 }
35602 {
35603 arg3 = (bool)(SWIG_As_bool(obj2));
35604 if (SWIG_arg_fail(3)) SWIG_fail;
35605 }
35606 {
35607 PyThreadState* __tstate = wxPyBeginAllowThreads();
35608 (arg1)->Check(arg2,arg3);
35609
35610 wxPyEndAllowThreads(__tstate);
35611 if (PyErr_Occurred()) SWIG_fail;
35612 }
35613 Py_INCREF(Py_None); resultobj = Py_None;
35614 return resultobj;
35615 fail:
35616 return NULL;
35617 }
35618
35619
35620 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35621 PyObject *resultobj;
35622 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35623 int arg2 ;
35624 bool result;
35625 PyObject * obj0 = 0 ;
35626 PyObject * obj1 = 0 ;
35627 char *kwnames[] = {
35628 (char *) "self",(char *) "id", NULL
35629 };
35630
35631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35633 if (SWIG_arg_fail(1)) SWIG_fail;
35634 {
35635 arg2 = (int)(SWIG_As_int(obj1));
35636 if (SWIG_arg_fail(2)) SWIG_fail;
35637 }
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35641
35642 wxPyEndAllowThreads(__tstate);
35643 if (PyErr_Occurred()) SWIG_fail;
35644 }
35645 {
35646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35647 }
35648 return resultobj;
35649 fail:
35650 return NULL;
35651 }
35652
35653
35654 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35655 PyObject *resultobj;
35656 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35657 int arg2 ;
35658 bool result;
35659 PyObject * obj0 = 0 ;
35660 PyObject * obj1 = 0 ;
35661 char *kwnames[] = {
35662 (char *) "self",(char *) "id", NULL
35663 };
35664
35665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35667 if (SWIG_arg_fail(1)) SWIG_fail;
35668 {
35669 arg2 = (int)(SWIG_As_int(obj1));
35670 if (SWIG_arg_fail(2)) SWIG_fail;
35671 }
35672 {
35673 PyThreadState* __tstate = wxPyBeginAllowThreads();
35674 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35675
35676 wxPyEndAllowThreads(__tstate);
35677 if (PyErr_Occurred()) SWIG_fail;
35678 }
35679 {
35680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35681 }
35682 return resultobj;
35683 fail:
35684 return NULL;
35685 }
35686
35687
35688 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35689 PyObject *resultobj;
35690 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35691 int arg2 ;
35692 wxString *arg3 = 0 ;
35693 bool temp3 = false ;
35694 PyObject * obj0 = 0 ;
35695 PyObject * obj1 = 0 ;
35696 PyObject * obj2 = 0 ;
35697 char *kwnames[] = {
35698 (char *) "self",(char *) "id",(char *) "label", NULL
35699 };
35700
35701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35703 if (SWIG_arg_fail(1)) SWIG_fail;
35704 {
35705 arg2 = (int)(SWIG_As_int(obj1));
35706 if (SWIG_arg_fail(2)) SWIG_fail;
35707 }
35708 {
35709 arg3 = wxString_in_helper(obj2);
35710 if (arg3 == NULL) SWIG_fail;
35711 temp3 = true;
35712 }
35713 {
35714 PyThreadState* __tstate = wxPyBeginAllowThreads();
35715 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35716
35717 wxPyEndAllowThreads(__tstate);
35718 if (PyErr_Occurred()) SWIG_fail;
35719 }
35720 Py_INCREF(Py_None); resultobj = Py_None;
35721 {
35722 if (temp3)
35723 delete arg3;
35724 }
35725 return resultobj;
35726 fail:
35727 {
35728 if (temp3)
35729 delete arg3;
35730 }
35731 return NULL;
35732 }
35733
35734
35735 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35736 PyObject *resultobj;
35737 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35738 int arg2 ;
35739 wxString result;
35740 PyObject * obj0 = 0 ;
35741 PyObject * obj1 = 0 ;
35742 char *kwnames[] = {
35743 (char *) "self",(char *) "id", NULL
35744 };
35745
35746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35748 if (SWIG_arg_fail(1)) SWIG_fail;
35749 {
35750 arg2 = (int)(SWIG_As_int(obj1));
35751 if (SWIG_arg_fail(2)) SWIG_fail;
35752 }
35753 {
35754 PyThreadState* __tstate = wxPyBeginAllowThreads();
35755 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35756
35757 wxPyEndAllowThreads(__tstate);
35758 if (PyErr_Occurred()) SWIG_fail;
35759 }
35760 {
35761 #if wxUSE_UNICODE
35762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35763 #else
35764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35765 #endif
35766 }
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35774 PyObject *resultobj;
35775 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35776 int arg2 ;
35777 wxString *arg3 = 0 ;
35778 bool temp3 = false ;
35779 PyObject * obj0 = 0 ;
35780 PyObject * obj1 = 0 ;
35781 PyObject * obj2 = 0 ;
35782 char *kwnames[] = {
35783 (char *) "self",(char *) "id",(char *) "helpString", NULL
35784 };
35785
35786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35788 if (SWIG_arg_fail(1)) SWIG_fail;
35789 {
35790 arg2 = (int)(SWIG_As_int(obj1));
35791 if (SWIG_arg_fail(2)) SWIG_fail;
35792 }
35793 {
35794 arg3 = wxString_in_helper(obj2);
35795 if (arg3 == NULL) SWIG_fail;
35796 temp3 = true;
35797 }
35798 {
35799 PyThreadState* __tstate = wxPyBeginAllowThreads();
35800 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35801
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 Py_INCREF(Py_None); resultobj = Py_None;
35806 {
35807 if (temp3)
35808 delete arg3;
35809 }
35810 return resultobj;
35811 fail:
35812 {
35813 if (temp3)
35814 delete arg3;
35815 }
35816 return NULL;
35817 }
35818
35819
35820 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35821 PyObject *resultobj;
35822 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35823 int arg2 ;
35824 wxString result;
35825 PyObject * obj0 = 0 ;
35826 PyObject * obj1 = 0 ;
35827 char *kwnames[] = {
35828 (char *) "self",(char *) "id", NULL
35829 };
35830
35831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35833 if (SWIG_arg_fail(1)) SWIG_fail;
35834 {
35835 arg2 = (int)(SWIG_As_int(obj1));
35836 if (SWIG_arg_fail(2)) SWIG_fail;
35837 }
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35841
35842 wxPyEndAllowThreads(__tstate);
35843 if (PyErr_Occurred()) SWIG_fail;
35844 }
35845 {
35846 #if wxUSE_UNICODE
35847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35848 #else
35849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35850 #endif
35851 }
35852 return resultobj;
35853 fail:
35854 return NULL;
35855 }
35856
35857
35858 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35859 PyObject *resultobj;
35860 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35861 wxFrame *result;
35862 PyObject * obj0 = 0 ;
35863 char *kwnames[] = {
35864 (char *) "self", NULL
35865 };
35866
35867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35869 if (SWIG_arg_fail(1)) SWIG_fail;
35870 {
35871 PyThreadState* __tstate = wxPyBeginAllowThreads();
35872 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35873
35874 wxPyEndAllowThreads(__tstate);
35875 if (PyErr_Occurred()) SWIG_fail;
35876 }
35877 {
35878 resultobj = wxPyMake_wxObject(result, 0);
35879 }
35880 return resultobj;
35881 fail:
35882 return NULL;
35883 }
35884
35885
35886 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35887 PyObject *resultobj;
35888 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35889 bool result;
35890 PyObject * obj0 = 0 ;
35891 char *kwnames[] = {
35892 (char *) "self", NULL
35893 };
35894
35895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35897 if (SWIG_arg_fail(1)) SWIG_fail;
35898 {
35899 PyThreadState* __tstate = wxPyBeginAllowThreads();
35900 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35901
35902 wxPyEndAllowThreads(__tstate);
35903 if (PyErr_Occurred()) SWIG_fail;
35904 }
35905 {
35906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35907 }
35908 return resultobj;
35909 fail:
35910 return NULL;
35911 }
35912
35913
35914 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35915 PyObject *resultobj;
35916 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35917 wxFrame *arg2 = (wxFrame *) 0 ;
35918 PyObject * obj0 = 0 ;
35919 PyObject * obj1 = 0 ;
35920 char *kwnames[] = {
35921 (char *) "self",(char *) "frame", NULL
35922 };
35923
35924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35926 if (SWIG_arg_fail(1)) SWIG_fail;
35927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35928 if (SWIG_arg_fail(2)) SWIG_fail;
35929 {
35930 PyThreadState* __tstate = wxPyBeginAllowThreads();
35931 (arg1)->Attach(arg2);
35932
35933 wxPyEndAllowThreads(__tstate);
35934 if (PyErr_Occurred()) SWIG_fail;
35935 }
35936 Py_INCREF(Py_None); resultobj = Py_None;
35937 return resultobj;
35938 fail:
35939 return NULL;
35940 }
35941
35942
35943 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35944 PyObject *resultobj;
35945 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35946 PyObject * obj0 = 0 ;
35947 char *kwnames[] = {
35948 (char *) "self", NULL
35949 };
35950
35951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35953 if (SWIG_arg_fail(1)) SWIG_fail;
35954 {
35955 PyThreadState* __tstate = wxPyBeginAllowThreads();
35956 (arg1)->Detach();
35957
35958 wxPyEndAllowThreads(__tstate);
35959 if (PyErr_Occurred()) SWIG_fail;
35960 }
35961 Py_INCREF(Py_None); resultobj = Py_None;
35962 return resultobj;
35963 fail:
35964 return NULL;
35965 }
35966
35967
35968 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35969 PyObject *resultobj;
35970 bool arg1 ;
35971 PyObject * obj0 = 0 ;
35972 char *kwnames[] = {
35973 (char *) "enable", NULL
35974 };
35975
35976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
35977 {
35978 arg1 = (bool)(SWIG_As_bool(obj0));
35979 if (SWIG_arg_fail(1)) SWIG_fail;
35980 }
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 wxMenuBar::SetAutoWindowMenu(arg1);
35984
35985 wxPyEndAllowThreads(__tstate);
35986 if (PyErr_Occurred()) SWIG_fail;
35987 }
35988 Py_INCREF(Py_None); resultobj = Py_None;
35989 return resultobj;
35990 fail:
35991 return NULL;
35992 }
35993
35994
35995 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35996 PyObject *resultobj;
35997 bool result;
35998 char *kwnames[] = {
35999 NULL
36000 };
36001
36002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 result = (bool)wxMenuBar::GetAutoWindowMenu();
36006
36007 wxPyEndAllowThreads(__tstate);
36008 if (PyErr_Occurred()) SWIG_fail;
36009 }
36010 {
36011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36012 }
36013 return resultobj;
36014 fail:
36015 return NULL;
36016 }
36017
36018
36019 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36020 PyObject *obj;
36021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36022 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36023 Py_INCREF(obj);
36024 return Py_BuildValue((char *)"");
36025 }
36026 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36027 PyObject *resultobj;
36028 wxMenu *arg1 = (wxMenu *) NULL ;
36029 int arg2 = (int) wxID_ANY ;
36030 wxString const &arg3_defvalue = wxPyEmptyString ;
36031 wxString *arg3 = (wxString *) &arg3_defvalue ;
36032 wxString const &arg4_defvalue = wxPyEmptyString ;
36033 wxString *arg4 = (wxString *) &arg4_defvalue ;
36034 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36035 wxMenu *arg6 = (wxMenu *) NULL ;
36036 wxMenuItem *result;
36037 bool temp3 = false ;
36038 bool temp4 = false ;
36039 PyObject * obj0 = 0 ;
36040 PyObject * obj1 = 0 ;
36041 PyObject * obj2 = 0 ;
36042 PyObject * obj3 = 0 ;
36043 PyObject * obj4 = 0 ;
36044 PyObject * obj5 = 0 ;
36045 char *kwnames[] = {
36046 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36047 };
36048
36049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36050 if (obj0) {
36051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36052 if (SWIG_arg_fail(1)) SWIG_fail;
36053 }
36054 if (obj1) {
36055 {
36056 arg2 = (int)(SWIG_As_int(obj1));
36057 if (SWIG_arg_fail(2)) SWIG_fail;
36058 }
36059 }
36060 if (obj2) {
36061 {
36062 arg3 = wxString_in_helper(obj2);
36063 if (arg3 == NULL) SWIG_fail;
36064 temp3 = true;
36065 }
36066 }
36067 if (obj3) {
36068 {
36069 arg4 = wxString_in_helper(obj3);
36070 if (arg4 == NULL) SWIG_fail;
36071 temp4 = true;
36072 }
36073 }
36074 if (obj4) {
36075 {
36076 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36077 if (SWIG_arg_fail(5)) SWIG_fail;
36078 }
36079 }
36080 if (obj5) {
36081 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36082 if (SWIG_arg_fail(6)) SWIG_fail;
36083 }
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36087
36088 wxPyEndAllowThreads(__tstate);
36089 if (PyErr_Occurred()) SWIG_fail;
36090 }
36091 {
36092 resultobj = wxPyMake_wxObject(result, 1);
36093 }
36094 {
36095 if (temp3)
36096 delete arg3;
36097 }
36098 {
36099 if (temp4)
36100 delete arg4;
36101 }
36102 return resultobj;
36103 fail:
36104 {
36105 if (temp3)
36106 delete arg3;
36107 }
36108 {
36109 if (temp4)
36110 delete arg4;
36111 }
36112 return NULL;
36113 }
36114
36115
36116 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36117 PyObject *resultobj;
36118 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36119 wxMenu *result;
36120 PyObject * obj0 = 0 ;
36121 char *kwnames[] = {
36122 (char *) "self", NULL
36123 };
36124
36125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36127 if (SWIG_arg_fail(1)) SWIG_fail;
36128 {
36129 PyThreadState* __tstate = wxPyBeginAllowThreads();
36130 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36131
36132 wxPyEndAllowThreads(__tstate);
36133 if (PyErr_Occurred()) SWIG_fail;
36134 }
36135 {
36136 resultobj = wxPyMake_wxObject(result, 0);
36137 }
36138 return resultobj;
36139 fail:
36140 return NULL;
36141 }
36142
36143
36144 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36145 PyObject *resultobj;
36146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36147 wxMenu *arg2 = (wxMenu *) 0 ;
36148 PyObject * obj0 = 0 ;
36149 PyObject * obj1 = 0 ;
36150 char *kwnames[] = {
36151 (char *) "self",(char *) "menu", NULL
36152 };
36153
36154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36156 if (SWIG_arg_fail(1)) SWIG_fail;
36157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36158 if (SWIG_arg_fail(2)) SWIG_fail;
36159 {
36160 PyThreadState* __tstate = wxPyBeginAllowThreads();
36161 (arg1)->SetMenu(arg2);
36162
36163 wxPyEndAllowThreads(__tstate);
36164 if (PyErr_Occurred()) SWIG_fail;
36165 }
36166 Py_INCREF(Py_None); resultobj = Py_None;
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36174 PyObject *resultobj;
36175 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36176 int arg2 ;
36177 PyObject * obj0 = 0 ;
36178 PyObject * obj1 = 0 ;
36179 char *kwnames[] = {
36180 (char *) "self",(char *) "id", NULL
36181 };
36182
36183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36185 if (SWIG_arg_fail(1)) SWIG_fail;
36186 {
36187 arg2 = (int)(SWIG_As_int(obj1));
36188 if (SWIG_arg_fail(2)) SWIG_fail;
36189 }
36190 {
36191 PyThreadState* __tstate = wxPyBeginAllowThreads();
36192 (arg1)->SetId(arg2);
36193
36194 wxPyEndAllowThreads(__tstate);
36195 if (PyErr_Occurred()) SWIG_fail;
36196 }
36197 Py_INCREF(Py_None); resultobj = Py_None;
36198 return resultobj;
36199 fail:
36200 return NULL;
36201 }
36202
36203
36204 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36205 PyObject *resultobj;
36206 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36207 int result;
36208 PyObject * obj0 = 0 ;
36209 char *kwnames[] = {
36210 (char *) "self", NULL
36211 };
36212
36213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36215 if (SWIG_arg_fail(1)) SWIG_fail;
36216 {
36217 PyThreadState* __tstate = wxPyBeginAllowThreads();
36218 result = (int)((wxMenuItem const *)arg1)->GetId();
36219
36220 wxPyEndAllowThreads(__tstate);
36221 if (PyErr_Occurred()) SWIG_fail;
36222 }
36223 {
36224 resultobj = SWIG_From_int((int)(result));
36225 }
36226 return resultobj;
36227 fail:
36228 return NULL;
36229 }
36230
36231
36232 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36233 PyObject *resultobj;
36234 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36235 bool result;
36236 PyObject * obj0 = 0 ;
36237 char *kwnames[] = {
36238 (char *) "self", NULL
36239 };
36240
36241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36243 if (SWIG_arg_fail(1)) SWIG_fail;
36244 {
36245 PyThreadState* __tstate = wxPyBeginAllowThreads();
36246 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36247
36248 wxPyEndAllowThreads(__tstate);
36249 if (PyErr_Occurred()) SWIG_fail;
36250 }
36251 {
36252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36253 }
36254 return resultobj;
36255 fail:
36256 return NULL;
36257 }
36258
36259
36260 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36261 PyObject *resultobj;
36262 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36263 wxString *arg2 = 0 ;
36264 bool temp2 = false ;
36265 PyObject * obj0 = 0 ;
36266 PyObject * obj1 = 0 ;
36267 char *kwnames[] = {
36268 (char *) "self",(char *) "str", NULL
36269 };
36270
36271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36273 if (SWIG_arg_fail(1)) SWIG_fail;
36274 {
36275 arg2 = wxString_in_helper(obj1);
36276 if (arg2 == NULL) SWIG_fail;
36277 temp2 = true;
36278 }
36279 {
36280 PyThreadState* __tstate = wxPyBeginAllowThreads();
36281 (arg1)->SetText((wxString const &)*arg2);
36282
36283 wxPyEndAllowThreads(__tstate);
36284 if (PyErr_Occurred()) SWIG_fail;
36285 }
36286 Py_INCREF(Py_None); resultobj = Py_None;
36287 {
36288 if (temp2)
36289 delete arg2;
36290 }
36291 return resultobj;
36292 fail:
36293 {
36294 if (temp2)
36295 delete arg2;
36296 }
36297 return NULL;
36298 }
36299
36300
36301 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36302 PyObject *resultobj;
36303 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36304 wxString result;
36305 PyObject * obj0 = 0 ;
36306 char *kwnames[] = {
36307 (char *) "self", NULL
36308 };
36309
36310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36312 if (SWIG_arg_fail(1)) SWIG_fail;
36313 {
36314 PyThreadState* __tstate = wxPyBeginAllowThreads();
36315 result = ((wxMenuItem const *)arg1)->GetLabel();
36316
36317 wxPyEndAllowThreads(__tstate);
36318 if (PyErr_Occurred()) SWIG_fail;
36319 }
36320 {
36321 #if wxUSE_UNICODE
36322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36323 #else
36324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36325 #endif
36326 }
36327 return resultobj;
36328 fail:
36329 return NULL;
36330 }
36331
36332
36333 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36334 PyObject *resultobj;
36335 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36336 wxString *result;
36337 PyObject * obj0 = 0 ;
36338 char *kwnames[] = {
36339 (char *) "self", NULL
36340 };
36341
36342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36344 if (SWIG_arg_fail(1)) SWIG_fail;
36345 {
36346 PyThreadState* __tstate = wxPyBeginAllowThreads();
36347 {
36348 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36349 result = (wxString *) &_result_ref;
36350 }
36351
36352 wxPyEndAllowThreads(__tstate);
36353 if (PyErr_Occurred()) SWIG_fail;
36354 }
36355 {
36356 #if wxUSE_UNICODE
36357 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36358 #else
36359 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36360 #endif
36361 }
36362 return resultobj;
36363 fail:
36364 return NULL;
36365 }
36366
36367
36368 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36369 PyObject *resultobj;
36370 wxString *arg1 = 0 ;
36371 wxString result;
36372 bool temp1 = false ;
36373 PyObject * obj0 = 0 ;
36374 char *kwnames[] = {
36375 (char *) "text", NULL
36376 };
36377
36378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36379 {
36380 arg1 = wxString_in_helper(obj0);
36381 if (arg1 == NULL) SWIG_fail;
36382 temp1 = true;
36383 }
36384 {
36385 PyThreadState* __tstate = wxPyBeginAllowThreads();
36386 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36387
36388 wxPyEndAllowThreads(__tstate);
36389 if (PyErr_Occurred()) SWIG_fail;
36390 }
36391 {
36392 #if wxUSE_UNICODE
36393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36394 #else
36395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36396 #endif
36397 }
36398 {
36399 if (temp1)
36400 delete arg1;
36401 }
36402 return resultobj;
36403 fail:
36404 {
36405 if (temp1)
36406 delete arg1;
36407 }
36408 return NULL;
36409 }
36410
36411
36412 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36413 PyObject *resultobj;
36414 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36415 wxItemKind result;
36416 PyObject * obj0 = 0 ;
36417 char *kwnames[] = {
36418 (char *) "self", NULL
36419 };
36420
36421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36423 if (SWIG_arg_fail(1)) SWIG_fail;
36424 {
36425 PyThreadState* __tstate = wxPyBeginAllowThreads();
36426 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36427
36428 wxPyEndAllowThreads(__tstate);
36429 if (PyErr_Occurred()) SWIG_fail;
36430 }
36431 resultobj = SWIG_From_int((result));
36432 return resultobj;
36433 fail:
36434 return NULL;
36435 }
36436
36437
36438 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36439 PyObject *resultobj;
36440 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36441 wxItemKind arg2 ;
36442 PyObject * obj0 = 0 ;
36443 PyObject * obj1 = 0 ;
36444 char *kwnames[] = {
36445 (char *) "self",(char *) "kind", NULL
36446 };
36447
36448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36450 if (SWIG_arg_fail(1)) SWIG_fail;
36451 {
36452 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36453 if (SWIG_arg_fail(2)) SWIG_fail;
36454 }
36455 {
36456 PyThreadState* __tstate = wxPyBeginAllowThreads();
36457 (arg1)->SetKind((wxItemKind )arg2);
36458
36459 wxPyEndAllowThreads(__tstate);
36460 if (PyErr_Occurred()) SWIG_fail;
36461 }
36462 Py_INCREF(Py_None); resultobj = Py_None;
36463 return resultobj;
36464 fail:
36465 return NULL;
36466 }
36467
36468
36469 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36470 PyObject *resultobj;
36471 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36472 bool arg2 ;
36473 PyObject * obj0 = 0 ;
36474 PyObject * obj1 = 0 ;
36475 char *kwnames[] = {
36476 (char *) "self",(char *) "checkable", NULL
36477 };
36478
36479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36481 if (SWIG_arg_fail(1)) SWIG_fail;
36482 {
36483 arg2 = (bool)(SWIG_As_bool(obj1));
36484 if (SWIG_arg_fail(2)) SWIG_fail;
36485 }
36486 {
36487 PyThreadState* __tstate = wxPyBeginAllowThreads();
36488 (arg1)->SetCheckable(arg2);
36489
36490 wxPyEndAllowThreads(__tstate);
36491 if (PyErr_Occurred()) SWIG_fail;
36492 }
36493 Py_INCREF(Py_None); resultobj = Py_None;
36494 return resultobj;
36495 fail:
36496 return NULL;
36497 }
36498
36499
36500 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36501 PyObject *resultobj;
36502 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36503 bool result;
36504 PyObject * obj0 = 0 ;
36505 char *kwnames[] = {
36506 (char *) "self", NULL
36507 };
36508
36509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36511 if (SWIG_arg_fail(1)) SWIG_fail;
36512 {
36513 PyThreadState* __tstate = wxPyBeginAllowThreads();
36514 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36515
36516 wxPyEndAllowThreads(__tstate);
36517 if (PyErr_Occurred()) SWIG_fail;
36518 }
36519 {
36520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36521 }
36522 return resultobj;
36523 fail:
36524 return NULL;
36525 }
36526
36527
36528 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36529 PyObject *resultobj;
36530 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36531 bool result;
36532 PyObject * obj0 = 0 ;
36533 char *kwnames[] = {
36534 (char *) "self", NULL
36535 };
36536
36537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36539 if (SWIG_arg_fail(1)) SWIG_fail;
36540 {
36541 PyThreadState* __tstate = wxPyBeginAllowThreads();
36542 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36543
36544 wxPyEndAllowThreads(__tstate);
36545 if (PyErr_Occurred()) SWIG_fail;
36546 }
36547 {
36548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36549 }
36550 return resultobj;
36551 fail:
36552 return NULL;
36553 }
36554
36555
36556 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36557 PyObject *resultobj;
36558 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36559 wxMenu *arg2 = (wxMenu *) 0 ;
36560 PyObject * obj0 = 0 ;
36561 PyObject * obj1 = 0 ;
36562 char *kwnames[] = {
36563 (char *) "self",(char *) "menu", NULL
36564 };
36565
36566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36568 if (SWIG_arg_fail(1)) SWIG_fail;
36569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36570 if (SWIG_arg_fail(2)) SWIG_fail;
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 (arg1)->SetSubMenu(arg2);
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_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36586 PyObject *resultobj;
36587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36588 wxMenu *result;
36589 PyObject * obj0 = 0 ;
36590 char *kwnames[] = {
36591 (char *) "self", NULL
36592 };
36593
36594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36596 if (SWIG_arg_fail(1)) SWIG_fail;
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36600
36601 wxPyEndAllowThreads(__tstate);
36602 if (PyErr_Occurred()) SWIG_fail;
36603 }
36604 {
36605 resultobj = wxPyMake_wxObject(result, 0);
36606 }
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36614 PyObject *resultobj;
36615 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36616 bool arg2 = (bool) true ;
36617 PyObject * obj0 = 0 ;
36618 PyObject * obj1 = 0 ;
36619 char *kwnames[] = {
36620 (char *) "self",(char *) "enable", NULL
36621 };
36622
36623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36625 if (SWIG_arg_fail(1)) SWIG_fail;
36626 if (obj1) {
36627 {
36628 arg2 = (bool)(SWIG_As_bool(obj1));
36629 if (SWIG_arg_fail(2)) SWIG_fail;
36630 }
36631 }
36632 {
36633 PyThreadState* __tstate = wxPyBeginAllowThreads();
36634 (arg1)->Enable(arg2);
36635
36636 wxPyEndAllowThreads(__tstate);
36637 if (PyErr_Occurred()) SWIG_fail;
36638 }
36639 Py_INCREF(Py_None); resultobj = Py_None;
36640 return resultobj;
36641 fail:
36642 return NULL;
36643 }
36644
36645
36646 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36647 PyObject *resultobj;
36648 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36649 bool result;
36650 PyObject * obj0 = 0 ;
36651 char *kwnames[] = {
36652 (char *) "self", NULL
36653 };
36654
36655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36657 if (SWIG_arg_fail(1)) SWIG_fail;
36658 {
36659 PyThreadState* __tstate = wxPyBeginAllowThreads();
36660 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36661
36662 wxPyEndAllowThreads(__tstate);
36663 if (PyErr_Occurred()) SWIG_fail;
36664 }
36665 {
36666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36667 }
36668 return resultobj;
36669 fail:
36670 return NULL;
36671 }
36672
36673
36674 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36675 PyObject *resultobj;
36676 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36677 bool arg2 = (bool) true ;
36678 PyObject * obj0 = 0 ;
36679 PyObject * obj1 = 0 ;
36680 char *kwnames[] = {
36681 (char *) "self",(char *) "check", NULL
36682 };
36683
36684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36686 if (SWIG_arg_fail(1)) SWIG_fail;
36687 if (obj1) {
36688 {
36689 arg2 = (bool)(SWIG_As_bool(obj1));
36690 if (SWIG_arg_fail(2)) SWIG_fail;
36691 }
36692 }
36693 {
36694 PyThreadState* __tstate = wxPyBeginAllowThreads();
36695 (arg1)->Check(arg2);
36696
36697 wxPyEndAllowThreads(__tstate);
36698 if (PyErr_Occurred()) SWIG_fail;
36699 }
36700 Py_INCREF(Py_None); resultobj = Py_None;
36701 return resultobj;
36702 fail:
36703 return NULL;
36704 }
36705
36706
36707 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36708 PyObject *resultobj;
36709 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36710 bool result;
36711 PyObject * obj0 = 0 ;
36712 char *kwnames[] = {
36713 (char *) "self", NULL
36714 };
36715
36716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36718 if (SWIG_arg_fail(1)) SWIG_fail;
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36722
36723 wxPyEndAllowThreads(__tstate);
36724 if (PyErr_Occurred()) SWIG_fail;
36725 }
36726 {
36727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36728 }
36729 return resultobj;
36730 fail:
36731 return NULL;
36732 }
36733
36734
36735 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36736 PyObject *resultobj;
36737 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36738 PyObject * obj0 = 0 ;
36739 char *kwnames[] = {
36740 (char *) "self", NULL
36741 };
36742
36743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36745 if (SWIG_arg_fail(1)) SWIG_fail;
36746 {
36747 PyThreadState* __tstate = wxPyBeginAllowThreads();
36748 (arg1)->Toggle();
36749
36750 wxPyEndAllowThreads(__tstate);
36751 if (PyErr_Occurred()) SWIG_fail;
36752 }
36753 Py_INCREF(Py_None); resultobj = Py_None;
36754 return resultobj;
36755 fail:
36756 return NULL;
36757 }
36758
36759
36760 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36761 PyObject *resultobj;
36762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36763 wxString *arg2 = 0 ;
36764 bool temp2 = false ;
36765 PyObject * obj0 = 0 ;
36766 PyObject * obj1 = 0 ;
36767 char *kwnames[] = {
36768 (char *) "self",(char *) "str", NULL
36769 };
36770
36771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36773 if (SWIG_arg_fail(1)) SWIG_fail;
36774 {
36775 arg2 = wxString_in_helper(obj1);
36776 if (arg2 == NULL) SWIG_fail;
36777 temp2 = true;
36778 }
36779 {
36780 PyThreadState* __tstate = wxPyBeginAllowThreads();
36781 (arg1)->SetHelp((wxString const &)*arg2);
36782
36783 wxPyEndAllowThreads(__tstate);
36784 if (PyErr_Occurred()) SWIG_fail;
36785 }
36786 Py_INCREF(Py_None); resultobj = Py_None;
36787 {
36788 if (temp2)
36789 delete arg2;
36790 }
36791 return resultobj;
36792 fail:
36793 {
36794 if (temp2)
36795 delete arg2;
36796 }
36797 return NULL;
36798 }
36799
36800
36801 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36802 PyObject *resultobj;
36803 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36804 wxString *result;
36805 PyObject * obj0 = 0 ;
36806 char *kwnames[] = {
36807 (char *) "self", NULL
36808 };
36809
36810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36812 if (SWIG_arg_fail(1)) SWIG_fail;
36813 {
36814 PyThreadState* __tstate = wxPyBeginAllowThreads();
36815 {
36816 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36817 result = (wxString *) &_result_ref;
36818 }
36819
36820 wxPyEndAllowThreads(__tstate);
36821 if (PyErr_Occurred()) SWIG_fail;
36822 }
36823 {
36824 #if wxUSE_UNICODE
36825 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36826 #else
36827 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36828 #endif
36829 }
36830 return resultobj;
36831 fail:
36832 return NULL;
36833 }
36834
36835
36836 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36837 PyObject *resultobj;
36838 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36839 wxAcceleratorEntry *result;
36840 PyObject * obj0 = 0 ;
36841 char *kwnames[] = {
36842 (char *) "self", NULL
36843 };
36844
36845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36847 if (SWIG_arg_fail(1)) SWIG_fail;
36848 {
36849 PyThreadState* __tstate = wxPyBeginAllowThreads();
36850 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36851
36852 wxPyEndAllowThreads(__tstate);
36853 if (PyErr_Occurred()) SWIG_fail;
36854 }
36855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36856 return resultobj;
36857 fail:
36858 return NULL;
36859 }
36860
36861
36862 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36863 PyObject *resultobj;
36864 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36865 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36866 PyObject * obj0 = 0 ;
36867 PyObject * obj1 = 0 ;
36868 char *kwnames[] = {
36869 (char *) "self",(char *) "accel", NULL
36870 };
36871
36872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36874 if (SWIG_arg_fail(1)) SWIG_fail;
36875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36876 if (SWIG_arg_fail(2)) SWIG_fail;
36877 {
36878 PyThreadState* __tstate = wxPyBeginAllowThreads();
36879 (arg1)->SetAccel(arg2);
36880
36881 wxPyEndAllowThreads(__tstate);
36882 if (PyErr_Occurred()) SWIG_fail;
36883 }
36884 Py_INCREF(Py_None); resultobj = Py_None;
36885 return resultobj;
36886 fail:
36887 return NULL;
36888 }
36889
36890
36891 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36892 PyObject *resultobj;
36893 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36894 wxFont *arg2 = 0 ;
36895 PyObject * obj0 = 0 ;
36896 PyObject * obj1 = 0 ;
36897 char *kwnames[] = {
36898 (char *) "self",(char *) "font", NULL
36899 };
36900
36901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36903 if (SWIG_arg_fail(1)) SWIG_fail;
36904 {
36905 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36906 if (SWIG_arg_fail(2)) SWIG_fail;
36907 if (arg2 == NULL) {
36908 SWIG_null_ref("wxFont");
36909 }
36910 if (SWIG_arg_fail(2)) SWIG_fail;
36911 }
36912 {
36913 PyThreadState* __tstate = wxPyBeginAllowThreads();
36914 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36915
36916 wxPyEndAllowThreads(__tstate);
36917 if (PyErr_Occurred()) SWIG_fail;
36918 }
36919 Py_INCREF(Py_None); resultobj = Py_None;
36920 return resultobj;
36921 fail:
36922 return NULL;
36923 }
36924
36925
36926 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36927 PyObject *resultobj;
36928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36929 wxFont result;
36930 PyObject * obj0 = 0 ;
36931 char *kwnames[] = {
36932 (char *) "self", NULL
36933 };
36934
36935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36937 if (SWIG_arg_fail(1)) SWIG_fail;
36938 {
36939 PyThreadState* __tstate = wxPyBeginAllowThreads();
36940 result = wxMenuItem_GetFont(arg1);
36941
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 {
36946 wxFont * resultptr;
36947 resultptr = new wxFont((wxFont &)(result));
36948 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36949 }
36950 return resultobj;
36951 fail:
36952 return NULL;
36953 }
36954
36955
36956 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36957 PyObject *resultobj;
36958 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36959 wxColour *arg2 = 0 ;
36960 wxColour temp2 ;
36961 PyObject * obj0 = 0 ;
36962 PyObject * obj1 = 0 ;
36963 char *kwnames[] = {
36964 (char *) "self",(char *) "colText", NULL
36965 };
36966
36967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36969 if (SWIG_arg_fail(1)) SWIG_fail;
36970 {
36971 arg2 = &temp2;
36972 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36973 }
36974 {
36975 PyThreadState* __tstate = wxPyBeginAllowThreads();
36976 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36977
36978 wxPyEndAllowThreads(__tstate);
36979 if (PyErr_Occurred()) SWIG_fail;
36980 }
36981 Py_INCREF(Py_None); resultobj = Py_None;
36982 return resultobj;
36983 fail:
36984 return NULL;
36985 }
36986
36987
36988 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36989 PyObject *resultobj;
36990 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36991 wxColour result;
36992 PyObject * obj0 = 0 ;
36993 char *kwnames[] = {
36994 (char *) "self", NULL
36995 };
36996
36997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36999 if (SWIG_arg_fail(1)) SWIG_fail;
37000 {
37001 PyThreadState* __tstate = wxPyBeginAllowThreads();
37002 result = wxMenuItem_GetTextColour(arg1);
37003
37004 wxPyEndAllowThreads(__tstate);
37005 if (PyErr_Occurred()) SWIG_fail;
37006 }
37007 {
37008 wxColour * resultptr;
37009 resultptr = new wxColour((wxColour &)(result));
37010 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37011 }
37012 return resultobj;
37013 fail:
37014 return NULL;
37015 }
37016
37017
37018 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37019 PyObject *resultobj;
37020 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37021 wxColour *arg2 = 0 ;
37022 wxColour temp2 ;
37023 PyObject * obj0 = 0 ;
37024 PyObject * obj1 = 0 ;
37025 char *kwnames[] = {
37026 (char *) "self",(char *) "colBack", NULL
37027 };
37028
37029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37031 if (SWIG_arg_fail(1)) SWIG_fail;
37032 {
37033 arg2 = &temp2;
37034 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37035 }
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37039
37040 wxPyEndAllowThreads(__tstate);
37041 if (PyErr_Occurred()) SWIG_fail;
37042 }
37043 Py_INCREF(Py_None); resultobj = Py_None;
37044 return resultobj;
37045 fail:
37046 return NULL;
37047 }
37048
37049
37050 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37051 PyObject *resultobj;
37052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37053 wxColour result;
37054 PyObject * obj0 = 0 ;
37055 char *kwnames[] = {
37056 (char *) "self", NULL
37057 };
37058
37059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37061 if (SWIG_arg_fail(1)) SWIG_fail;
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 result = wxMenuItem_GetBackgroundColour(arg1);
37065
37066 wxPyEndAllowThreads(__tstate);
37067 if (PyErr_Occurred()) SWIG_fail;
37068 }
37069 {
37070 wxColour * resultptr;
37071 resultptr = new wxColour((wxColour &)(result));
37072 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37073 }
37074 return resultobj;
37075 fail:
37076 return NULL;
37077 }
37078
37079
37080 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37081 PyObject *resultobj;
37082 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37083 wxBitmap *arg2 = 0 ;
37084 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37085 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37086 PyObject * obj0 = 0 ;
37087 PyObject * obj1 = 0 ;
37088 PyObject * obj2 = 0 ;
37089 char *kwnames[] = {
37090 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37091 };
37092
37093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37095 if (SWIG_arg_fail(1)) SWIG_fail;
37096 {
37097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37098 if (SWIG_arg_fail(2)) SWIG_fail;
37099 if (arg2 == NULL) {
37100 SWIG_null_ref("wxBitmap");
37101 }
37102 if (SWIG_arg_fail(2)) SWIG_fail;
37103 }
37104 if (obj2) {
37105 {
37106 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37107 if (SWIG_arg_fail(3)) SWIG_fail;
37108 if (arg3 == NULL) {
37109 SWIG_null_ref("wxBitmap");
37110 }
37111 if (SWIG_arg_fail(3)) SWIG_fail;
37112 }
37113 }
37114 {
37115 PyThreadState* __tstate = wxPyBeginAllowThreads();
37116 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37117
37118 wxPyEndAllowThreads(__tstate);
37119 if (PyErr_Occurred()) SWIG_fail;
37120 }
37121 Py_INCREF(Py_None); resultobj = Py_None;
37122 return resultobj;
37123 fail:
37124 return NULL;
37125 }
37126
37127
37128 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37129 PyObject *resultobj;
37130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37131 wxBitmap *arg2 = 0 ;
37132 PyObject * obj0 = 0 ;
37133 PyObject * obj1 = 0 ;
37134 char *kwnames[] = {
37135 (char *) "self",(char *) "bmpDisabled", NULL
37136 };
37137
37138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37140 if (SWIG_arg_fail(1)) SWIG_fail;
37141 {
37142 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37143 if (SWIG_arg_fail(2)) SWIG_fail;
37144 if (arg2 == NULL) {
37145 SWIG_null_ref("wxBitmap");
37146 }
37147 if (SWIG_arg_fail(2)) SWIG_fail;
37148 }
37149 {
37150 PyThreadState* __tstate = wxPyBeginAllowThreads();
37151 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37152
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 Py_INCREF(Py_None); resultobj = Py_None;
37157 return resultobj;
37158 fail:
37159 return NULL;
37160 }
37161
37162
37163 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37164 PyObject *resultobj;
37165 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37166 wxBitmap *result;
37167 PyObject * obj0 = 0 ;
37168 char *kwnames[] = {
37169 (char *) "self", NULL
37170 };
37171
37172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37174 if (SWIG_arg_fail(1)) SWIG_fail;
37175 {
37176 PyThreadState* __tstate = wxPyBeginAllowThreads();
37177 {
37178 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37179 result = (wxBitmap *) &_result_ref;
37180 }
37181
37182 wxPyEndAllowThreads(__tstate);
37183 if (PyErr_Occurred()) SWIG_fail;
37184 }
37185 {
37186 wxBitmap* resultptr = new wxBitmap(*result);
37187 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37188 }
37189 return resultobj;
37190 fail:
37191 return NULL;
37192 }
37193
37194
37195 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37196 PyObject *resultobj;
37197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37198 int arg2 ;
37199 PyObject * obj0 = 0 ;
37200 PyObject * obj1 = 0 ;
37201 char *kwnames[] = {
37202 (char *) "self",(char *) "nWidth", NULL
37203 };
37204
37205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37207 if (SWIG_arg_fail(1)) SWIG_fail;
37208 {
37209 arg2 = (int)(SWIG_As_int(obj1));
37210 if (SWIG_arg_fail(2)) SWIG_fail;
37211 }
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 wxMenuItem_SetMarginWidth(arg1,arg2);
37215
37216 wxPyEndAllowThreads(__tstate);
37217 if (PyErr_Occurred()) SWIG_fail;
37218 }
37219 Py_INCREF(Py_None); resultobj = Py_None;
37220 return resultobj;
37221 fail:
37222 return NULL;
37223 }
37224
37225
37226 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37227 PyObject *resultobj;
37228 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37229 int result;
37230 PyObject * obj0 = 0 ;
37231 char *kwnames[] = {
37232 (char *) "self", NULL
37233 };
37234
37235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37237 if (SWIG_arg_fail(1)) SWIG_fail;
37238 {
37239 PyThreadState* __tstate = wxPyBeginAllowThreads();
37240 result = (int)wxMenuItem_GetMarginWidth(arg1);
37241
37242 wxPyEndAllowThreads(__tstate);
37243 if (PyErr_Occurred()) SWIG_fail;
37244 }
37245 {
37246 resultobj = SWIG_From_int((int)(result));
37247 }
37248 return resultobj;
37249 fail:
37250 return NULL;
37251 }
37252
37253
37254 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37255 PyObject *resultobj;
37256 int result;
37257 char *kwnames[] = {
37258 NULL
37259 };
37260
37261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37262 {
37263 PyThreadState* __tstate = wxPyBeginAllowThreads();
37264 result = (int)MenuItem_GetDefaultMarginWidth();
37265
37266 wxPyEndAllowThreads(__tstate);
37267 if (PyErr_Occurred()) SWIG_fail;
37268 }
37269 {
37270 resultobj = SWIG_From_int((int)(result));
37271 }
37272 return resultobj;
37273 fail:
37274 return NULL;
37275 }
37276
37277
37278 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37279 PyObject *resultobj;
37280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37281 bool result;
37282 PyObject * obj0 = 0 ;
37283 char *kwnames[] = {
37284 (char *) "self", NULL
37285 };
37286
37287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37289 if (SWIG_arg_fail(1)) SWIG_fail;
37290 {
37291 PyThreadState* __tstate = wxPyBeginAllowThreads();
37292 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37293
37294 wxPyEndAllowThreads(__tstate);
37295 if (PyErr_Occurred()) SWIG_fail;
37296 }
37297 {
37298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37299 }
37300 return resultobj;
37301 fail:
37302 return NULL;
37303 }
37304
37305
37306 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37307 PyObject *resultobj;
37308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37309 bool arg2 = (bool) true ;
37310 PyObject * obj0 = 0 ;
37311 PyObject * obj1 = 0 ;
37312 char *kwnames[] = {
37313 (char *) "self",(char *) "ownerDrawn", NULL
37314 };
37315
37316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37318 if (SWIG_arg_fail(1)) SWIG_fail;
37319 if (obj1) {
37320 {
37321 arg2 = (bool)(SWIG_As_bool(obj1));
37322 if (SWIG_arg_fail(2)) SWIG_fail;
37323 }
37324 }
37325 {
37326 PyThreadState* __tstate = wxPyBeginAllowThreads();
37327 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37328
37329 wxPyEndAllowThreads(__tstate);
37330 if (PyErr_Occurred()) SWIG_fail;
37331 }
37332 Py_INCREF(Py_None); resultobj = Py_None;
37333 return resultobj;
37334 fail:
37335 return NULL;
37336 }
37337
37338
37339 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37340 PyObject *resultobj;
37341 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37342 PyObject * obj0 = 0 ;
37343 char *kwnames[] = {
37344 (char *) "self", NULL
37345 };
37346
37347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37349 if (SWIG_arg_fail(1)) SWIG_fail;
37350 {
37351 PyThreadState* __tstate = wxPyBeginAllowThreads();
37352 wxMenuItem_ResetOwnerDrawn(arg1);
37353
37354 wxPyEndAllowThreads(__tstate);
37355 if (PyErr_Occurred()) SWIG_fail;
37356 }
37357 Py_INCREF(Py_None); resultobj = Py_None;
37358 return resultobj;
37359 fail:
37360 return NULL;
37361 }
37362
37363
37364 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37365 PyObject *resultobj;
37366 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37367 wxBitmap *arg2 = 0 ;
37368 PyObject * obj0 = 0 ;
37369 PyObject * obj1 = 0 ;
37370 char *kwnames[] = {
37371 (char *) "self",(char *) "bitmap", NULL
37372 };
37373
37374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37376 if (SWIG_arg_fail(1)) SWIG_fail;
37377 {
37378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37379 if (SWIG_arg_fail(2)) SWIG_fail;
37380 if (arg2 == NULL) {
37381 SWIG_null_ref("wxBitmap");
37382 }
37383 if (SWIG_arg_fail(2)) SWIG_fail;
37384 }
37385 {
37386 PyThreadState* __tstate = wxPyBeginAllowThreads();
37387 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37388
37389 wxPyEndAllowThreads(__tstate);
37390 if (PyErr_Occurred()) SWIG_fail;
37391 }
37392 Py_INCREF(Py_None); resultobj = Py_None;
37393 return resultobj;
37394 fail:
37395 return NULL;
37396 }
37397
37398
37399 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37400 PyObject *resultobj;
37401 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37402 wxBitmap *result;
37403 PyObject * obj0 = 0 ;
37404 char *kwnames[] = {
37405 (char *) "self", NULL
37406 };
37407
37408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37410 if (SWIG_arg_fail(1)) SWIG_fail;
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 {
37414 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37415 result = (wxBitmap *) &_result_ref;
37416 }
37417
37418 wxPyEndAllowThreads(__tstate);
37419 if (PyErr_Occurred()) SWIG_fail;
37420 }
37421 {
37422 wxBitmap* resultptr = new wxBitmap(*result);
37423 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37424 }
37425 return resultobj;
37426 fail:
37427 return NULL;
37428 }
37429
37430
37431 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37432 PyObject *obj;
37433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37434 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37435 Py_INCREF(obj);
37436 return Py_BuildValue((char *)"");
37437 }
37438 static int _wrap_ControlNameStr_set(PyObject *) {
37439 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37440 return 1;
37441 }
37442
37443
37444 static PyObject *_wrap_ControlNameStr_get(void) {
37445 PyObject *pyobj;
37446
37447 {
37448 #if wxUSE_UNICODE
37449 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37450 #else
37451 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37452 #endif
37453 }
37454 return pyobj;
37455 }
37456
37457
37458 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37459 PyObject *resultobj;
37460 wxWindow *arg1 = (wxWindow *) 0 ;
37461 int arg2 = (int) -1 ;
37462 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37463 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37464 wxSize const &arg4_defvalue = wxDefaultSize ;
37465 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37466 long arg5 = (long) 0 ;
37467 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37468 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37469 wxString const &arg7_defvalue = wxPyControlNameStr ;
37470 wxString *arg7 = (wxString *) &arg7_defvalue ;
37471 wxControl *result;
37472 wxPoint temp3 ;
37473 wxSize temp4 ;
37474 bool temp7 = false ;
37475 PyObject * obj0 = 0 ;
37476 PyObject * obj1 = 0 ;
37477 PyObject * obj2 = 0 ;
37478 PyObject * obj3 = 0 ;
37479 PyObject * obj4 = 0 ;
37480 PyObject * obj5 = 0 ;
37481 PyObject * obj6 = 0 ;
37482 char *kwnames[] = {
37483 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37484 };
37485
37486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37488 if (SWIG_arg_fail(1)) SWIG_fail;
37489 if (obj1) {
37490 {
37491 arg2 = (int)(SWIG_As_int(obj1));
37492 if (SWIG_arg_fail(2)) SWIG_fail;
37493 }
37494 }
37495 if (obj2) {
37496 {
37497 arg3 = &temp3;
37498 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37499 }
37500 }
37501 if (obj3) {
37502 {
37503 arg4 = &temp4;
37504 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37505 }
37506 }
37507 if (obj4) {
37508 {
37509 arg5 = (long)(SWIG_As_long(obj4));
37510 if (SWIG_arg_fail(5)) SWIG_fail;
37511 }
37512 }
37513 if (obj5) {
37514 {
37515 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37516 if (SWIG_arg_fail(6)) SWIG_fail;
37517 if (arg6 == NULL) {
37518 SWIG_null_ref("wxValidator");
37519 }
37520 if (SWIG_arg_fail(6)) SWIG_fail;
37521 }
37522 }
37523 if (obj6) {
37524 {
37525 arg7 = wxString_in_helper(obj6);
37526 if (arg7 == NULL) SWIG_fail;
37527 temp7 = true;
37528 }
37529 }
37530 {
37531 if (!wxPyCheckForApp()) SWIG_fail;
37532 PyThreadState* __tstate = wxPyBeginAllowThreads();
37533 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37534
37535 wxPyEndAllowThreads(__tstate);
37536 if (PyErr_Occurred()) SWIG_fail;
37537 }
37538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37539 {
37540 if (temp7)
37541 delete arg7;
37542 }
37543 return resultobj;
37544 fail:
37545 {
37546 if (temp7)
37547 delete arg7;
37548 }
37549 return NULL;
37550 }
37551
37552
37553 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37554 PyObject *resultobj;
37555 wxControl *result;
37556 char *kwnames[] = {
37557 NULL
37558 };
37559
37560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37561 {
37562 if (!wxPyCheckForApp()) SWIG_fail;
37563 PyThreadState* __tstate = wxPyBeginAllowThreads();
37564 result = (wxControl *)new wxControl();
37565
37566 wxPyEndAllowThreads(__tstate);
37567 if (PyErr_Occurred()) SWIG_fail;
37568 }
37569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37570 return resultobj;
37571 fail:
37572 return NULL;
37573 }
37574
37575
37576 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37577 PyObject *resultobj;
37578 wxControl *arg1 = (wxControl *) 0 ;
37579 wxWindow *arg2 = (wxWindow *) 0 ;
37580 int arg3 = (int) -1 ;
37581 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37582 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37583 wxSize const &arg5_defvalue = wxDefaultSize ;
37584 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37585 long arg6 = (long) 0 ;
37586 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37587 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37588 wxString const &arg8_defvalue = wxPyControlNameStr ;
37589 wxString *arg8 = (wxString *) &arg8_defvalue ;
37590 bool result;
37591 wxPoint temp4 ;
37592 wxSize temp5 ;
37593 bool temp8 = false ;
37594 PyObject * obj0 = 0 ;
37595 PyObject * obj1 = 0 ;
37596 PyObject * obj2 = 0 ;
37597 PyObject * obj3 = 0 ;
37598 PyObject * obj4 = 0 ;
37599 PyObject * obj5 = 0 ;
37600 PyObject * obj6 = 0 ;
37601 PyObject * obj7 = 0 ;
37602 char *kwnames[] = {
37603 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37604 };
37605
37606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37608 if (SWIG_arg_fail(1)) SWIG_fail;
37609 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37610 if (SWIG_arg_fail(2)) SWIG_fail;
37611 if (obj2) {
37612 {
37613 arg3 = (int)(SWIG_As_int(obj2));
37614 if (SWIG_arg_fail(3)) SWIG_fail;
37615 }
37616 }
37617 if (obj3) {
37618 {
37619 arg4 = &temp4;
37620 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37621 }
37622 }
37623 if (obj4) {
37624 {
37625 arg5 = &temp5;
37626 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37627 }
37628 }
37629 if (obj5) {
37630 {
37631 arg6 = (long)(SWIG_As_long(obj5));
37632 if (SWIG_arg_fail(6)) SWIG_fail;
37633 }
37634 }
37635 if (obj6) {
37636 {
37637 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37638 if (SWIG_arg_fail(7)) SWIG_fail;
37639 if (arg7 == NULL) {
37640 SWIG_null_ref("wxValidator");
37641 }
37642 if (SWIG_arg_fail(7)) SWIG_fail;
37643 }
37644 }
37645 if (obj7) {
37646 {
37647 arg8 = wxString_in_helper(obj7);
37648 if (arg8 == NULL) SWIG_fail;
37649 temp8 = true;
37650 }
37651 }
37652 {
37653 PyThreadState* __tstate = wxPyBeginAllowThreads();
37654 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37655
37656 wxPyEndAllowThreads(__tstate);
37657 if (PyErr_Occurred()) SWIG_fail;
37658 }
37659 {
37660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37661 }
37662 {
37663 if (temp8)
37664 delete arg8;
37665 }
37666 return resultobj;
37667 fail:
37668 {
37669 if (temp8)
37670 delete arg8;
37671 }
37672 return NULL;
37673 }
37674
37675
37676 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37677 PyObject *resultobj;
37678 wxControl *arg1 = (wxControl *) 0 ;
37679 wxCommandEvent *arg2 = 0 ;
37680 PyObject * obj0 = 0 ;
37681 PyObject * obj1 = 0 ;
37682 char *kwnames[] = {
37683 (char *) "self",(char *) "event", NULL
37684 };
37685
37686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37688 if (SWIG_arg_fail(1)) SWIG_fail;
37689 {
37690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37691 if (SWIG_arg_fail(2)) SWIG_fail;
37692 if (arg2 == NULL) {
37693 SWIG_null_ref("wxCommandEvent");
37694 }
37695 if (SWIG_arg_fail(2)) SWIG_fail;
37696 }
37697 {
37698 PyThreadState* __tstate = wxPyBeginAllowThreads();
37699 (arg1)->Command(*arg2);
37700
37701 wxPyEndAllowThreads(__tstate);
37702 if (PyErr_Occurred()) SWIG_fail;
37703 }
37704 Py_INCREF(Py_None); resultobj = Py_None;
37705 return resultobj;
37706 fail:
37707 return NULL;
37708 }
37709
37710
37711 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37712 PyObject *resultobj;
37713 wxControl *arg1 = (wxControl *) 0 ;
37714 wxString result;
37715 PyObject * obj0 = 0 ;
37716 char *kwnames[] = {
37717 (char *) "self", NULL
37718 };
37719
37720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37722 if (SWIG_arg_fail(1)) SWIG_fail;
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 result = (arg1)->GetLabel();
37726
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 {
37731 #if wxUSE_UNICODE
37732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37733 #else
37734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37735 #endif
37736 }
37737 return resultobj;
37738 fail:
37739 return NULL;
37740 }
37741
37742
37743 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37744 PyObject *resultobj;
37745 wxControl *arg1 = (wxControl *) 0 ;
37746 wxString *arg2 = 0 ;
37747 bool temp2 = false ;
37748 PyObject * obj0 = 0 ;
37749 PyObject * obj1 = 0 ;
37750 char *kwnames[] = {
37751 (char *) "self",(char *) "label", NULL
37752 };
37753
37754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37756 if (SWIG_arg_fail(1)) SWIG_fail;
37757 {
37758 arg2 = wxString_in_helper(obj1);
37759 if (arg2 == NULL) SWIG_fail;
37760 temp2 = true;
37761 }
37762 {
37763 PyThreadState* __tstate = wxPyBeginAllowThreads();
37764 (arg1)->SetLabel((wxString const &)*arg2);
37765
37766 wxPyEndAllowThreads(__tstate);
37767 if (PyErr_Occurred()) SWIG_fail;
37768 }
37769 Py_INCREF(Py_None); resultobj = Py_None;
37770 {
37771 if (temp2)
37772 delete arg2;
37773 }
37774 return resultobj;
37775 fail:
37776 {
37777 if (temp2)
37778 delete arg2;
37779 }
37780 return NULL;
37781 }
37782
37783
37784 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37785 PyObject *resultobj;
37786 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37787 wxVisualAttributes result;
37788 PyObject * obj0 = 0 ;
37789 char *kwnames[] = {
37790 (char *) "variant", NULL
37791 };
37792
37793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37794 if (obj0) {
37795 {
37796 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37797 if (SWIG_arg_fail(1)) SWIG_fail;
37798 }
37799 }
37800 {
37801 if (!wxPyCheckForApp()) SWIG_fail;
37802 PyThreadState* __tstate = wxPyBeginAllowThreads();
37803 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37804
37805 wxPyEndAllowThreads(__tstate);
37806 if (PyErr_Occurred()) SWIG_fail;
37807 }
37808 {
37809 wxVisualAttributes * resultptr;
37810 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37811 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37812 }
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37820 PyObject *obj;
37821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37822 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37823 Py_INCREF(obj);
37824 return Py_BuildValue((char *)"");
37825 }
37826 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37827 PyObject *resultobj;
37828 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37829 wxString *arg2 = 0 ;
37830 PyObject *arg3 = (PyObject *) NULL ;
37831 int result;
37832 bool temp2 = false ;
37833 PyObject * obj0 = 0 ;
37834 PyObject * obj1 = 0 ;
37835 PyObject * obj2 = 0 ;
37836 char *kwnames[] = {
37837 (char *) "self",(char *) "item",(char *) "clientData", NULL
37838 };
37839
37840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37842 if (SWIG_arg_fail(1)) SWIG_fail;
37843 {
37844 arg2 = wxString_in_helper(obj1);
37845 if (arg2 == NULL) SWIG_fail;
37846 temp2 = true;
37847 }
37848 if (obj2) {
37849 arg3 = obj2;
37850 }
37851 {
37852 PyThreadState* __tstate = wxPyBeginAllowThreads();
37853 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37854
37855 wxPyEndAllowThreads(__tstate);
37856 if (PyErr_Occurred()) SWIG_fail;
37857 }
37858 {
37859 resultobj = SWIG_From_int((int)(result));
37860 }
37861 {
37862 if (temp2)
37863 delete arg2;
37864 }
37865 return resultobj;
37866 fail:
37867 {
37868 if (temp2)
37869 delete arg2;
37870 }
37871 return NULL;
37872 }
37873
37874
37875 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37876 PyObject *resultobj;
37877 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37878 wxArrayString *arg2 = 0 ;
37879 bool temp2 = false ;
37880 PyObject * obj0 = 0 ;
37881 PyObject * obj1 = 0 ;
37882 char *kwnames[] = {
37883 (char *) "self",(char *) "strings", NULL
37884 };
37885
37886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37888 if (SWIG_arg_fail(1)) SWIG_fail;
37889 {
37890 if (! PySequence_Check(obj1)) {
37891 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37892 SWIG_fail;
37893 }
37894 arg2 = new wxArrayString;
37895 temp2 = true;
37896 int i, len=PySequence_Length(obj1);
37897 for (i=0; i<len; i++) {
37898 PyObject* item = PySequence_GetItem(obj1, i);
37899 wxString* s = wxString_in_helper(item);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 arg2->Add(*s);
37902 delete s;
37903 Py_DECREF(item);
37904 }
37905 }
37906 {
37907 PyThreadState* __tstate = wxPyBeginAllowThreads();
37908 (arg1)->Append((wxArrayString const &)*arg2);
37909
37910 wxPyEndAllowThreads(__tstate);
37911 if (PyErr_Occurred()) SWIG_fail;
37912 }
37913 Py_INCREF(Py_None); resultobj = Py_None;
37914 {
37915 if (temp2) delete arg2;
37916 }
37917 return resultobj;
37918 fail:
37919 {
37920 if (temp2) delete arg2;
37921 }
37922 return NULL;
37923 }
37924
37925
37926 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37927 PyObject *resultobj;
37928 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37929 wxString *arg2 = 0 ;
37930 int arg3 ;
37931 PyObject *arg4 = (PyObject *) NULL ;
37932 int result;
37933 bool temp2 = false ;
37934 PyObject * obj0 = 0 ;
37935 PyObject * obj1 = 0 ;
37936 PyObject * obj2 = 0 ;
37937 PyObject * obj3 = 0 ;
37938 char *kwnames[] = {
37939 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37940 };
37941
37942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37944 if (SWIG_arg_fail(1)) SWIG_fail;
37945 {
37946 arg2 = wxString_in_helper(obj1);
37947 if (arg2 == NULL) SWIG_fail;
37948 temp2 = true;
37949 }
37950 {
37951 arg3 = (int)(SWIG_As_int(obj2));
37952 if (SWIG_arg_fail(3)) SWIG_fail;
37953 }
37954 if (obj3) {
37955 arg4 = obj3;
37956 }
37957 {
37958 PyThreadState* __tstate = wxPyBeginAllowThreads();
37959 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37960
37961 wxPyEndAllowThreads(__tstate);
37962 if (PyErr_Occurred()) SWIG_fail;
37963 }
37964 {
37965 resultobj = SWIG_From_int((int)(result));
37966 }
37967 {
37968 if (temp2)
37969 delete arg2;
37970 }
37971 return resultobj;
37972 fail:
37973 {
37974 if (temp2)
37975 delete arg2;
37976 }
37977 return NULL;
37978 }
37979
37980
37981 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37982 PyObject *resultobj;
37983 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37984 PyObject * obj0 = 0 ;
37985 char *kwnames[] = {
37986 (char *) "self", NULL
37987 };
37988
37989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37991 if (SWIG_arg_fail(1)) SWIG_fail;
37992 {
37993 PyThreadState* __tstate = wxPyBeginAllowThreads();
37994 (arg1)->Clear();
37995
37996 wxPyEndAllowThreads(__tstate);
37997 if (PyErr_Occurred()) SWIG_fail;
37998 }
37999 Py_INCREF(Py_None); resultobj = Py_None;
38000 return resultobj;
38001 fail:
38002 return NULL;
38003 }
38004
38005
38006 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38007 PyObject *resultobj;
38008 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38009 int arg2 ;
38010 PyObject * obj0 = 0 ;
38011 PyObject * obj1 = 0 ;
38012 char *kwnames[] = {
38013 (char *) "self",(char *) "n", NULL
38014 };
38015
38016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38018 if (SWIG_arg_fail(1)) SWIG_fail;
38019 {
38020 arg2 = (int)(SWIG_As_int(obj1));
38021 if (SWIG_arg_fail(2)) SWIG_fail;
38022 }
38023 {
38024 PyThreadState* __tstate = wxPyBeginAllowThreads();
38025 (arg1)->Delete(arg2);
38026
38027 wxPyEndAllowThreads(__tstate);
38028 if (PyErr_Occurred()) SWIG_fail;
38029 }
38030 Py_INCREF(Py_None); resultobj = Py_None;
38031 return resultobj;
38032 fail:
38033 return NULL;
38034 }
38035
38036
38037 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38038 PyObject *resultobj;
38039 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38040 int arg2 ;
38041 PyObject *result;
38042 PyObject * obj0 = 0 ;
38043 PyObject * obj1 = 0 ;
38044 char *kwnames[] = {
38045 (char *) "self",(char *) "n", NULL
38046 };
38047
38048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38050 if (SWIG_arg_fail(1)) SWIG_fail;
38051 {
38052 arg2 = (int)(SWIG_As_int(obj1));
38053 if (SWIG_arg_fail(2)) SWIG_fail;
38054 }
38055 {
38056 PyThreadState* __tstate = wxPyBeginAllowThreads();
38057 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38058
38059 wxPyEndAllowThreads(__tstate);
38060 if (PyErr_Occurred()) SWIG_fail;
38061 }
38062 resultobj = result;
38063 return resultobj;
38064 fail:
38065 return NULL;
38066 }
38067
38068
38069 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38070 PyObject *resultobj;
38071 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38072 int arg2 ;
38073 PyObject *arg3 = (PyObject *) 0 ;
38074 PyObject * obj0 = 0 ;
38075 PyObject * obj1 = 0 ;
38076 PyObject * obj2 = 0 ;
38077 char *kwnames[] = {
38078 (char *) "self",(char *) "n",(char *) "clientData", NULL
38079 };
38080
38081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38083 if (SWIG_arg_fail(1)) SWIG_fail;
38084 {
38085 arg2 = (int)(SWIG_As_int(obj1));
38086 if (SWIG_arg_fail(2)) SWIG_fail;
38087 }
38088 arg3 = obj2;
38089 {
38090 PyThreadState* __tstate = wxPyBeginAllowThreads();
38091 wxItemContainer_SetClientData(arg1,arg2,arg3);
38092
38093 wxPyEndAllowThreads(__tstate);
38094 if (PyErr_Occurred()) SWIG_fail;
38095 }
38096 Py_INCREF(Py_None); resultobj = Py_None;
38097 return resultobj;
38098 fail:
38099 return NULL;
38100 }
38101
38102
38103 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38104 PyObject *resultobj;
38105 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38106 int result;
38107 PyObject * obj0 = 0 ;
38108 char *kwnames[] = {
38109 (char *) "self", NULL
38110 };
38111
38112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38114 if (SWIG_arg_fail(1)) SWIG_fail;
38115 {
38116 PyThreadState* __tstate = wxPyBeginAllowThreads();
38117 result = (int)((wxItemContainer const *)arg1)->GetCount();
38118
38119 wxPyEndAllowThreads(__tstate);
38120 if (PyErr_Occurred()) SWIG_fail;
38121 }
38122 {
38123 resultobj = SWIG_From_int((int)(result));
38124 }
38125 return resultobj;
38126 fail:
38127 return NULL;
38128 }
38129
38130
38131 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38132 PyObject *resultobj;
38133 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38134 bool result;
38135 PyObject * obj0 = 0 ;
38136 char *kwnames[] = {
38137 (char *) "self", NULL
38138 };
38139
38140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38142 if (SWIG_arg_fail(1)) SWIG_fail;
38143 {
38144 PyThreadState* __tstate = wxPyBeginAllowThreads();
38145 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38146
38147 wxPyEndAllowThreads(__tstate);
38148 if (PyErr_Occurred()) SWIG_fail;
38149 }
38150 {
38151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38152 }
38153 return resultobj;
38154 fail:
38155 return NULL;
38156 }
38157
38158
38159 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38160 PyObject *resultobj;
38161 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38162 int arg2 ;
38163 wxString result;
38164 PyObject * obj0 = 0 ;
38165 PyObject * obj1 = 0 ;
38166 char *kwnames[] = {
38167 (char *) "self",(char *) "n", NULL
38168 };
38169
38170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38172 if (SWIG_arg_fail(1)) SWIG_fail;
38173 {
38174 arg2 = (int)(SWIG_As_int(obj1));
38175 if (SWIG_arg_fail(2)) SWIG_fail;
38176 }
38177 {
38178 PyThreadState* __tstate = wxPyBeginAllowThreads();
38179 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38180
38181 wxPyEndAllowThreads(__tstate);
38182 if (PyErr_Occurred()) SWIG_fail;
38183 }
38184 {
38185 #if wxUSE_UNICODE
38186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38187 #else
38188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38189 #endif
38190 }
38191 return resultobj;
38192 fail:
38193 return NULL;
38194 }
38195
38196
38197 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38198 PyObject *resultobj;
38199 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38200 wxArrayString result;
38201 PyObject * obj0 = 0 ;
38202 char *kwnames[] = {
38203 (char *) "self", NULL
38204 };
38205
38206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38208 if (SWIG_arg_fail(1)) SWIG_fail;
38209 {
38210 PyThreadState* __tstate = wxPyBeginAllowThreads();
38211 result = ((wxItemContainer const *)arg1)->GetStrings();
38212
38213 wxPyEndAllowThreads(__tstate);
38214 if (PyErr_Occurred()) SWIG_fail;
38215 }
38216 {
38217 resultobj = wxArrayString2PyList_helper(result);
38218 }
38219 return resultobj;
38220 fail:
38221 return NULL;
38222 }
38223
38224
38225 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38226 PyObject *resultobj;
38227 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38228 int arg2 ;
38229 wxString *arg3 = 0 ;
38230 bool temp3 = false ;
38231 PyObject * obj0 = 0 ;
38232 PyObject * obj1 = 0 ;
38233 PyObject * obj2 = 0 ;
38234 char *kwnames[] = {
38235 (char *) "self",(char *) "n",(char *) "s", NULL
38236 };
38237
38238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38240 if (SWIG_arg_fail(1)) SWIG_fail;
38241 {
38242 arg2 = (int)(SWIG_As_int(obj1));
38243 if (SWIG_arg_fail(2)) SWIG_fail;
38244 }
38245 {
38246 arg3 = wxString_in_helper(obj2);
38247 if (arg3 == NULL) SWIG_fail;
38248 temp3 = true;
38249 }
38250 {
38251 PyThreadState* __tstate = wxPyBeginAllowThreads();
38252 (arg1)->SetString(arg2,(wxString const &)*arg3);
38253
38254 wxPyEndAllowThreads(__tstate);
38255 if (PyErr_Occurred()) SWIG_fail;
38256 }
38257 Py_INCREF(Py_None); resultobj = Py_None;
38258 {
38259 if (temp3)
38260 delete arg3;
38261 }
38262 return resultobj;
38263 fail:
38264 {
38265 if (temp3)
38266 delete arg3;
38267 }
38268 return NULL;
38269 }
38270
38271
38272 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38273 PyObject *resultobj;
38274 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38275 wxString *arg2 = 0 ;
38276 int result;
38277 bool temp2 = false ;
38278 PyObject * obj0 = 0 ;
38279 PyObject * obj1 = 0 ;
38280 char *kwnames[] = {
38281 (char *) "self",(char *) "s", NULL
38282 };
38283
38284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38286 if (SWIG_arg_fail(1)) SWIG_fail;
38287 {
38288 arg2 = wxString_in_helper(obj1);
38289 if (arg2 == NULL) SWIG_fail;
38290 temp2 = true;
38291 }
38292 {
38293 PyThreadState* __tstate = wxPyBeginAllowThreads();
38294 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38295
38296 wxPyEndAllowThreads(__tstate);
38297 if (PyErr_Occurred()) SWIG_fail;
38298 }
38299 {
38300 resultobj = SWIG_From_int((int)(result));
38301 }
38302 {
38303 if (temp2)
38304 delete arg2;
38305 }
38306 return resultobj;
38307 fail:
38308 {
38309 if (temp2)
38310 delete arg2;
38311 }
38312 return NULL;
38313 }
38314
38315
38316 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38317 PyObject *resultobj;
38318 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38319 int arg2 ;
38320 PyObject * obj0 = 0 ;
38321 PyObject * obj1 = 0 ;
38322 char *kwnames[] = {
38323 (char *) "self",(char *) "n", NULL
38324 };
38325
38326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38328 if (SWIG_arg_fail(1)) SWIG_fail;
38329 {
38330 arg2 = (int)(SWIG_As_int(obj1));
38331 if (SWIG_arg_fail(2)) SWIG_fail;
38332 }
38333 {
38334 PyThreadState* __tstate = wxPyBeginAllowThreads();
38335 (arg1)->SetSelection(arg2);
38336
38337 wxPyEndAllowThreads(__tstate);
38338 if (PyErr_Occurred()) SWIG_fail;
38339 }
38340 Py_INCREF(Py_None); resultobj = Py_None;
38341 return resultobj;
38342 fail:
38343 return NULL;
38344 }
38345
38346
38347 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38348 PyObject *resultobj;
38349 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38350 int result;
38351 PyObject * obj0 = 0 ;
38352 char *kwnames[] = {
38353 (char *) "self", NULL
38354 };
38355
38356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38358 if (SWIG_arg_fail(1)) SWIG_fail;
38359 {
38360 PyThreadState* __tstate = wxPyBeginAllowThreads();
38361 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38362
38363 wxPyEndAllowThreads(__tstate);
38364 if (PyErr_Occurred()) SWIG_fail;
38365 }
38366 {
38367 resultobj = SWIG_From_int((int)(result));
38368 }
38369 return resultobj;
38370 fail:
38371 return NULL;
38372 }
38373
38374
38375 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38376 PyObject *resultobj;
38377 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38378 wxString *arg2 = 0 ;
38379 bool result;
38380 bool temp2 = false ;
38381 PyObject * obj0 = 0 ;
38382 PyObject * obj1 = 0 ;
38383 char *kwnames[] = {
38384 (char *) "self",(char *) "s", NULL
38385 };
38386
38387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38389 if (SWIG_arg_fail(1)) SWIG_fail;
38390 {
38391 arg2 = wxString_in_helper(obj1);
38392 if (arg2 == NULL) SWIG_fail;
38393 temp2 = true;
38394 }
38395 {
38396 PyThreadState* __tstate = wxPyBeginAllowThreads();
38397 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38398
38399 wxPyEndAllowThreads(__tstate);
38400 if (PyErr_Occurred()) SWIG_fail;
38401 }
38402 {
38403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38404 }
38405 {
38406 if (temp2)
38407 delete arg2;
38408 }
38409 return resultobj;
38410 fail:
38411 {
38412 if (temp2)
38413 delete arg2;
38414 }
38415 return NULL;
38416 }
38417
38418
38419 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38420 PyObject *resultobj;
38421 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38422 wxString result;
38423 PyObject * obj0 = 0 ;
38424 char *kwnames[] = {
38425 (char *) "self", NULL
38426 };
38427
38428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38430 if (SWIG_arg_fail(1)) SWIG_fail;
38431 {
38432 PyThreadState* __tstate = wxPyBeginAllowThreads();
38433 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38434
38435 wxPyEndAllowThreads(__tstate);
38436 if (PyErr_Occurred()) SWIG_fail;
38437 }
38438 {
38439 #if wxUSE_UNICODE
38440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38441 #else
38442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38443 #endif
38444 }
38445 return resultobj;
38446 fail:
38447 return NULL;
38448 }
38449
38450
38451 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38452 PyObject *resultobj;
38453 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38454 int arg2 ;
38455 PyObject * obj0 = 0 ;
38456 PyObject * obj1 = 0 ;
38457 char *kwnames[] = {
38458 (char *) "self",(char *) "n", NULL
38459 };
38460
38461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38463 if (SWIG_arg_fail(1)) SWIG_fail;
38464 {
38465 arg2 = (int)(SWIG_As_int(obj1));
38466 if (SWIG_arg_fail(2)) SWIG_fail;
38467 }
38468 {
38469 PyThreadState* __tstate = wxPyBeginAllowThreads();
38470 (arg1)->Select(arg2);
38471
38472 wxPyEndAllowThreads(__tstate);
38473 if (PyErr_Occurred()) SWIG_fail;
38474 }
38475 Py_INCREF(Py_None); resultobj = Py_None;
38476 return resultobj;
38477 fail:
38478 return NULL;
38479 }
38480
38481
38482 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38483 PyObject *obj;
38484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38485 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38486 Py_INCREF(obj);
38487 return Py_BuildValue((char *)"");
38488 }
38489 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38490 PyObject *obj;
38491 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38492 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38493 Py_INCREF(obj);
38494 return Py_BuildValue((char *)"");
38495 }
38496 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38497 PyObject *resultobj;
38498 wxSizerItem *result;
38499 char *kwnames[] = {
38500 NULL
38501 };
38502
38503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38504 {
38505 PyThreadState* __tstate = wxPyBeginAllowThreads();
38506 result = (wxSizerItem *)new wxSizerItem();
38507
38508 wxPyEndAllowThreads(__tstate);
38509 if (PyErr_Occurred()) SWIG_fail;
38510 }
38511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38512 return resultobj;
38513 fail:
38514 return NULL;
38515 }
38516
38517
38518 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38519 PyObject *resultobj;
38520 wxWindow *arg1 = (wxWindow *) 0 ;
38521 int arg2 ;
38522 int arg3 ;
38523 int arg4 ;
38524 PyObject *arg5 = (PyObject *) NULL ;
38525 wxSizerItem *result;
38526 PyObject * obj0 = 0 ;
38527 PyObject * obj1 = 0 ;
38528 PyObject * obj2 = 0 ;
38529 PyObject * obj3 = 0 ;
38530 PyObject * obj4 = 0 ;
38531 char *kwnames[] = {
38532 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38533 };
38534
38535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38537 if (SWIG_arg_fail(1)) SWIG_fail;
38538 {
38539 arg2 = (int)(SWIG_As_int(obj1));
38540 if (SWIG_arg_fail(2)) SWIG_fail;
38541 }
38542 {
38543 arg3 = (int)(SWIG_As_int(obj2));
38544 if (SWIG_arg_fail(3)) SWIG_fail;
38545 }
38546 {
38547 arg4 = (int)(SWIG_As_int(obj3));
38548 if (SWIG_arg_fail(4)) SWIG_fail;
38549 }
38550 if (obj4) {
38551 arg5 = obj4;
38552 }
38553 {
38554 PyThreadState* __tstate = wxPyBeginAllowThreads();
38555 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38556
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38561 return resultobj;
38562 fail:
38563 return NULL;
38564 }
38565
38566
38567 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38568 PyObject *resultobj;
38569 int arg1 ;
38570 int arg2 ;
38571 int arg3 ;
38572 int arg4 ;
38573 int arg5 ;
38574 PyObject *arg6 = (PyObject *) NULL ;
38575 wxSizerItem *result;
38576 PyObject * obj0 = 0 ;
38577 PyObject * obj1 = 0 ;
38578 PyObject * obj2 = 0 ;
38579 PyObject * obj3 = 0 ;
38580 PyObject * obj4 = 0 ;
38581 PyObject * obj5 = 0 ;
38582 char *kwnames[] = {
38583 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38584 };
38585
38586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38587 {
38588 arg1 = (int)(SWIG_As_int(obj0));
38589 if (SWIG_arg_fail(1)) SWIG_fail;
38590 }
38591 {
38592 arg2 = (int)(SWIG_As_int(obj1));
38593 if (SWIG_arg_fail(2)) SWIG_fail;
38594 }
38595 {
38596 arg3 = (int)(SWIG_As_int(obj2));
38597 if (SWIG_arg_fail(3)) SWIG_fail;
38598 }
38599 {
38600 arg4 = (int)(SWIG_As_int(obj3));
38601 if (SWIG_arg_fail(4)) SWIG_fail;
38602 }
38603 {
38604 arg5 = (int)(SWIG_As_int(obj4));
38605 if (SWIG_arg_fail(5)) SWIG_fail;
38606 }
38607 if (obj5) {
38608 arg6 = obj5;
38609 }
38610 {
38611 PyThreadState* __tstate = wxPyBeginAllowThreads();
38612 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38613
38614 wxPyEndAllowThreads(__tstate);
38615 if (PyErr_Occurred()) SWIG_fail;
38616 }
38617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38618 return resultobj;
38619 fail:
38620 return NULL;
38621 }
38622
38623
38624 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38625 PyObject *resultobj;
38626 wxSizer *arg1 = (wxSizer *) 0 ;
38627 int arg2 ;
38628 int arg3 ;
38629 int arg4 ;
38630 PyObject *arg5 = (PyObject *) NULL ;
38631 wxSizerItem *result;
38632 PyObject * obj0 = 0 ;
38633 PyObject * obj1 = 0 ;
38634 PyObject * obj2 = 0 ;
38635 PyObject * obj3 = 0 ;
38636 PyObject * obj4 = 0 ;
38637 char *kwnames[] = {
38638 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38639 };
38640
38641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38643 if (SWIG_arg_fail(1)) SWIG_fail;
38644 {
38645 arg2 = (int)(SWIG_As_int(obj1));
38646 if (SWIG_arg_fail(2)) SWIG_fail;
38647 }
38648 {
38649 arg3 = (int)(SWIG_As_int(obj2));
38650 if (SWIG_arg_fail(3)) SWIG_fail;
38651 }
38652 {
38653 arg4 = (int)(SWIG_As_int(obj3));
38654 if (SWIG_arg_fail(4)) SWIG_fail;
38655 }
38656 if (obj4) {
38657 arg5 = obj4;
38658 }
38659 {
38660 PyThreadState* __tstate = wxPyBeginAllowThreads();
38661 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38662
38663 wxPyEndAllowThreads(__tstate);
38664 if (PyErr_Occurred()) SWIG_fail;
38665 }
38666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38667 return resultobj;
38668 fail:
38669 return NULL;
38670 }
38671
38672
38673 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38674 PyObject *resultobj;
38675 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38676 PyObject * obj0 = 0 ;
38677 char *kwnames[] = {
38678 (char *) "self", NULL
38679 };
38680
38681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38683 if (SWIG_arg_fail(1)) SWIG_fail;
38684 {
38685 PyThreadState* __tstate = wxPyBeginAllowThreads();
38686 (arg1)->DeleteWindows();
38687
38688 wxPyEndAllowThreads(__tstate);
38689 if (PyErr_Occurred()) SWIG_fail;
38690 }
38691 Py_INCREF(Py_None); resultobj = Py_None;
38692 return resultobj;
38693 fail:
38694 return NULL;
38695 }
38696
38697
38698 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38699 PyObject *resultobj;
38700 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38701 PyObject * obj0 = 0 ;
38702 char *kwnames[] = {
38703 (char *) "self", NULL
38704 };
38705
38706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
38711 (arg1)->DetachSizer();
38712
38713 wxPyEndAllowThreads(__tstate);
38714 if (PyErr_Occurred()) SWIG_fail;
38715 }
38716 Py_INCREF(Py_None); resultobj = Py_None;
38717 return resultobj;
38718 fail:
38719 return NULL;
38720 }
38721
38722
38723 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38724 PyObject *resultobj;
38725 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38726 wxSize result;
38727 PyObject * obj0 = 0 ;
38728 char *kwnames[] = {
38729 (char *) "self", NULL
38730 };
38731
38732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38734 if (SWIG_arg_fail(1)) SWIG_fail;
38735 {
38736 PyThreadState* __tstate = wxPyBeginAllowThreads();
38737 result = (arg1)->GetSize();
38738
38739 wxPyEndAllowThreads(__tstate);
38740 if (PyErr_Occurred()) SWIG_fail;
38741 }
38742 {
38743 wxSize * resultptr;
38744 resultptr = new wxSize((wxSize &)(result));
38745 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38746 }
38747 return resultobj;
38748 fail:
38749 return NULL;
38750 }
38751
38752
38753 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38754 PyObject *resultobj;
38755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38756 wxSize result;
38757 PyObject * obj0 = 0 ;
38758 char *kwnames[] = {
38759 (char *) "self", NULL
38760 };
38761
38762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38764 if (SWIG_arg_fail(1)) SWIG_fail;
38765 {
38766 PyThreadState* __tstate = wxPyBeginAllowThreads();
38767 result = (arg1)->CalcMin();
38768
38769 wxPyEndAllowThreads(__tstate);
38770 if (PyErr_Occurred()) SWIG_fail;
38771 }
38772 {
38773 wxSize * resultptr;
38774 resultptr = new wxSize((wxSize &)(result));
38775 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38776 }
38777 return resultobj;
38778 fail:
38779 return NULL;
38780 }
38781
38782
38783 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38784 PyObject *resultobj;
38785 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38786 wxPoint arg2 ;
38787 wxSize arg3 ;
38788 PyObject * obj0 = 0 ;
38789 PyObject * obj1 = 0 ;
38790 PyObject * obj2 = 0 ;
38791 char *kwnames[] = {
38792 (char *) "self",(char *) "pos",(char *) "size", NULL
38793 };
38794
38795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) 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 wxPoint * argp;
38800 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38801 if (SWIG_arg_fail(2)) SWIG_fail;
38802 if (argp == NULL) {
38803 SWIG_null_ref("wxPoint");
38804 }
38805 if (SWIG_arg_fail(2)) SWIG_fail;
38806 arg2 = *argp;
38807 }
38808 {
38809 wxSize * argp;
38810 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38811 if (SWIG_arg_fail(3)) SWIG_fail;
38812 if (argp == NULL) {
38813 SWIG_null_ref("wxSize");
38814 }
38815 if (SWIG_arg_fail(3)) SWIG_fail;
38816 arg3 = *argp;
38817 }
38818 {
38819 PyThreadState* __tstate = wxPyBeginAllowThreads();
38820 (arg1)->SetDimension(arg2,arg3);
38821
38822 wxPyEndAllowThreads(__tstate);
38823 if (PyErr_Occurred()) SWIG_fail;
38824 }
38825 Py_INCREF(Py_None); resultobj = Py_None;
38826 return resultobj;
38827 fail:
38828 return NULL;
38829 }
38830
38831
38832 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38833 PyObject *resultobj;
38834 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38835 wxSize result;
38836 PyObject * obj0 = 0 ;
38837 char *kwnames[] = {
38838 (char *) "self", NULL
38839 };
38840
38841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38843 if (SWIG_arg_fail(1)) SWIG_fail;
38844 {
38845 PyThreadState* __tstate = wxPyBeginAllowThreads();
38846 result = (arg1)->GetMinSize();
38847
38848 wxPyEndAllowThreads(__tstate);
38849 if (PyErr_Occurred()) SWIG_fail;
38850 }
38851 {
38852 wxSize * resultptr;
38853 resultptr = new wxSize((wxSize &)(result));
38854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38855 }
38856 return resultobj;
38857 fail:
38858 return NULL;
38859 }
38860
38861
38862 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38863 PyObject *resultobj;
38864 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38865 wxSize result;
38866 PyObject * obj0 = 0 ;
38867 char *kwnames[] = {
38868 (char *) "self", NULL
38869 };
38870
38871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38873 if (SWIG_arg_fail(1)) SWIG_fail;
38874 {
38875 PyThreadState* __tstate = wxPyBeginAllowThreads();
38876 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38877
38878 wxPyEndAllowThreads(__tstate);
38879 if (PyErr_Occurred()) SWIG_fail;
38880 }
38881 {
38882 wxSize * resultptr;
38883 resultptr = new wxSize((wxSize &)(result));
38884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38885 }
38886 return resultobj;
38887 fail:
38888 return NULL;
38889 }
38890
38891
38892 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38893 PyObject *resultobj;
38894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38895 int arg2 ;
38896 int arg3 ;
38897 PyObject * obj0 = 0 ;
38898 PyObject * obj1 = 0 ;
38899 PyObject * obj2 = 0 ;
38900 char *kwnames[] = {
38901 (char *) "self",(char *) "x",(char *) "y", NULL
38902 };
38903
38904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38906 if (SWIG_arg_fail(1)) SWIG_fail;
38907 {
38908 arg2 = (int)(SWIG_As_int(obj1));
38909 if (SWIG_arg_fail(2)) SWIG_fail;
38910 }
38911 {
38912 arg3 = (int)(SWIG_As_int(obj2));
38913 if (SWIG_arg_fail(3)) SWIG_fail;
38914 }
38915 {
38916 PyThreadState* __tstate = wxPyBeginAllowThreads();
38917 (arg1)->SetInitSize(arg2,arg3);
38918
38919 wxPyEndAllowThreads(__tstate);
38920 if (PyErr_Occurred()) SWIG_fail;
38921 }
38922 Py_INCREF(Py_None); resultobj = Py_None;
38923 return resultobj;
38924 fail:
38925 return NULL;
38926 }
38927
38928
38929 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38930 PyObject *resultobj;
38931 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38932 int arg2 ;
38933 int arg3 ;
38934 PyObject * obj0 = 0 ;
38935 PyObject * obj1 = 0 ;
38936 PyObject * obj2 = 0 ;
38937 char *kwnames[] = {
38938 (char *) "self",(char *) "width",(char *) "height", NULL
38939 };
38940
38941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38943 if (SWIG_arg_fail(1)) SWIG_fail;
38944 {
38945 arg2 = (int)(SWIG_As_int(obj1));
38946 if (SWIG_arg_fail(2)) SWIG_fail;
38947 }
38948 {
38949 arg3 = (int)(SWIG_As_int(obj2));
38950 if (SWIG_arg_fail(3)) SWIG_fail;
38951 }
38952 {
38953 PyThreadState* __tstate = wxPyBeginAllowThreads();
38954 (arg1)->SetRatio(arg2,arg3);
38955
38956 wxPyEndAllowThreads(__tstate);
38957 if (PyErr_Occurred()) SWIG_fail;
38958 }
38959 Py_INCREF(Py_None); resultobj = Py_None;
38960 return resultobj;
38961 fail:
38962 return NULL;
38963 }
38964
38965
38966 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38967 PyObject *resultobj;
38968 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38969 wxSize *arg2 = 0 ;
38970 wxSize temp2 ;
38971 PyObject * obj0 = 0 ;
38972 PyObject * obj1 = 0 ;
38973 char *kwnames[] = {
38974 (char *) "self",(char *) "size", NULL
38975 };
38976
38977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38979 if (SWIG_arg_fail(1)) SWIG_fail;
38980 {
38981 arg2 = &temp2;
38982 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38983 }
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 (arg1)->SetRatio((wxSize const &)*arg2);
38987
38988 wxPyEndAllowThreads(__tstate);
38989 if (PyErr_Occurred()) SWIG_fail;
38990 }
38991 Py_INCREF(Py_None); resultobj = Py_None;
38992 return resultobj;
38993 fail:
38994 return NULL;
38995 }
38996
38997
38998 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38999 PyObject *resultobj;
39000 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39001 float arg2 ;
39002 PyObject * obj0 = 0 ;
39003 PyObject * obj1 = 0 ;
39004 char *kwnames[] = {
39005 (char *) "self",(char *) "ratio", NULL
39006 };
39007
39008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39010 if (SWIG_arg_fail(1)) SWIG_fail;
39011 {
39012 arg2 = (float)(SWIG_As_float(obj1));
39013 if (SWIG_arg_fail(2)) SWIG_fail;
39014 }
39015 {
39016 PyThreadState* __tstate = wxPyBeginAllowThreads();
39017 (arg1)->SetRatio(arg2);
39018
39019 wxPyEndAllowThreads(__tstate);
39020 if (PyErr_Occurred()) SWIG_fail;
39021 }
39022 Py_INCREF(Py_None); resultobj = Py_None;
39023 return resultobj;
39024 fail:
39025 return NULL;
39026 }
39027
39028
39029 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39030 PyObject *resultobj;
39031 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39032 float result;
39033 PyObject * obj0 = 0 ;
39034 char *kwnames[] = {
39035 (char *) "self", NULL
39036 };
39037
39038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39040 if (SWIG_arg_fail(1)) SWIG_fail;
39041 {
39042 PyThreadState* __tstate = wxPyBeginAllowThreads();
39043 result = (float)(arg1)->GetRatio();
39044
39045 wxPyEndAllowThreads(__tstate);
39046 if (PyErr_Occurred()) SWIG_fail;
39047 }
39048 {
39049 resultobj = SWIG_From_float((float)(result));
39050 }
39051 return resultobj;
39052 fail:
39053 return NULL;
39054 }
39055
39056
39057 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39058 PyObject *resultobj;
39059 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39060 wxRect result;
39061 PyObject * obj0 = 0 ;
39062 char *kwnames[] = {
39063 (char *) "self", NULL
39064 };
39065
39066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39068 if (SWIG_arg_fail(1)) SWIG_fail;
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 result = (arg1)->GetRect();
39072
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 {
39077 wxRect * resultptr;
39078 resultptr = new wxRect((wxRect &)(result));
39079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39080 }
39081 return resultobj;
39082 fail:
39083 return NULL;
39084 }
39085
39086
39087 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39088 PyObject *resultobj;
39089 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39090 bool result;
39091 PyObject * obj0 = 0 ;
39092 char *kwnames[] = {
39093 (char *) "self", NULL
39094 };
39095
39096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39098 if (SWIG_arg_fail(1)) SWIG_fail;
39099 {
39100 PyThreadState* __tstate = wxPyBeginAllowThreads();
39101 result = (bool)(arg1)->IsWindow();
39102
39103 wxPyEndAllowThreads(__tstate);
39104 if (PyErr_Occurred()) SWIG_fail;
39105 }
39106 {
39107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39108 }
39109 return resultobj;
39110 fail:
39111 return NULL;
39112 }
39113
39114
39115 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39116 PyObject *resultobj;
39117 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39118 bool result;
39119 PyObject * obj0 = 0 ;
39120 char *kwnames[] = {
39121 (char *) "self", NULL
39122 };
39123
39124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39126 if (SWIG_arg_fail(1)) SWIG_fail;
39127 {
39128 PyThreadState* __tstate = wxPyBeginAllowThreads();
39129 result = (bool)(arg1)->IsSizer();
39130
39131 wxPyEndAllowThreads(__tstate);
39132 if (PyErr_Occurred()) SWIG_fail;
39133 }
39134 {
39135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39136 }
39137 return resultobj;
39138 fail:
39139 return NULL;
39140 }
39141
39142
39143 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39144 PyObject *resultobj;
39145 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39146 bool result;
39147 PyObject * obj0 = 0 ;
39148 char *kwnames[] = {
39149 (char *) "self", NULL
39150 };
39151
39152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39154 if (SWIG_arg_fail(1)) SWIG_fail;
39155 {
39156 PyThreadState* __tstate = wxPyBeginAllowThreads();
39157 result = (bool)(arg1)->IsSpacer();
39158
39159 wxPyEndAllowThreads(__tstate);
39160 if (PyErr_Occurred()) SWIG_fail;
39161 }
39162 {
39163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39164 }
39165 return resultobj;
39166 fail:
39167 return NULL;
39168 }
39169
39170
39171 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39172 PyObject *resultobj;
39173 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39174 int arg2 ;
39175 PyObject * obj0 = 0 ;
39176 PyObject * obj1 = 0 ;
39177 char *kwnames[] = {
39178 (char *) "self",(char *) "proportion", NULL
39179 };
39180
39181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39183 if (SWIG_arg_fail(1)) SWIG_fail;
39184 {
39185 arg2 = (int)(SWIG_As_int(obj1));
39186 if (SWIG_arg_fail(2)) SWIG_fail;
39187 }
39188 {
39189 PyThreadState* __tstate = wxPyBeginAllowThreads();
39190 (arg1)->SetProportion(arg2);
39191
39192 wxPyEndAllowThreads(__tstate);
39193 if (PyErr_Occurred()) SWIG_fail;
39194 }
39195 Py_INCREF(Py_None); resultobj = Py_None;
39196 return resultobj;
39197 fail:
39198 return NULL;
39199 }
39200
39201
39202 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39203 PyObject *resultobj;
39204 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39205 int result;
39206 PyObject * obj0 = 0 ;
39207 char *kwnames[] = {
39208 (char *) "self", NULL
39209 };
39210
39211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39213 if (SWIG_arg_fail(1)) SWIG_fail;
39214 {
39215 PyThreadState* __tstate = wxPyBeginAllowThreads();
39216 result = (int)(arg1)->GetProportion();
39217
39218 wxPyEndAllowThreads(__tstate);
39219 if (PyErr_Occurred()) SWIG_fail;
39220 }
39221 {
39222 resultobj = SWIG_From_int((int)(result));
39223 }
39224 return resultobj;
39225 fail:
39226 return NULL;
39227 }
39228
39229
39230 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39231 PyObject *resultobj;
39232 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39233 int arg2 ;
39234 PyObject * obj0 = 0 ;
39235 PyObject * obj1 = 0 ;
39236 char *kwnames[] = {
39237 (char *) "self",(char *) "flag", NULL
39238 };
39239
39240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39242 if (SWIG_arg_fail(1)) SWIG_fail;
39243 {
39244 arg2 = (int)(SWIG_As_int(obj1));
39245 if (SWIG_arg_fail(2)) SWIG_fail;
39246 }
39247 {
39248 PyThreadState* __tstate = wxPyBeginAllowThreads();
39249 (arg1)->SetFlag(arg2);
39250
39251 wxPyEndAllowThreads(__tstate);
39252 if (PyErr_Occurred()) SWIG_fail;
39253 }
39254 Py_INCREF(Py_None); resultobj = Py_None;
39255 return resultobj;
39256 fail:
39257 return NULL;
39258 }
39259
39260
39261 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39262 PyObject *resultobj;
39263 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39264 int result;
39265 PyObject * obj0 = 0 ;
39266 char *kwnames[] = {
39267 (char *) "self", NULL
39268 };
39269
39270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39272 if (SWIG_arg_fail(1)) SWIG_fail;
39273 {
39274 PyThreadState* __tstate = wxPyBeginAllowThreads();
39275 result = (int)(arg1)->GetFlag();
39276
39277 wxPyEndAllowThreads(__tstate);
39278 if (PyErr_Occurred()) SWIG_fail;
39279 }
39280 {
39281 resultobj = SWIG_From_int((int)(result));
39282 }
39283 return resultobj;
39284 fail:
39285 return NULL;
39286 }
39287
39288
39289 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39290 PyObject *resultobj;
39291 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39292 int arg2 ;
39293 PyObject * obj0 = 0 ;
39294 PyObject * obj1 = 0 ;
39295 char *kwnames[] = {
39296 (char *) "self",(char *) "border", NULL
39297 };
39298
39299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39301 if (SWIG_arg_fail(1)) SWIG_fail;
39302 {
39303 arg2 = (int)(SWIG_As_int(obj1));
39304 if (SWIG_arg_fail(2)) SWIG_fail;
39305 }
39306 {
39307 PyThreadState* __tstate = wxPyBeginAllowThreads();
39308 (arg1)->SetBorder(arg2);
39309
39310 wxPyEndAllowThreads(__tstate);
39311 if (PyErr_Occurred()) SWIG_fail;
39312 }
39313 Py_INCREF(Py_None); resultobj = Py_None;
39314 return resultobj;
39315 fail:
39316 return NULL;
39317 }
39318
39319
39320 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39321 PyObject *resultobj;
39322 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39323 int result;
39324 PyObject * obj0 = 0 ;
39325 char *kwnames[] = {
39326 (char *) "self", NULL
39327 };
39328
39329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39331 if (SWIG_arg_fail(1)) SWIG_fail;
39332 {
39333 PyThreadState* __tstate = wxPyBeginAllowThreads();
39334 result = (int)(arg1)->GetBorder();
39335
39336 wxPyEndAllowThreads(__tstate);
39337 if (PyErr_Occurred()) SWIG_fail;
39338 }
39339 {
39340 resultobj = SWIG_From_int((int)(result));
39341 }
39342 return resultobj;
39343 fail:
39344 return NULL;
39345 }
39346
39347
39348 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39349 PyObject *resultobj;
39350 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39351 wxWindow *result;
39352 PyObject * obj0 = 0 ;
39353 char *kwnames[] = {
39354 (char *) "self", NULL
39355 };
39356
39357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39359 if (SWIG_arg_fail(1)) SWIG_fail;
39360 {
39361 PyThreadState* __tstate = wxPyBeginAllowThreads();
39362 result = (wxWindow *)(arg1)->GetWindow();
39363
39364 wxPyEndAllowThreads(__tstate);
39365 if (PyErr_Occurred()) SWIG_fail;
39366 }
39367 {
39368 resultobj = wxPyMake_wxObject(result, 0);
39369 }
39370 return resultobj;
39371 fail:
39372 return NULL;
39373 }
39374
39375
39376 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39377 PyObject *resultobj;
39378 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39379 wxWindow *arg2 = (wxWindow *) 0 ;
39380 PyObject * obj0 = 0 ;
39381 PyObject * obj1 = 0 ;
39382 char *kwnames[] = {
39383 (char *) "self",(char *) "window", NULL
39384 };
39385
39386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39388 if (SWIG_arg_fail(1)) SWIG_fail;
39389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39390 if (SWIG_arg_fail(2)) SWIG_fail;
39391 {
39392 PyThreadState* __tstate = wxPyBeginAllowThreads();
39393 (arg1)->SetWindow(arg2);
39394
39395 wxPyEndAllowThreads(__tstate);
39396 if (PyErr_Occurred()) SWIG_fail;
39397 }
39398 Py_INCREF(Py_None); resultobj = Py_None;
39399 return resultobj;
39400 fail:
39401 return NULL;
39402 }
39403
39404
39405 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39406 PyObject *resultobj;
39407 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39408 wxSizer *result;
39409 PyObject * obj0 = 0 ;
39410 char *kwnames[] = {
39411 (char *) "self", NULL
39412 };
39413
39414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39416 if (SWIG_arg_fail(1)) SWIG_fail;
39417 {
39418 PyThreadState* __tstate = wxPyBeginAllowThreads();
39419 result = (wxSizer *)(arg1)->GetSizer();
39420
39421 wxPyEndAllowThreads(__tstate);
39422 if (PyErr_Occurred()) SWIG_fail;
39423 }
39424 {
39425 resultobj = wxPyMake_wxObject(result, 0);
39426 }
39427 return resultobj;
39428 fail:
39429 return NULL;
39430 }
39431
39432
39433 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39434 PyObject *resultobj;
39435 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39436 wxSizer *arg2 = (wxSizer *) 0 ;
39437 PyObject * obj0 = 0 ;
39438 PyObject * obj1 = 0 ;
39439 char *kwnames[] = {
39440 (char *) "self",(char *) "sizer", NULL
39441 };
39442
39443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39445 if (SWIG_arg_fail(1)) SWIG_fail;
39446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39447 if (SWIG_arg_fail(2)) SWIG_fail;
39448 {
39449 PyThreadState* __tstate = wxPyBeginAllowThreads();
39450 (arg1)->SetSizer(arg2);
39451
39452 wxPyEndAllowThreads(__tstate);
39453 if (PyErr_Occurred()) SWIG_fail;
39454 }
39455 Py_INCREF(Py_None); resultobj = Py_None;
39456 return resultobj;
39457 fail:
39458 return NULL;
39459 }
39460
39461
39462 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39463 PyObject *resultobj;
39464 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39465 wxSize *result;
39466 PyObject * obj0 = 0 ;
39467 char *kwnames[] = {
39468 (char *) "self", NULL
39469 };
39470
39471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39473 if (SWIG_arg_fail(1)) SWIG_fail;
39474 {
39475 PyThreadState* __tstate = wxPyBeginAllowThreads();
39476 {
39477 wxSize const &_result_ref = (arg1)->GetSpacer();
39478 result = (wxSize *) &_result_ref;
39479 }
39480
39481 wxPyEndAllowThreads(__tstate);
39482 if (PyErr_Occurred()) SWIG_fail;
39483 }
39484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39485 return resultobj;
39486 fail:
39487 return NULL;
39488 }
39489
39490
39491 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39492 PyObject *resultobj;
39493 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39494 wxSize *arg2 = 0 ;
39495 wxSize temp2 ;
39496 PyObject * obj0 = 0 ;
39497 PyObject * obj1 = 0 ;
39498 char *kwnames[] = {
39499 (char *) "self",(char *) "size", NULL
39500 };
39501
39502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39504 if (SWIG_arg_fail(1)) SWIG_fail;
39505 {
39506 arg2 = &temp2;
39507 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39508 }
39509 {
39510 PyThreadState* __tstate = wxPyBeginAllowThreads();
39511 (arg1)->SetSpacer((wxSize const &)*arg2);
39512
39513 wxPyEndAllowThreads(__tstate);
39514 if (PyErr_Occurred()) SWIG_fail;
39515 }
39516 Py_INCREF(Py_None); resultobj = Py_None;
39517 return resultobj;
39518 fail:
39519 return NULL;
39520 }
39521
39522
39523 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39524 PyObject *resultobj;
39525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39526 bool arg2 ;
39527 PyObject * obj0 = 0 ;
39528 PyObject * obj1 = 0 ;
39529 char *kwnames[] = {
39530 (char *) "self",(char *) "show", NULL
39531 };
39532
39533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39535 if (SWIG_arg_fail(1)) SWIG_fail;
39536 {
39537 arg2 = (bool)(SWIG_As_bool(obj1));
39538 if (SWIG_arg_fail(2)) SWIG_fail;
39539 }
39540 {
39541 PyThreadState* __tstate = wxPyBeginAllowThreads();
39542 (arg1)->Show(arg2);
39543
39544 wxPyEndAllowThreads(__tstate);
39545 if (PyErr_Occurred()) SWIG_fail;
39546 }
39547 Py_INCREF(Py_None); resultobj = Py_None;
39548 return resultobj;
39549 fail:
39550 return NULL;
39551 }
39552
39553
39554 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39555 PyObject *resultobj;
39556 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39557 bool result;
39558 PyObject * obj0 = 0 ;
39559 char *kwnames[] = {
39560 (char *) "self", NULL
39561 };
39562
39563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39565 if (SWIG_arg_fail(1)) SWIG_fail;
39566 {
39567 PyThreadState* __tstate = wxPyBeginAllowThreads();
39568 result = (bool)(arg1)->IsShown();
39569
39570 wxPyEndAllowThreads(__tstate);
39571 if (PyErr_Occurred()) SWIG_fail;
39572 }
39573 {
39574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39575 }
39576 return resultobj;
39577 fail:
39578 return NULL;
39579 }
39580
39581
39582 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39583 PyObject *resultobj;
39584 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39585 wxPoint result;
39586 PyObject * obj0 = 0 ;
39587 char *kwnames[] = {
39588 (char *) "self", NULL
39589 };
39590
39591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39593 if (SWIG_arg_fail(1)) SWIG_fail;
39594 {
39595 PyThreadState* __tstate = wxPyBeginAllowThreads();
39596 result = (arg1)->GetPosition();
39597
39598 wxPyEndAllowThreads(__tstate);
39599 if (PyErr_Occurred()) SWIG_fail;
39600 }
39601 {
39602 wxPoint * resultptr;
39603 resultptr = new wxPoint((wxPoint &)(result));
39604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39605 }
39606 return resultobj;
39607 fail:
39608 return NULL;
39609 }
39610
39611
39612 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39613 PyObject *resultobj;
39614 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39615 PyObject *result;
39616 PyObject * obj0 = 0 ;
39617 char *kwnames[] = {
39618 (char *) "self", NULL
39619 };
39620
39621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39623 if (SWIG_arg_fail(1)) SWIG_fail;
39624 {
39625 PyThreadState* __tstate = wxPyBeginAllowThreads();
39626 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39627
39628 wxPyEndAllowThreads(__tstate);
39629 if (PyErr_Occurred()) SWIG_fail;
39630 }
39631 resultobj = result;
39632 return resultobj;
39633 fail:
39634 return NULL;
39635 }
39636
39637
39638 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39639 PyObject *obj;
39640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39641 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39642 Py_INCREF(obj);
39643 return Py_BuildValue((char *)"");
39644 }
39645 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39646 PyObject *resultobj;
39647 wxSizer *arg1 = (wxSizer *) 0 ;
39648 PyObject *arg2 = (PyObject *) 0 ;
39649 PyObject * obj0 = 0 ;
39650 PyObject * obj1 = 0 ;
39651 char *kwnames[] = {
39652 (char *) "self",(char *) "_self", NULL
39653 };
39654
39655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39657 if (SWIG_arg_fail(1)) SWIG_fail;
39658 arg2 = obj1;
39659 {
39660 PyThreadState* __tstate = wxPyBeginAllowThreads();
39661 wxSizer__setOORInfo(arg1,arg2);
39662
39663 wxPyEndAllowThreads(__tstate);
39664 if (PyErr_Occurred()) SWIG_fail;
39665 }
39666 Py_INCREF(Py_None); resultobj = Py_None;
39667 return resultobj;
39668 fail:
39669 return NULL;
39670 }
39671
39672
39673 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39674 PyObject *resultobj;
39675 wxSizer *arg1 = (wxSizer *) 0 ;
39676 PyObject *arg2 = (PyObject *) 0 ;
39677 int arg3 = (int) 0 ;
39678 int arg4 = (int) 0 ;
39679 int arg5 = (int) 0 ;
39680 PyObject *arg6 = (PyObject *) NULL ;
39681 wxSizerItem *result;
39682 PyObject * obj0 = 0 ;
39683 PyObject * obj1 = 0 ;
39684 PyObject * obj2 = 0 ;
39685 PyObject * obj3 = 0 ;
39686 PyObject * obj4 = 0 ;
39687 PyObject * obj5 = 0 ;
39688 char *kwnames[] = {
39689 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39690 };
39691
39692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39694 if (SWIG_arg_fail(1)) SWIG_fail;
39695 arg2 = obj1;
39696 if (obj2) {
39697 {
39698 arg3 = (int)(SWIG_As_int(obj2));
39699 if (SWIG_arg_fail(3)) SWIG_fail;
39700 }
39701 }
39702 if (obj3) {
39703 {
39704 arg4 = (int)(SWIG_As_int(obj3));
39705 if (SWIG_arg_fail(4)) SWIG_fail;
39706 }
39707 }
39708 if (obj4) {
39709 {
39710 arg5 = (int)(SWIG_As_int(obj4));
39711 if (SWIG_arg_fail(5)) SWIG_fail;
39712 }
39713 }
39714 if (obj5) {
39715 arg6 = obj5;
39716 }
39717 {
39718 PyThreadState* __tstate = wxPyBeginAllowThreads();
39719 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39720
39721 wxPyEndAllowThreads(__tstate);
39722 if (PyErr_Occurred()) SWIG_fail;
39723 }
39724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39725 return resultobj;
39726 fail:
39727 return NULL;
39728 }
39729
39730
39731 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39732 PyObject *resultobj;
39733 wxSizer *arg1 = (wxSizer *) 0 ;
39734 int arg2 ;
39735 PyObject *arg3 = (PyObject *) 0 ;
39736 int arg4 = (int) 0 ;
39737 int arg5 = (int) 0 ;
39738 int arg6 = (int) 0 ;
39739 PyObject *arg7 = (PyObject *) NULL ;
39740 wxSizerItem *result;
39741 PyObject * obj0 = 0 ;
39742 PyObject * obj1 = 0 ;
39743 PyObject * obj2 = 0 ;
39744 PyObject * obj3 = 0 ;
39745 PyObject * obj4 = 0 ;
39746 PyObject * obj5 = 0 ;
39747 PyObject * obj6 = 0 ;
39748 char *kwnames[] = {
39749 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39750 };
39751
39752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39754 if (SWIG_arg_fail(1)) SWIG_fail;
39755 {
39756 arg2 = (int)(SWIG_As_int(obj1));
39757 if (SWIG_arg_fail(2)) SWIG_fail;
39758 }
39759 arg3 = obj2;
39760 if (obj3) {
39761 {
39762 arg4 = (int)(SWIG_As_int(obj3));
39763 if (SWIG_arg_fail(4)) SWIG_fail;
39764 }
39765 }
39766 if (obj4) {
39767 {
39768 arg5 = (int)(SWIG_As_int(obj4));
39769 if (SWIG_arg_fail(5)) SWIG_fail;
39770 }
39771 }
39772 if (obj5) {
39773 {
39774 arg6 = (int)(SWIG_As_int(obj5));
39775 if (SWIG_arg_fail(6)) SWIG_fail;
39776 }
39777 }
39778 if (obj6) {
39779 arg7 = obj6;
39780 }
39781 {
39782 PyThreadState* __tstate = wxPyBeginAllowThreads();
39783 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39784
39785 wxPyEndAllowThreads(__tstate);
39786 if (PyErr_Occurred()) SWIG_fail;
39787 }
39788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39789 return resultobj;
39790 fail:
39791 return NULL;
39792 }
39793
39794
39795 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39796 PyObject *resultobj;
39797 wxSizer *arg1 = (wxSizer *) 0 ;
39798 PyObject *arg2 = (PyObject *) 0 ;
39799 int arg3 = (int) 0 ;
39800 int arg4 = (int) 0 ;
39801 int arg5 = (int) 0 ;
39802 PyObject *arg6 = (PyObject *) NULL ;
39803 wxSizerItem *result;
39804 PyObject * obj0 = 0 ;
39805 PyObject * obj1 = 0 ;
39806 PyObject * obj2 = 0 ;
39807 PyObject * obj3 = 0 ;
39808 PyObject * obj4 = 0 ;
39809 PyObject * obj5 = 0 ;
39810 char *kwnames[] = {
39811 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39812 };
39813
39814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39816 if (SWIG_arg_fail(1)) SWIG_fail;
39817 arg2 = obj1;
39818 if (obj2) {
39819 {
39820 arg3 = (int)(SWIG_As_int(obj2));
39821 if (SWIG_arg_fail(3)) SWIG_fail;
39822 }
39823 }
39824 if (obj3) {
39825 {
39826 arg4 = (int)(SWIG_As_int(obj3));
39827 if (SWIG_arg_fail(4)) SWIG_fail;
39828 }
39829 }
39830 if (obj4) {
39831 {
39832 arg5 = (int)(SWIG_As_int(obj4));
39833 if (SWIG_arg_fail(5)) SWIG_fail;
39834 }
39835 }
39836 if (obj5) {
39837 arg6 = obj5;
39838 }
39839 {
39840 PyThreadState* __tstate = wxPyBeginAllowThreads();
39841 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39842
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39847 return resultobj;
39848 fail:
39849 return NULL;
39850 }
39851
39852
39853 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39854 PyObject *resultobj;
39855 wxSizer *arg1 = (wxSizer *) 0 ;
39856 PyObject *arg2 = (PyObject *) 0 ;
39857 bool result;
39858 PyObject * obj0 = 0 ;
39859 PyObject * obj1 = 0 ;
39860 char *kwnames[] = {
39861 (char *) "self",(char *) "item", NULL
39862 };
39863
39864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39866 if (SWIG_arg_fail(1)) SWIG_fail;
39867 arg2 = obj1;
39868 {
39869 PyThreadState* __tstate = wxPyBeginAllowThreads();
39870 result = (bool)wxSizer_Remove(arg1,arg2);
39871
39872 wxPyEndAllowThreads(__tstate);
39873 if (PyErr_Occurred()) SWIG_fail;
39874 }
39875 {
39876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39877 }
39878 return resultobj;
39879 fail:
39880 return NULL;
39881 }
39882
39883
39884 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39885 PyObject *resultobj;
39886 wxSizer *arg1 = (wxSizer *) 0 ;
39887 PyObject *arg2 = (PyObject *) 0 ;
39888 bool result;
39889 PyObject * obj0 = 0 ;
39890 PyObject * obj1 = 0 ;
39891 char *kwnames[] = {
39892 (char *) "self",(char *) "item", NULL
39893 };
39894
39895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39897 if (SWIG_arg_fail(1)) SWIG_fail;
39898 arg2 = obj1;
39899 {
39900 PyThreadState* __tstate = wxPyBeginAllowThreads();
39901 result = (bool)wxSizer_Detach(arg1,arg2);
39902
39903 wxPyEndAllowThreads(__tstate);
39904 if (PyErr_Occurred()) SWIG_fail;
39905 }
39906 {
39907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39908 }
39909 return resultobj;
39910 fail:
39911 return NULL;
39912 }
39913
39914
39915 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39916 PyObject *resultobj;
39917 wxSizer *arg1 = (wxSizer *) 0 ;
39918 PyObject *arg2 = (PyObject *) 0 ;
39919 wxSizerItem *result;
39920 PyObject * obj0 = 0 ;
39921 PyObject * obj1 = 0 ;
39922 char *kwnames[] = {
39923 (char *) "self",(char *) "item", NULL
39924 };
39925
39926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39928 if (SWIG_arg_fail(1)) SWIG_fail;
39929 arg2 = obj1;
39930 {
39931 PyThreadState* __tstate = wxPyBeginAllowThreads();
39932 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39933
39934 wxPyEndAllowThreads(__tstate);
39935 if (PyErr_Occurred()) SWIG_fail;
39936 }
39937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39938 return resultobj;
39939 fail:
39940 return NULL;
39941 }
39942
39943
39944 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39945 PyObject *resultobj;
39946 wxSizer *arg1 = (wxSizer *) 0 ;
39947 PyObject *arg2 = (PyObject *) 0 ;
39948 wxSize *arg3 = 0 ;
39949 wxSize temp3 ;
39950 PyObject * obj0 = 0 ;
39951 PyObject * obj1 = 0 ;
39952 PyObject * obj2 = 0 ;
39953 char *kwnames[] = {
39954 (char *) "self",(char *) "item",(char *) "size", NULL
39955 };
39956
39957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39959 if (SWIG_arg_fail(1)) SWIG_fail;
39960 arg2 = obj1;
39961 {
39962 arg3 = &temp3;
39963 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39964 }
39965 {
39966 PyThreadState* __tstate = wxPyBeginAllowThreads();
39967 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39968
39969 wxPyEndAllowThreads(__tstate);
39970 if (PyErr_Occurred()) SWIG_fail;
39971 }
39972 Py_INCREF(Py_None); resultobj = Py_None;
39973 return resultobj;
39974 fail:
39975 return NULL;
39976 }
39977
39978
39979 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39980 PyObject *resultobj;
39981 wxSizer *arg1 = (wxSizer *) 0 ;
39982 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39983 wxSizerItem *result;
39984 PyObject * obj0 = 0 ;
39985 PyObject * obj1 = 0 ;
39986 char *kwnames[] = {
39987 (char *) "self",(char *) "item", NULL
39988 };
39989
39990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39992 if (SWIG_arg_fail(1)) SWIG_fail;
39993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39994 if (SWIG_arg_fail(2)) SWIG_fail;
39995 {
39996 PyThreadState* __tstate = wxPyBeginAllowThreads();
39997 result = (wxSizerItem *)(arg1)->Add(arg2);
39998
39999 wxPyEndAllowThreads(__tstate);
40000 if (PyErr_Occurred()) SWIG_fail;
40001 }
40002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40003 return resultobj;
40004 fail:
40005 return NULL;
40006 }
40007
40008
40009 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40010 PyObject *resultobj;
40011 wxSizer *arg1 = (wxSizer *) 0 ;
40012 size_t arg2 ;
40013 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40014 wxSizerItem *result;
40015 PyObject * obj0 = 0 ;
40016 PyObject * obj1 = 0 ;
40017 PyObject * obj2 = 0 ;
40018 char *kwnames[] = {
40019 (char *) "self",(char *) "index",(char *) "item", NULL
40020 };
40021
40022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40024 if (SWIG_arg_fail(1)) SWIG_fail;
40025 {
40026 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40027 if (SWIG_arg_fail(2)) SWIG_fail;
40028 }
40029 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40030 if (SWIG_arg_fail(3)) SWIG_fail;
40031 {
40032 PyThreadState* __tstate = wxPyBeginAllowThreads();
40033 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40034
40035 wxPyEndAllowThreads(__tstate);
40036 if (PyErr_Occurred()) SWIG_fail;
40037 }
40038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40039 return resultobj;
40040 fail:
40041 return NULL;
40042 }
40043
40044
40045 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40046 PyObject *resultobj;
40047 wxSizer *arg1 = (wxSizer *) 0 ;
40048 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40049 wxSizerItem *result;
40050 PyObject * obj0 = 0 ;
40051 PyObject * obj1 = 0 ;
40052 char *kwnames[] = {
40053 (char *) "self",(char *) "item", NULL
40054 };
40055
40056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40058 if (SWIG_arg_fail(1)) SWIG_fail;
40059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40060 if (SWIG_arg_fail(2)) SWIG_fail;
40061 {
40062 PyThreadState* __tstate = wxPyBeginAllowThreads();
40063 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40064
40065 wxPyEndAllowThreads(__tstate);
40066 if (PyErr_Occurred()) SWIG_fail;
40067 }
40068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40069 return resultobj;
40070 fail:
40071 return NULL;
40072 }
40073
40074
40075 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40076 PyObject *resultobj;
40077 wxSizer *arg1 = (wxSizer *) 0 ;
40078 int arg2 ;
40079 int arg3 ;
40080 int arg4 ;
40081 int arg5 ;
40082 PyObject * obj0 = 0 ;
40083 PyObject * obj1 = 0 ;
40084 PyObject * obj2 = 0 ;
40085 PyObject * obj3 = 0 ;
40086 PyObject * obj4 = 0 ;
40087 char *kwnames[] = {
40088 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40089 };
40090
40091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40093 if (SWIG_arg_fail(1)) SWIG_fail;
40094 {
40095 arg2 = (int)(SWIG_As_int(obj1));
40096 if (SWIG_arg_fail(2)) SWIG_fail;
40097 }
40098 {
40099 arg3 = (int)(SWIG_As_int(obj2));
40100 if (SWIG_arg_fail(3)) SWIG_fail;
40101 }
40102 {
40103 arg4 = (int)(SWIG_As_int(obj3));
40104 if (SWIG_arg_fail(4)) SWIG_fail;
40105 }
40106 {
40107 arg5 = (int)(SWIG_As_int(obj4));
40108 if (SWIG_arg_fail(5)) SWIG_fail;
40109 }
40110 {
40111 PyThreadState* __tstate = wxPyBeginAllowThreads();
40112 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40113
40114 wxPyEndAllowThreads(__tstate);
40115 if (PyErr_Occurred()) SWIG_fail;
40116 }
40117 Py_INCREF(Py_None); resultobj = Py_None;
40118 return resultobj;
40119 fail:
40120 return NULL;
40121 }
40122
40123
40124 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40125 PyObject *resultobj;
40126 wxSizer *arg1 = (wxSizer *) 0 ;
40127 wxSize *arg2 = 0 ;
40128 wxSize temp2 ;
40129 PyObject * obj0 = 0 ;
40130 PyObject * obj1 = 0 ;
40131 char *kwnames[] = {
40132 (char *) "self",(char *) "size", NULL
40133 };
40134
40135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40137 if (SWIG_arg_fail(1)) SWIG_fail;
40138 {
40139 arg2 = &temp2;
40140 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40141 }
40142 {
40143 PyThreadState* __tstate = wxPyBeginAllowThreads();
40144 (arg1)->SetMinSize((wxSize const &)*arg2);
40145
40146 wxPyEndAllowThreads(__tstate);
40147 if (PyErr_Occurred()) SWIG_fail;
40148 }
40149 Py_INCREF(Py_None); resultobj = Py_None;
40150 return resultobj;
40151 fail:
40152 return NULL;
40153 }
40154
40155
40156 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40157 PyObject *resultobj;
40158 wxSizer *arg1 = (wxSizer *) 0 ;
40159 wxSize result;
40160 PyObject * obj0 = 0 ;
40161 char *kwnames[] = {
40162 (char *) "self", NULL
40163 };
40164
40165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40167 if (SWIG_arg_fail(1)) SWIG_fail;
40168 {
40169 PyThreadState* __tstate = wxPyBeginAllowThreads();
40170 result = (arg1)->GetSize();
40171
40172 wxPyEndAllowThreads(__tstate);
40173 if (PyErr_Occurred()) SWIG_fail;
40174 }
40175 {
40176 wxSize * resultptr;
40177 resultptr = new wxSize((wxSize &)(result));
40178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40179 }
40180 return resultobj;
40181 fail:
40182 return NULL;
40183 }
40184
40185
40186 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40187 PyObject *resultobj;
40188 wxSizer *arg1 = (wxSizer *) 0 ;
40189 wxPoint result;
40190 PyObject * obj0 = 0 ;
40191 char *kwnames[] = {
40192 (char *) "self", NULL
40193 };
40194
40195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40197 if (SWIG_arg_fail(1)) SWIG_fail;
40198 {
40199 PyThreadState* __tstate = wxPyBeginAllowThreads();
40200 result = (arg1)->GetPosition();
40201
40202 wxPyEndAllowThreads(__tstate);
40203 if (PyErr_Occurred()) SWIG_fail;
40204 }
40205 {
40206 wxPoint * resultptr;
40207 resultptr = new wxPoint((wxPoint &)(result));
40208 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40209 }
40210 return resultobj;
40211 fail:
40212 return NULL;
40213 }
40214
40215
40216 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40217 PyObject *resultobj;
40218 wxSizer *arg1 = (wxSizer *) 0 ;
40219 wxSize result;
40220 PyObject * obj0 = 0 ;
40221 char *kwnames[] = {
40222 (char *) "self", NULL
40223 };
40224
40225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40227 if (SWIG_arg_fail(1)) SWIG_fail;
40228 {
40229 PyThreadState* __tstate = wxPyBeginAllowThreads();
40230 result = (arg1)->GetMinSize();
40231
40232 wxPyEndAllowThreads(__tstate);
40233 if (PyErr_Occurred()) SWIG_fail;
40234 }
40235 {
40236 wxSize * resultptr;
40237 resultptr = new wxSize((wxSize &)(result));
40238 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40239 }
40240 return resultobj;
40241 fail:
40242 return NULL;
40243 }
40244
40245
40246 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40247 PyObject *resultobj;
40248 wxSizer *arg1 = (wxSizer *) 0 ;
40249 PyObject * obj0 = 0 ;
40250 char *kwnames[] = {
40251 (char *) "self", NULL
40252 };
40253
40254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40256 if (SWIG_arg_fail(1)) SWIG_fail;
40257 {
40258 PyThreadState* __tstate = wxPyBeginAllowThreads();
40259 (arg1)->RecalcSizes();
40260
40261 wxPyEndAllowThreads(__tstate);
40262 if (PyErr_Occurred()) SWIG_fail;
40263 }
40264 Py_INCREF(Py_None); resultobj = Py_None;
40265 return resultobj;
40266 fail:
40267 return NULL;
40268 }
40269
40270
40271 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40272 PyObject *resultobj;
40273 wxSizer *arg1 = (wxSizer *) 0 ;
40274 wxSize result;
40275 PyObject * obj0 = 0 ;
40276 char *kwnames[] = {
40277 (char *) "self", NULL
40278 };
40279
40280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40282 if (SWIG_arg_fail(1)) SWIG_fail;
40283 {
40284 PyThreadState* __tstate = wxPyBeginAllowThreads();
40285 result = (arg1)->CalcMin();
40286
40287 wxPyEndAllowThreads(__tstate);
40288 if (PyErr_Occurred()) SWIG_fail;
40289 }
40290 {
40291 wxSize * resultptr;
40292 resultptr = new wxSize((wxSize &)(result));
40293 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40294 }
40295 return resultobj;
40296 fail:
40297 return NULL;
40298 }
40299
40300
40301 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40302 PyObject *resultobj;
40303 wxSizer *arg1 = (wxSizer *) 0 ;
40304 PyObject * obj0 = 0 ;
40305 char *kwnames[] = {
40306 (char *) "self", NULL
40307 };
40308
40309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40311 if (SWIG_arg_fail(1)) SWIG_fail;
40312 {
40313 PyThreadState* __tstate = wxPyBeginAllowThreads();
40314 (arg1)->Layout();
40315
40316 wxPyEndAllowThreads(__tstate);
40317 if (PyErr_Occurred()) SWIG_fail;
40318 }
40319 Py_INCREF(Py_None); resultobj = Py_None;
40320 return resultobj;
40321 fail:
40322 return NULL;
40323 }
40324
40325
40326 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40327 PyObject *resultobj;
40328 wxSizer *arg1 = (wxSizer *) 0 ;
40329 wxWindow *arg2 = (wxWindow *) 0 ;
40330 wxSize result;
40331 PyObject * obj0 = 0 ;
40332 PyObject * obj1 = 0 ;
40333 char *kwnames[] = {
40334 (char *) "self",(char *) "window", NULL
40335 };
40336
40337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40339 if (SWIG_arg_fail(1)) SWIG_fail;
40340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40341 if (SWIG_arg_fail(2)) SWIG_fail;
40342 {
40343 PyThreadState* __tstate = wxPyBeginAllowThreads();
40344 result = (arg1)->Fit(arg2);
40345
40346 wxPyEndAllowThreads(__tstate);
40347 if (PyErr_Occurred()) SWIG_fail;
40348 }
40349 {
40350 wxSize * resultptr;
40351 resultptr = new wxSize((wxSize &)(result));
40352 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40353 }
40354 return resultobj;
40355 fail:
40356 return NULL;
40357 }
40358
40359
40360 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40361 PyObject *resultobj;
40362 wxSizer *arg1 = (wxSizer *) 0 ;
40363 wxWindow *arg2 = (wxWindow *) 0 ;
40364 PyObject * obj0 = 0 ;
40365 PyObject * obj1 = 0 ;
40366 char *kwnames[] = {
40367 (char *) "self",(char *) "window", NULL
40368 };
40369
40370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40372 if (SWIG_arg_fail(1)) SWIG_fail;
40373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40374 if (SWIG_arg_fail(2)) SWIG_fail;
40375 {
40376 PyThreadState* __tstate = wxPyBeginAllowThreads();
40377 (arg1)->FitInside(arg2);
40378
40379 wxPyEndAllowThreads(__tstate);
40380 if (PyErr_Occurred()) SWIG_fail;
40381 }
40382 Py_INCREF(Py_None); resultobj = Py_None;
40383 return resultobj;
40384 fail:
40385 return NULL;
40386 }
40387
40388
40389 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40390 PyObject *resultobj;
40391 wxSizer *arg1 = (wxSizer *) 0 ;
40392 wxWindow *arg2 = (wxWindow *) 0 ;
40393 PyObject * obj0 = 0 ;
40394 PyObject * obj1 = 0 ;
40395 char *kwnames[] = {
40396 (char *) "self",(char *) "window", NULL
40397 };
40398
40399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40401 if (SWIG_arg_fail(1)) SWIG_fail;
40402 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40403 if (SWIG_arg_fail(2)) SWIG_fail;
40404 {
40405 PyThreadState* __tstate = wxPyBeginAllowThreads();
40406 (arg1)->SetSizeHints(arg2);
40407
40408 wxPyEndAllowThreads(__tstate);
40409 if (PyErr_Occurred()) SWIG_fail;
40410 }
40411 Py_INCREF(Py_None); resultobj = Py_None;
40412 return resultobj;
40413 fail:
40414 return NULL;
40415 }
40416
40417
40418 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40419 PyObject *resultobj;
40420 wxSizer *arg1 = (wxSizer *) 0 ;
40421 wxWindow *arg2 = (wxWindow *) 0 ;
40422 PyObject * obj0 = 0 ;
40423 PyObject * obj1 = 0 ;
40424 char *kwnames[] = {
40425 (char *) "self",(char *) "window", NULL
40426 };
40427
40428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40430 if (SWIG_arg_fail(1)) SWIG_fail;
40431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40432 if (SWIG_arg_fail(2)) SWIG_fail;
40433 {
40434 PyThreadState* __tstate = wxPyBeginAllowThreads();
40435 (arg1)->SetVirtualSizeHints(arg2);
40436
40437 wxPyEndAllowThreads(__tstate);
40438 if (PyErr_Occurred()) SWIG_fail;
40439 }
40440 Py_INCREF(Py_None); resultobj = Py_None;
40441 return resultobj;
40442 fail:
40443 return NULL;
40444 }
40445
40446
40447 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40448 PyObject *resultobj;
40449 wxSizer *arg1 = (wxSizer *) 0 ;
40450 bool arg2 = (bool) false ;
40451 PyObject * obj0 = 0 ;
40452 PyObject * obj1 = 0 ;
40453 char *kwnames[] = {
40454 (char *) "self",(char *) "deleteWindows", NULL
40455 };
40456
40457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40459 if (SWIG_arg_fail(1)) SWIG_fail;
40460 if (obj1) {
40461 {
40462 arg2 = (bool)(SWIG_As_bool(obj1));
40463 if (SWIG_arg_fail(2)) SWIG_fail;
40464 }
40465 }
40466 {
40467 PyThreadState* __tstate = wxPyBeginAllowThreads();
40468 (arg1)->Clear(arg2);
40469
40470 wxPyEndAllowThreads(__tstate);
40471 if (PyErr_Occurred()) SWIG_fail;
40472 }
40473 Py_INCREF(Py_None); resultobj = Py_None;
40474 return resultobj;
40475 fail:
40476 return NULL;
40477 }
40478
40479
40480 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40481 PyObject *resultobj;
40482 wxSizer *arg1 = (wxSizer *) 0 ;
40483 PyObject * obj0 = 0 ;
40484 char *kwnames[] = {
40485 (char *) "self", NULL
40486 };
40487
40488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40490 if (SWIG_arg_fail(1)) SWIG_fail;
40491 {
40492 PyThreadState* __tstate = wxPyBeginAllowThreads();
40493 (arg1)->DeleteWindows();
40494
40495 wxPyEndAllowThreads(__tstate);
40496 if (PyErr_Occurred()) SWIG_fail;
40497 }
40498 Py_INCREF(Py_None); resultobj = Py_None;
40499 return resultobj;
40500 fail:
40501 return NULL;
40502 }
40503
40504
40505 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40506 PyObject *resultobj;
40507 wxSizer *arg1 = (wxSizer *) 0 ;
40508 PyObject *result;
40509 PyObject * obj0 = 0 ;
40510 char *kwnames[] = {
40511 (char *) "self", NULL
40512 };
40513
40514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40516 if (SWIG_arg_fail(1)) SWIG_fail;
40517 {
40518 PyThreadState* __tstate = wxPyBeginAllowThreads();
40519 result = (PyObject *)wxSizer_GetChildren(arg1);
40520
40521 wxPyEndAllowThreads(__tstate);
40522 if (PyErr_Occurred()) SWIG_fail;
40523 }
40524 resultobj = result;
40525 return resultobj;
40526 fail:
40527 return NULL;
40528 }
40529
40530
40531 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40532 PyObject *resultobj;
40533 wxSizer *arg1 = (wxSizer *) 0 ;
40534 PyObject *arg2 = (PyObject *) 0 ;
40535 bool arg3 = (bool) true ;
40536 bool arg4 = (bool) false ;
40537 bool result;
40538 PyObject * obj0 = 0 ;
40539 PyObject * obj1 = 0 ;
40540 PyObject * obj2 = 0 ;
40541 PyObject * obj3 = 0 ;
40542 char *kwnames[] = {
40543 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40544 };
40545
40546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40548 if (SWIG_arg_fail(1)) SWIG_fail;
40549 arg2 = obj1;
40550 if (obj2) {
40551 {
40552 arg3 = (bool)(SWIG_As_bool(obj2));
40553 if (SWIG_arg_fail(3)) SWIG_fail;
40554 }
40555 }
40556 if (obj3) {
40557 {
40558 arg4 = (bool)(SWIG_As_bool(obj3));
40559 if (SWIG_arg_fail(4)) SWIG_fail;
40560 }
40561 }
40562 {
40563 PyThreadState* __tstate = wxPyBeginAllowThreads();
40564 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40565
40566 wxPyEndAllowThreads(__tstate);
40567 if (PyErr_Occurred()) SWIG_fail;
40568 }
40569 {
40570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40571 }
40572 return resultobj;
40573 fail:
40574 return NULL;
40575 }
40576
40577
40578 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40579 PyObject *resultobj;
40580 wxSizer *arg1 = (wxSizer *) 0 ;
40581 PyObject *arg2 = (PyObject *) 0 ;
40582 bool result;
40583 PyObject * obj0 = 0 ;
40584 PyObject * obj1 = 0 ;
40585 char *kwnames[] = {
40586 (char *) "self",(char *) "item", NULL
40587 };
40588
40589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40591 if (SWIG_arg_fail(1)) SWIG_fail;
40592 arg2 = obj1;
40593 {
40594 PyThreadState* __tstate = wxPyBeginAllowThreads();
40595 result = (bool)wxSizer_IsShown(arg1,arg2);
40596
40597 wxPyEndAllowThreads(__tstate);
40598 if (PyErr_Occurred()) SWIG_fail;
40599 }
40600 {
40601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40602 }
40603 return resultobj;
40604 fail:
40605 return NULL;
40606 }
40607
40608
40609 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40610 PyObject *resultobj;
40611 wxSizer *arg1 = (wxSizer *) 0 ;
40612 bool arg2 ;
40613 PyObject * obj0 = 0 ;
40614 PyObject * obj1 = 0 ;
40615 char *kwnames[] = {
40616 (char *) "self",(char *) "show", NULL
40617 };
40618
40619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40621 if (SWIG_arg_fail(1)) SWIG_fail;
40622 {
40623 arg2 = (bool)(SWIG_As_bool(obj1));
40624 if (SWIG_arg_fail(2)) SWIG_fail;
40625 }
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 (arg1)->ShowItems(arg2);
40629
40630 wxPyEndAllowThreads(__tstate);
40631 if (PyErr_Occurred()) SWIG_fail;
40632 }
40633 Py_INCREF(Py_None); resultobj = Py_None;
40634 return resultobj;
40635 fail:
40636 return NULL;
40637 }
40638
40639
40640 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40641 PyObject *obj;
40642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40643 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40644 Py_INCREF(obj);
40645 return Py_BuildValue((char *)"");
40646 }
40647 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40648 PyObject *resultobj;
40649 wxPySizer *result;
40650 char *kwnames[] = {
40651 NULL
40652 };
40653
40654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40655 {
40656 PyThreadState* __tstate = wxPyBeginAllowThreads();
40657 result = (wxPySizer *)new wxPySizer();
40658
40659 wxPyEndAllowThreads(__tstate);
40660 if (PyErr_Occurred()) SWIG_fail;
40661 }
40662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40663 return resultobj;
40664 fail:
40665 return NULL;
40666 }
40667
40668
40669 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40670 PyObject *resultobj;
40671 wxPySizer *arg1 = (wxPySizer *) 0 ;
40672 PyObject *arg2 = (PyObject *) 0 ;
40673 PyObject *arg3 = (PyObject *) 0 ;
40674 PyObject * obj0 = 0 ;
40675 PyObject * obj1 = 0 ;
40676 PyObject * obj2 = 0 ;
40677 char *kwnames[] = {
40678 (char *) "self",(char *) "self",(char *) "_class", NULL
40679 };
40680
40681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40683 if (SWIG_arg_fail(1)) SWIG_fail;
40684 arg2 = obj1;
40685 arg3 = obj2;
40686 {
40687 PyThreadState* __tstate = wxPyBeginAllowThreads();
40688 (arg1)->_setCallbackInfo(arg2,arg3);
40689
40690 wxPyEndAllowThreads(__tstate);
40691 if (PyErr_Occurred()) SWIG_fail;
40692 }
40693 Py_INCREF(Py_None); resultobj = Py_None;
40694 return resultobj;
40695 fail:
40696 return NULL;
40697 }
40698
40699
40700 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40701 PyObject *obj;
40702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40703 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40704 Py_INCREF(obj);
40705 return Py_BuildValue((char *)"");
40706 }
40707 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40708 PyObject *resultobj;
40709 int arg1 = (int) wxHORIZONTAL ;
40710 wxBoxSizer *result;
40711 PyObject * obj0 = 0 ;
40712 char *kwnames[] = {
40713 (char *) "orient", NULL
40714 };
40715
40716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40717 if (obj0) {
40718 {
40719 arg1 = (int)(SWIG_As_int(obj0));
40720 if (SWIG_arg_fail(1)) SWIG_fail;
40721 }
40722 }
40723 {
40724 PyThreadState* __tstate = wxPyBeginAllowThreads();
40725 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40726
40727 wxPyEndAllowThreads(__tstate);
40728 if (PyErr_Occurred()) SWIG_fail;
40729 }
40730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40731 return resultobj;
40732 fail:
40733 return NULL;
40734 }
40735
40736
40737 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40738 PyObject *resultobj;
40739 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40740 int result;
40741 PyObject * obj0 = 0 ;
40742 char *kwnames[] = {
40743 (char *) "self", NULL
40744 };
40745
40746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40748 if (SWIG_arg_fail(1)) SWIG_fail;
40749 {
40750 PyThreadState* __tstate = wxPyBeginAllowThreads();
40751 result = (int)(arg1)->GetOrientation();
40752
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 {
40757 resultobj = SWIG_From_int((int)(result));
40758 }
40759 return resultobj;
40760 fail:
40761 return NULL;
40762 }
40763
40764
40765 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40766 PyObject *resultobj;
40767 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40768 int arg2 ;
40769 PyObject * obj0 = 0 ;
40770 PyObject * obj1 = 0 ;
40771 char *kwnames[] = {
40772 (char *) "self",(char *) "orient", NULL
40773 };
40774
40775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40777 if (SWIG_arg_fail(1)) SWIG_fail;
40778 {
40779 arg2 = (int)(SWIG_As_int(obj1));
40780 if (SWIG_arg_fail(2)) SWIG_fail;
40781 }
40782 {
40783 PyThreadState* __tstate = wxPyBeginAllowThreads();
40784 (arg1)->SetOrientation(arg2);
40785
40786 wxPyEndAllowThreads(__tstate);
40787 if (PyErr_Occurred()) SWIG_fail;
40788 }
40789 Py_INCREF(Py_None); resultobj = Py_None;
40790 return resultobj;
40791 fail:
40792 return NULL;
40793 }
40794
40795
40796 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40797 PyObject *obj;
40798 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40799 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40800 Py_INCREF(obj);
40801 return Py_BuildValue((char *)"");
40802 }
40803 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40804 PyObject *resultobj;
40805 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40806 int arg2 = (int) wxHORIZONTAL ;
40807 wxStaticBoxSizer *result;
40808 PyObject * obj0 = 0 ;
40809 PyObject * obj1 = 0 ;
40810 char *kwnames[] = {
40811 (char *) "box",(char *) "orient", NULL
40812 };
40813
40814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40816 if (SWIG_arg_fail(1)) SWIG_fail;
40817 if (obj1) {
40818 {
40819 arg2 = (int)(SWIG_As_int(obj1));
40820 if (SWIG_arg_fail(2)) SWIG_fail;
40821 }
40822 }
40823 {
40824 PyThreadState* __tstate = wxPyBeginAllowThreads();
40825 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40826
40827 wxPyEndAllowThreads(__tstate);
40828 if (PyErr_Occurred()) SWIG_fail;
40829 }
40830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40831 return resultobj;
40832 fail:
40833 return NULL;
40834 }
40835
40836
40837 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40838 PyObject *resultobj;
40839 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40840 wxStaticBox *result;
40841 PyObject * obj0 = 0 ;
40842 char *kwnames[] = {
40843 (char *) "self", NULL
40844 };
40845
40846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40848 if (SWIG_arg_fail(1)) SWIG_fail;
40849 {
40850 PyThreadState* __tstate = wxPyBeginAllowThreads();
40851 result = (wxStaticBox *)(arg1)->GetStaticBox();
40852
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 {
40857 resultobj = wxPyMake_wxObject(result, 0);
40858 }
40859 return resultobj;
40860 fail:
40861 return NULL;
40862 }
40863
40864
40865 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40866 PyObject *obj;
40867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40868 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40869 Py_INCREF(obj);
40870 return Py_BuildValue((char *)"");
40871 }
40872 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40873 PyObject *resultobj;
40874 int arg1 = (int) 1 ;
40875 int arg2 = (int) 0 ;
40876 int arg3 = (int) 0 ;
40877 int arg4 = (int) 0 ;
40878 wxGridSizer *result;
40879 PyObject * obj0 = 0 ;
40880 PyObject * obj1 = 0 ;
40881 PyObject * obj2 = 0 ;
40882 PyObject * obj3 = 0 ;
40883 char *kwnames[] = {
40884 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40885 };
40886
40887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40888 if (obj0) {
40889 {
40890 arg1 = (int)(SWIG_As_int(obj0));
40891 if (SWIG_arg_fail(1)) SWIG_fail;
40892 }
40893 }
40894 if (obj1) {
40895 {
40896 arg2 = (int)(SWIG_As_int(obj1));
40897 if (SWIG_arg_fail(2)) SWIG_fail;
40898 }
40899 }
40900 if (obj2) {
40901 {
40902 arg3 = (int)(SWIG_As_int(obj2));
40903 if (SWIG_arg_fail(3)) SWIG_fail;
40904 }
40905 }
40906 if (obj3) {
40907 {
40908 arg4 = (int)(SWIG_As_int(obj3));
40909 if (SWIG_arg_fail(4)) SWIG_fail;
40910 }
40911 }
40912 {
40913 PyThreadState* __tstate = wxPyBeginAllowThreads();
40914 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40915
40916 wxPyEndAllowThreads(__tstate);
40917 if (PyErr_Occurred()) SWIG_fail;
40918 }
40919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40920 return resultobj;
40921 fail:
40922 return NULL;
40923 }
40924
40925
40926 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40927 PyObject *resultobj;
40928 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40929 int arg2 ;
40930 PyObject * obj0 = 0 ;
40931 PyObject * obj1 = 0 ;
40932 char *kwnames[] = {
40933 (char *) "self",(char *) "cols", NULL
40934 };
40935
40936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40938 if (SWIG_arg_fail(1)) SWIG_fail;
40939 {
40940 arg2 = (int)(SWIG_As_int(obj1));
40941 if (SWIG_arg_fail(2)) SWIG_fail;
40942 }
40943 {
40944 PyThreadState* __tstate = wxPyBeginAllowThreads();
40945 (arg1)->SetCols(arg2);
40946
40947 wxPyEndAllowThreads(__tstate);
40948 if (PyErr_Occurred()) SWIG_fail;
40949 }
40950 Py_INCREF(Py_None); resultobj = Py_None;
40951 return resultobj;
40952 fail:
40953 return NULL;
40954 }
40955
40956
40957 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40958 PyObject *resultobj;
40959 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40960 int arg2 ;
40961 PyObject * obj0 = 0 ;
40962 PyObject * obj1 = 0 ;
40963 char *kwnames[] = {
40964 (char *) "self",(char *) "rows", NULL
40965 };
40966
40967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40969 if (SWIG_arg_fail(1)) SWIG_fail;
40970 {
40971 arg2 = (int)(SWIG_As_int(obj1));
40972 if (SWIG_arg_fail(2)) SWIG_fail;
40973 }
40974 {
40975 PyThreadState* __tstate = wxPyBeginAllowThreads();
40976 (arg1)->SetRows(arg2);
40977
40978 wxPyEndAllowThreads(__tstate);
40979 if (PyErr_Occurred()) SWIG_fail;
40980 }
40981 Py_INCREF(Py_None); resultobj = Py_None;
40982 return resultobj;
40983 fail:
40984 return NULL;
40985 }
40986
40987
40988 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40989 PyObject *resultobj;
40990 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40991 int arg2 ;
40992 PyObject * obj0 = 0 ;
40993 PyObject * obj1 = 0 ;
40994 char *kwnames[] = {
40995 (char *) "self",(char *) "gap", NULL
40996 };
40997
40998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41000 if (SWIG_arg_fail(1)) SWIG_fail;
41001 {
41002 arg2 = (int)(SWIG_As_int(obj1));
41003 if (SWIG_arg_fail(2)) SWIG_fail;
41004 }
41005 {
41006 PyThreadState* __tstate = wxPyBeginAllowThreads();
41007 (arg1)->SetVGap(arg2);
41008
41009 wxPyEndAllowThreads(__tstate);
41010 if (PyErr_Occurred()) SWIG_fail;
41011 }
41012 Py_INCREF(Py_None); resultobj = Py_None;
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj;
41021 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41022 int arg2 ;
41023 PyObject * obj0 = 0 ;
41024 PyObject * obj1 = 0 ;
41025 char *kwnames[] = {
41026 (char *) "self",(char *) "gap", NULL
41027 };
41028
41029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41031 if (SWIG_arg_fail(1)) SWIG_fail;
41032 {
41033 arg2 = (int)(SWIG_As_int(obj1));
41034 if (SWIG_arg_fail(2)) SWIG_fail;
41035 }
41036 {
41037 PyThreadState* __tstate = wxPyBeginAllowThreads();
41038 (arg1)->SetHGap(arg2);
41039
41040 wxPyEndAllowThreads(__tstate);
41041 if (PyErr_Occurred()) SWIG_fail;
41042 }
41043 Py_INCREF(Py_None); resultobj = Py_None;
41044 return resultobj;
41045 fail:
41046 return NULL;
41047 }
41048
41049
41050 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41051 PyObject *resultobj;
41052 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41053 int result;
41054 PyObject * obj0 = 0 ;
41055 char *kwnames[] = {
41056 (char *) "self", NULL
41057 };
41058
41059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41061 if (SWIG_arg_fail(1)) SWIG_fail;
41062 {
41063 PyThreadState* __tstate = wxPyBeginAllowThreads();
41064 result = (int)(arg1)->GetCols();
41065
41066 wxPyEndAllowThreads(__tstate);
41067 if (PyErr_Occurred()) SWIG_fail;
41068 }
41069 {
41070 resultobj = SWIG_From_int((int)(result));
41071 }
41072 return resultobj;
41073 fail:
41074 return NULL;
41075 }
41076
41077
41078 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41079 PyObject *resultobj;
41080 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41081 int result;
41082 PyObject * obj0 = 0 ;
41083 char *kwnames[] = {
41084 (char *) "self", NULL
41085 };
41086
41087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41089 if (SWIG_arg_fail(1)) SWIG_fail;
41090 {
41091 PyThreadState* __tstate = wxPyBeginAllowThreads();
41092 result = (int)(arg1)->GetRows();
41093
41094 wxPyEndAllowThreads(__tstate);
41095 if (PyErr_Occurred()) SWIG_fail;
41096 }
41097 {
41098 resultobj = SWIG_From_int((int)(result));
41099 }
41100 return resultobj;
41101 fail:
41102 return NULL;
41103 }
41104
41105
41106 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41107 PyObject *resultobj;
41108 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41109 int result;
41110 PyObject * obj0 = 0 ;
41111 char *kwnames[] = {
41112 (char *) "self", NULL
41113 };
41114
41115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41117 if (SWIG_arg_fail(1)) SWIG_fail;
41118 {
41119 PyThreadState* __tstate = wxPyBeginAllowThreads();
41120 result = (int)(arg1)->GetVGap();
41121
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 {
41126 resultobj = SWIG_From_int((int)(result));
41127 }
41128 return resultobj;
41129 fail:
41130 return NULL;
41131 }
41132
41133
41134 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41135 PyObject *resultobj;
41136 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41137 int result;
41138 PyObject * obj0 = 0 ;
41139 char *kwnames[] = {
41140 (char *) "self", NULL
41141 };
41142
41143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41145 if (SWIG_arg_fail(1)) SWIG_fail;
41146 {
41147 PyThreadState* __tstate = wxPyBeginAllowThreads();
41148 result = (int)(arg1)->GetHGap();
41149
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 {
41154 resultobj = SWIG_From_int((int)(result));
41155 }
41156 return resultobj;
41157 fail:
41158 return NULL;
41159 }
41160
41161
41162 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41163 PyObject *obj;
41164 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41165 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41166 Py_INCREF(obj);
41167 return Py_BuildValue((char *)"");
41168 }
41169 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41170 PyObject *resultobj;
41171 int arg1 = (int) 1 ;
41172 int arg2 = (int) 0 ;
41173 int arg3 = (int) 0 ;
41174 int arg4 = (int) 0 ;
41175 wxFlexGridSizer *result;
41176 PyObject * obj0 = 0 ;
41177 PyObject * obj1 = 0 ;
41178 PyObject * obj2 = 0 ;
41179 PyObject * obj3 = 0 ;
41180 char *kwnames[] = {
41181 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41182 };
41183
41184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41185 if (obj0) {
41186 {
41187 arg1 = (int)(SWIG_As_int(obj0));
41188 if (SWIG_arg_fail(1)) SWIG_fail;
41189 }
41190 }
41191 if (obj1) {
41192 {
41193 arg2 = (int)(SWIG_As_int(obj1));
41194 if (SWIG_arg_fail(2)) SWIG_fail;
41195 }
41196 }
41197 if (obj2) {
41198 {
41199 arg3 = (int)(SWIG_As_int(obj2));
41200 if (SWIG_arg_fail(3)) SWIG_fail;
41201 }
41202 }
41203 if (obj3) {
41204 {
41205 arg4 = (int)(SWIG_As_int(obj3));
41206 if (SWIG_arg_fail(4)) SWIG_fail;
41207 }
41208 }
41209 {
41210 PyThreadState* __tstate = wxPyBeginAllowThreads();
41211 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41212
41213 wxPyEndAllowThreads(__tstate);
41214 if (PyErr_Occurred()) SWIG_fail;
41215 }
41216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41217 return resultobj;
41218 fail:
41219 return NULL;
41220 }
41221
41222
41223 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41224 PyObject *resultobj;
41225 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41226 size_t arg2 ;
41227 int arg3 = (int) 0 ;
41228 PyObject * obj0 = 0 ;
41229 PyObject * obj1 = 0 ;
41230 PyObject * obj2 = 0 ;
41231 char *kwnames[] = {
41232 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41233 };
41234
41235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41237 if (SWIG_arg_fail(1)) SWIG_fail;
41238 {
41239 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41240 if (SWIG_arg_fail(2)) SWIG_fail;
41241 }
41242 if (obj2) {
41243 {
41244 arg3 = (int)(SWIG_As_int(obj2));
41245 if (SWIG_arg_fail(3)) SWIG_fail;
41246 }
41247 }
41248 {
41249 PyThreadState* __tstate = wxPyBeginAllowThreads();
41250 (arg1)->AddGrowableRow(arg2,arg3);
41251
41252 wxPyEndAllowThreads(__tstate);
41253 if (PyErr_Occurred()) SWIG_fail;
41254 }
41255 Py_INCREF(Py_None); resultobj = Py_None;
41256 return resultobj;
41257 fail:
41258 return NULL;
41259 }
41260
41261
41262 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41263 PyObject *resultobj;
41264 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41265 size_t arg2 ;
41266 PyObject * obj0 = 0 ;
41267 PyObject * obj1 = 0 ;
41268 char *kwnames[] = {
41269 (char *) "self",(char *) "idx", NULL
41270 };
41271
41272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41274 if (SWIG_arg_fail(1)) SWIG_fail;
41275 {
41276 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41277 if (SWIG_arg_fail(2)) SWIG_fail;
41278 }
41279 {
41280 PyThreadState* __tstate = wxPyBeginAllowThreads();
41281 (arg1)->RemoveGrowableRow(arg2);
41282
41283 wxPyEndAllowThreads(__tstate);
41284 if (PyErr_Occurred()) SWIG_fail;
41285 }
41286 Py_INCREF(Py_None); resultobj = Py_None;
41287 return resultobj;
41288 fail:
41289 return NULL;
41290 }
41291
41292
41293 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41294 PyObject *resultobj;
41295 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41296 size_t arg2 ;
41297 int arg3 = (int) 0 ;
41298 PyObject * obj0 = 0 ;
41299 PyObject * obj1 = 0 ;
41300 PyObject * obj2 = 0 ;
41301 char *kwnames[] = {
41302 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41303 };
41304
41305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41307 if (SWIG_arg_fail(1)) SWIG_fail;
41308 {
41309 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41310 if (SWIG_arg_fail(2)) SWIG_fail;
41311 }
41312 if (obj2) {
41313 {
41314 arg3 = (int)(SWIG_As_int(obj2));
41315 if (SWIG_arg_fail(3)) SWIG_fail;
41316 }
41317 }
41318 {
41319 PyThreadState* __tstate = wxPyBeginAllowThreads();
41320 (arg1)->AddGrowableCol(arg2,arg3);
41321
41322 wxPyEndAllowThreads(__tstate);
41323 if (PyErr_Occurred()) SWIG_fail;
41324 }
41325 Py_INCREF(Py_None); resultobj = Py_None;
41326 return resultobj;
41327 fail:
41328 return NULL;
41329 }
41330
41331
41332 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41333 PyObject *resultobj;
41334 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41335 size_t arg2 ;
41336 PyObject * obj0 = 0 ;
41337 PyObject * obj1 = 0 ;
41338 char *kwnames[] = {
41339 (char *) "self",(char *) "idx", NULL
41340 };
41341
41342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41344 if (SWIG_arg_fail(1)) SWIG_fail;
41345 {
41346 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41347 if (SWIG_arg_fail(2)) SWIG_fail;
41348 }
41349 {
41350 PyThreadState* __tstate = wxPyBeginAllowThreads();
41351 (arg1)->RemoveGrowableCol(arg2);
41352
41353 wxPyEndAllowThreads(__tstate);
41354 if (PyErr_Occurred()) SWIG_fail;
41355 }
41356 Py_INCREF(Py_None); resultobj = Py_None;
41357 return resultobj;
41358 fail:
41359 return NULL;
41360 }
41361
41362
41363 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41364 PyObject *resultobj;
41365 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41366 int arg2 ;
41367 PyObject * obj0 = 0 ;
41368 PyObject * obj1 = 0 ;
41369 char *kwnames[] = {
41370 (char *) "self",(char *) "direction", NULL
41371 };
41372
41373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41375 if (SWIG_arg_fail(1)) SWIG_fail;
41376 {
41377 arg2 = (int)(SWIG_As_int(obj1));
41378 if (SWIG_arg_fail(2)) SWIG_fail;
41379 }
41380 {
41381 PyThreadState* __tstate = wxPyBeginAllowThreads();
41382 (arg1)->SetFlexibleDirection(arg2);
41383
41384 wxPyEndAllowThreads(__tstate);
41385 if (PyErr_Occurred()) SWIG_fail;
41386 }
41387 Py_INCREF(Py_None); resultobj = Py_None;
41388 return resultobj;
41389 fail:
41390 return NULL;
41391 }
41392
41393
41394 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41395 PyObject *resultobj;
41396 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41397 int result;
41398 PyObject * obj0 = 0 ;
41399 char *kwnames[] = {
41400 (char *) "self", NULL
41401 };
41402
41403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41405 if (SWIG_arg_fail(1)) SWIG_fail;
41406 {
41407 PyThreadState* __tstate = wxPyBeginAllowThreads();
41408 result = (int)(arg1)->GetFlexibleDirection();
41409
41410 wxPyEndAllowThreads(__tstate);
41411 if (PyErr_Occurred()) SWIG_fail;
41412 }
41413 {
41414 resultobj = SWIG_From_int((int)(result));
41415 }
41416 return resultobj;
41417 fail:
41418 return NULL;
41419 }
41420
41421
41422 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41423 PyObject *resultobj;
41424 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41425 wxFlexSizerGrowMode arg2 ;
41426 PyObject * obj0 = 0 ;
41427 PyObject * obj1 = 0 ;
41428 char *kwnames[] = {
41429 (char *) "self",(char *) "mode", NULL
41430 };
41431
41432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41434 if (SWIG_arg_fail(1)) SWIG_fail;
41435 {
41436 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41437 if (SWIG_arg_fail(2)) SWIG_fail;
41438 }
41439 {
41440 PyThreadState* __tstate = wxPyBeginAllowThreads();
41441 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41442
41443 wxPyEndAllowThreads(__tstate);
41444 if (PyErr_Occurred()) SWIG_fail;
41445 }
41446 Py_INCREF(Py_None); resultobj = Py_None;
41447 return resultobj;
41448 fail:
41449 return NULL;
41450 }
41451
41452
41453 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41454 PyObject *resultobj;
41455 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41456 wxFlexSizerGrowMode result;
41457 PyObject * obj0 = 0 ;
41458 char *kwnames[] = {
41459 (char *) "self", NULL
41460 };
41461
41462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41464 if (SWIG_arg_fail(1)) SWIG_fail;
41465 {
41466 PyThreadState* __tstate = wxPyBeginAllowThreads();
41467 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41468
41469 wxPyEndAllowThreads(__tstate);
41470 if (PyErr_Occurred()) SWIG_fail;
41471 }
41472 resultobj = SWIG_From_int((result));
41473 return resultobj;
41474 fail:
41475 return NULL;
41476 }
41477
41478
41479 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41480 PyObject *resultobj;
41481 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41482 wxArrayInt *result;
41483 PyObject * obj0 = 0 ;
41484 char *kwnames[] = {
41485 (char *) "self", NULL
41486 };
41487
41488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41490 if (SWIG_arg_fail(1)) SWIG_fail;
41491 {
41492 PyThreadState* __tstate = wxPyBeginAllowThreads();
41493 {
41494 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41495 result = (wxArrayInt *) &_result_ref;
41496 }
41497
41498 wxPyEndAllowThreads(__tstate);
41499 if (PyErr_Occurred()) SWIG_fail;
41500 }
41501 {
41502 resultobj = PyList_New(0);
41503 size_t idx;
41504 for (idx = 0; idx < result->GetCount(); idx += 1) {
41505 PyObject* val = PyInt_FromLong( result->Item(idx) );
41506 PyList_Append(resultobj, val);
41507 Py_DECREF(val);
41508 }
41509 }
41510 return resultobj;
41511 fail:
41512 return NULL;
41513 }
41514
41515
41516 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41517 PyObject *resultobj;
41518 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41519 wxArrayInt *result;
41520 PyObject * obj0 = 0 ;
41521 char *kwnames[] = {
41522 (char *) "self", NULL
41523 };
41524
41525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41527 if (SWIG_arg_fail(1)) SWIG_fail;
41528 {
41529 PyThreadState* __tstate = wxPyBeginAllowThreads();
41530 {
41531 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41532 result = (wxArrayInt *) &_result_ref;
41533 }
41534
41535 wxPyEndAllowThreads(__tstate);
41536 if (PyErr_Occurred()) SWIG_fail;
41537 }
41538 {
41539 resultobj = PyList_New(0);
41540 size_t idx;
41541 for (idx = 0; idx < result->GetCount(); idx += 1) {
41542 PyObject* val = PyInt_FromLong( result->Item(idx) );
41543 PyList_Append(resultobj, val);
41544 Py_DECREF(val);
41545 }
41546 }
41547 return resultobj;
41548 fail:
41549 return NULL;
41550 }
41551
41552
41553 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41554 PyObject *obj;
41555 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41556 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41557 Py_INCREF(obj);
41558 return Py_BuildValue((char *)"");
41559 }
41560 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41561 PyObject *resultobj;
41562 wxStdDialogButtonSizer *result;
41563 char *kwnames[] = {
41564 NULL
41565 };
41566
41567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41568 {
41569 PyThreadState* __tstate = wxPyBeginAllowThreads();
41570 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41571
41572 wxPyEndAllowThreads(__tstate);
41573 if (PyErr_Occurred()) SWIG_fail;
41574 }
41575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41576 return resultobj;
41577 fail:
41578 return NULL;
41579 }
41580
41581
41582 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41583 PyObject *resultobj;
41584 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41585 wxButton *arg2 = (wxButton *) 0 ;
41586 PyObject * obj0 = 0 ;
41587 PyObject * obj1 = 0 ;
41588 char *kwnames[] = {
41589 (char *) "self",(char *) "button", NULL
41590 };
41591
41592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41594 if (SWIG_arg_fail(1)) SWIG_fail;
41595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41596 if (SWIG_arg_fail(2)) SWIG_fail;
41597 {
41598 PyThreadState* __tstate = wxPyBeginAllowThreads();
41599 (arg1)->AddButton(arg2);
41600
41601 wxPyEndAllowThreads(__tstate);
41602 if (PyErr_Occurred()) SWIG_fail;
41603 }
41604 Py_INCREF(Py_None); resultobj = Py_None;
41605 return resultobj;
41606 fail:
41607 return NULL;
41608 }
41609
41610
41611 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41612 PyObject *resultobj;
41613 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41614 PyObject * obj0 = 0 ;
41615 char *kwnames[] = {
41616 (char *) "self", NULL
41617 };
41618
41619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41621 if (SWIG_arg_fail(1)) SWIG_fail;
41622 {
41623 PyThreadState* __tstate = wxPyBeginAllowThreads();
41624 (arg1)->Realize();
41625
41626 wxPyEndAllowThreads(__tstate);
41627 if (PyErr_Occurred()) SWIG_fail;
41628 }
41629 Py_INCREF(Py_None); resultobj = Py_None;
41630 return resultobj;
41631 fail:
41632 return NULL;
41633 }
41634
41635
41636 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41637 PyObject *resultobj;
41638 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41639 wxButton *arg2 = (wxButton *) 0 ;
41640 PyObject * obj0 = 0 ;
41641 PyObject * obj1 = 0 ;
41642 char *kwnames[] = {
41643 (char *) "self",(char *) "button", NULL
41644 };
41645
41646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41648 if (SWIG_arg_fail(1)) SWIG_fail;
41649 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41650 if (SWIG_arg_fail(2)) SWIG_fail;
41651 {
41652 PyThreadState* __tstate = wxPyBeginAllowThreads();
41653 (arg1)->SetAffirmativeButton(arg2);
41654
41655 wxPyEndAllowThreads(__tstate);
41656 if (PyErr_Occurred()) SWIG_fail;
41657 }
41658 Py_INCREF(Py_None); resultobj = Py_None;
41659 return resultobj;
41660 fail:
41661 return NULL;
41662 }
41663
41664
41665 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41666 PyObject *resultobj;
41667 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41668 wxButton *arg2 = (wxButton *) 0 ;
41669 PyObject * obj0 = 0 ;
41670 PyObject * obj1 = 0 ;
41671 char *kwnames[] = {
41672 (char *) "self",(char *) "button", NULL
41673 };
41674
41675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41677 if (SWIG_arg_fail(1)) SWIG_fail;
41678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41679 if (SWIG_arg_fail(2)) SWIG_fail;
41680 {
41681 PyThreadState* __tstate = wxPyBeginAllowThreads();
41682 (arg1)->SetNegativeButton(arg2);
41683
41684 wxPyEndAllowThreads(__tstate);
41685 if (PyErr_Occurred()) SWIG_fail;
41686 }
41687 Py_INCREF(Py_None); resultobj = Py_None;
41688 return resultobj;
41689 fail:
41690 return NULL;
41691 }
41692
41693
41694 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41695 PyObject *resultobj;
41696 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41697 wxButton *arg2 = (wxButton *) 0 ;
41698 PyObject * obj0 = 0 ;
41699 PyObject * obj1 = 0 ;
41700 char *kwnames[] = {
41701 (char *) "self",(char *) "button", NULL
41702 };
41703
41704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41706 if (SWIG_arg_fail(1)) SWIG_fail;
41707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41708 if (SWIG_arg_fail(2)) SWIG_fail;
41709 {
41710 PyThreadState* __tstate = wxPyBeginAllowThreads();
41711 (arg1)->SetCancelButton(arg2);
41712
41713 wxPyEndAllowThreads(__tstate);
41714 if (PyErr_Occurred()) SWIG_fail;
41715 }
41716 Py_INCREF(Py_None); resultobj = Py_None;
41717 return resultobj;
41718 fail:
41719 return NULL;
41720 }
41721
41722
41723 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41724 PyObject *resultobj;
41725 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41726 wxButton *result;
41727 PyObject * obj0 = 0 ;
41728 char *kwnames[] = {
41729 (char *) "self", NULL
41730 };
41731
41732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41734 if (SWIG_arg_fail(1)) SWIG_fail;
41735 {
41736 PyThreadState* __tstate = wxPyBeginAllowThreads();
41737 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41738
41739 wxPyEndAllowThreads(__tstate);
41740 if (PyErr_Occurred()) SWIG_fail;
41741 }
41742 {
41743 resultobj = wxPyMake_wxObject(result, 0);
41744 }
41745 return resultobj;
41746 fail:
41747 return NULL;
41748 }
41749
41750
41751 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41752 PyObject *resultobj;
41753 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41754 wxButton *result;
41755 PyObject * obj0 = 0 ;
41756 char *kwnames[] = {
41757 (char *) "self", NULL
41758 };
41759
41760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41762 if (SWIG_arg_fail(1)) SWIG_fail;
41763 {
41764 PyThreadState* __tstate = wxPyBeginAllowThreads();
41765 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41766
41767 wxPyEndAllowThreads(__tstate);
41768 if (PyErr_Occurred()) SWIG_fail;
41769 }
41770 {
41771 resultobj = wxPyMake_wxObject(result, 0);
41772 }
41773 return resultobj;
41774 fail:
41775 return NULL;
41776 }
41777
41778
41779 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41780 PyObject *resultobj;
41781 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41782 wxButton *result;
41783 PyObject * obj0 = 0 ;
41784 char *kwnames[] = {
41785 (char *) "self", NULL
41786 };
41787
41788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41790 if (SWIG_arg_fail(1)) SWIG_fail;
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41794
41795 wxPyEndAllowThreads(__tstate);
41796 if (PyErr_Occurred()) SWIG_fail;
41797 }
41798 {
41799 resultobj = wxPyMake_wxObject(result, 0);
41800 }
41801 return resultobj;
41802 fail:
41803 return NULL;
41804 }
41805
41806
41807 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41808 PyObject *resultobj;
41809 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41810 wxButton *result;
41811 PyObject * obj0 = 0 ;
41812 char *kwnames[] = {
41813 (char *) "self", NULL
41814 };
41815
41816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41818 if (SWIG_arg_fail(1)) SWIG_fail;
41819 {
41820 PyThreadState* __tstate = wxPyBeginAllowThreads();
41821 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41822
41823 wxPyEndAllowThreads(__tstate);
41824 if (PyErr_Occurred()) SWIG_fail;
41825 }
41826 {
41827 resultobj = wxPyMake_wxObject(result, 0);
41828 }
41829 return resultobj;
41830 fail:
41831 return NULL;
41832 }
41833
41834
41835 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41836 PyObject *resultobj;
41837 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41838 wxButton *result;
41839 PyObject * obj0 = 0 ;
41840 char *kwnames[] = {
41841 (char *) "self", NULL
41842 };
41843
41844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41846 if (SWIG_arg_fail(1)) SWIG_fail;
41847 {
41848 PyThreadState* __tstate = wxPyBeginAllowThreads();
41849 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41850
41851 wxPyEndAllowThreads(__tstate);
41852 if (PyErr_Occurred()) SWIG_fail;
41853 }
41854 {
41855 resultobj = wxPyMake_wxObject(result, 0);
41856 }
41857 return resultobj;
41858 fail:
41859 return NULL;
41860 }
41861
41862
41863 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41864 PyObject *obj;
41865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41866 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41867 Py_INCREF(obj);
41868 return Py_BuildValue((char *)"");
41869 }
41870 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41871 PyObject *resultobj;
41872 int arg1 = (int) 0 ;
41873 int arg2 = (int) 0 ;
41874 wxGBPosition *result;
41875 PyObject * obj0 = 0 ;
41876 PyObject * obj1 = 0 ;
41877 char *kwnames[] = {
41878 (char *) "row",(char *) "col", NULL
41879 };
41880
41881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41882 if (obj0) {
41883 {
41884 arg1 = (int)(SWIG_As_int(obj0));
41885 if (SWIG_arg_fail(1)) SWIG_fail;
41886 }
41887 }
41888 if (obj1) {
41889 {
41890 arg2 = (int)(SWIG_As_int(obj1));
41891 if (SWIG_arg_fail(2)) SWIG_fail;
41892 }
41893 }
41894 {
41895 PyThreadState* __tstate = wxPyBeginAllowThreads();
41896 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41897
41898 wxPyEndAllowThreads(__tstate);
41899 if (PyErr_Occurred()) SWIG_fail;
41900 }
41901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41902 return resultobj;
41903 fail:
41904 return NULL;
41905 }
41906
41907
41908 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41909 PyObject *resultobj;
41910 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41911 int result;
41912 PyObject * obj0 = 0 ;
41913 char *kwnames[] = {
41914 (char *) "self", NULL
41915 };
41916
41917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41919 if (SWIG_arg_fail(1)) SWIG_fail;
41920 {
41921 PyThreadState* __tstate = wxPyBeginAllowThreads();
41922 result = (int)((wxGBPosition const *)arg1)->GetRow();
41923
41924 wxPyEndAllowThreads(__tstate);
41925 if (PyErr_Occurred()) SWIG_fail;
41926 }
41927 {
41928 resultobj = SWIG_From_int((int)(result));
41929 }
41930 return resultobj;
41931 fail:
41932 return NULL;
41933 }
41934
41935
41936 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41937 PyObject *resultobj;
41938 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41939 int result;
41940 PyObject * obj0 = 0 ;
41941 char *kwnames[] = {
41942 (char *) "self", NULL
41943 };
41944
41945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41947 if (SWIG_arg_fail(1)) SWIG_fail;
41948 {
41949 PyThreadState* __tstate = wxPyBeginAllowThreads();
41950 result = (int)((wxGBPosition const *)arg1)->GetCol();
41951
41952 wxPyEndAllowThreads(__tstate);
41953 if (PyErr_Occurred()) SWIG_fail;
41954 }
41955 {
41956 resultobj = SWIG_From_int((int)(result));
41957 }
41958 return resultobj;
41959 fail:
41960 return NULL;
41961 }
41962
41963
41964 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41965 PyObject *resultobj;
41966 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41967 int arg2 ;
41968 PyObject * obj0 = 0 ;
41969 PyObject * obj1 = 0 ;
41970 char *kwnames[] = {
41971 (char *) "self",(char *) "row", NULL
41972 };
41973
41974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41976 if (SWIG_arg_fail(1)) SWIG_fail;
41977 {
41978 arg2 = (int)(SWIG_As_int(obj1));
41979 if (SWIG_arg_fail(2)) SWIG_fail;
41980 }
41981 {
41982 PyThreadState* __tstate = wxPyBeginAllowThreads();
41983 (arg1)->SetRow(arg2);
41984
41985 wxPyEndAllowThreads(__tstate);
41986 if (PyErr_Occurred()) SWIG_fail;
41987 }
41988 Py_INCREF(Py_None); resultobj = Py_None;
41989 return resultobj;
41990 fail:
41991 return NULL;
41992 }
41993
41994
41995 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41996 PyObject *resultobj;
41997 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41998 int arg2 ;
41999 PyObject * obj0 = 0 ;
42000 PyObject * obj1 = 0 ;
42001 char *kwnames[] = {
42002 (char *) "self",(char *) "col", NULL
42003 };
42004
42005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42007 if (SWIG_arg_fail(1)) SWIG_fail;
42008 {
42009 arg2 = (int)(SWIG_As_int(obj1));
42010 if (SWIG_arg_fail(2)) SWIG_fail;
42011 }
42012 {
42013 PyThreadState* __tstate = wxPyBeginAllowThreads();
42014 (arg1)->SetCol(arg2);
42015
42016 wxPyEndAllowThreads(__tstate);
42017 if (PyErr_Occurred()) SWIG_fail;
42018 }
42019 Py_INCREF(Py_None); resultobj = Py_None;
42020 return resultobj;
42021 fail:
42022 return NULL;
42023 }
42024
42025
42026 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42027 PyObject *resultobj;
42028 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42029 wxGBPosition *arg2 = 0 ;
42030 bool result;
42031 wxGBPosition temp2 ;
42032 PyObject * obj0 = 0 ;
42033 PyObject * obj1 = 0 ;
42034 char *kwnames[] = {
42035 (char *) "self",(char *) "other", NULL
42036 };
42037
42038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42040 if (SWIG_arg_fail(1)) SWIG_fail;
42041 {
42042 arg2 = &temp2;
42043 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42044 }
42045 {
42046 PyThreadState* __tstate = wxPyBeginAllowThreads();
42047 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42048
42049 wxPyEndAllowThreads(__tstate);
42050 if (PyErr_Occurred()) SWIG_fail;
42051 }
42052 {
42053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42054 }
42055 return resultobj;
42056 fail:
42057 return NULL;
42058 }
42059
42060
42061 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42062 PyObject *resultobj;
42063 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42064 wxGBPosition *arg2 = 0 ;
42065 bool result;
42066 wxGBPosition temp2 ;
42067 PyObject * obj0 = 0 ;
42068 PyObject * obj1 = 0 ;
42069 char *kwnames[] = {
42070 (char *) "self",(char *) "other", NULL
42071 };
42072
42073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42075 if (SWIG_arg_fail(1)) SWIG_fail;
42076 {
42077 arg2 = &temp2;
42078 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42079 }
42080 {
42081 PyThreadState* __tstate = wxPyBeginAllowThreads();
42082 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42083
42084 wxPyEndAllowThreads(__tstate);
42085 if (PyErr_Occurred()) SWIG_fail;
42086 }
42087 {
42088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42089 }
42090 return resultobj;
42091 fail:
42092 return NULL;
42093 }
42094
42095
42096 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42097 PyObject *resultobj;
42098 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42099 int arg2 = (int) 0 ;
42100 int arg3 = (int) 0 ;
42101 PyObject * obj0 = 0 ;
42102 PyObject * obj1 = 0 ;
42103 PyObject * obj2 = 0 ;
42104 char *kwnames[] = {
42105 (char *) "self",(char *) "row",(char *) "col", NULL
42106 };
42107
42108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42110 if (SWIG_arg_fail(1)) SWIG_fail;
42111 if (obj1) {
42112 {
42113 arg2 = (int)(SWIG_As_int(obj1));
42114 if (SWIG_arg_fail(2)) SWIG_fail;
42115 }
42116 }
42117 if (obj2) {
42118 {
42119 arg3 = (int)(SWIG_As_int(obj2));
42120 if (SWIG_arg_fail(3)) SWIG_fail;
42121 }
42122 }
42123 {
42124 PyThreadState* __tstate = wxPyBeginAllowThreads();
42125 wxGBPosition_Set(arg1,arg2,arg3);
42126
42127 wxPyEndAllowThreads(__tstate);
42128 if (PyErr_Occurred()) SWIG_fail;
42129 }
42130 Py_INCREF(Py_None); resultobj = Py_None;
42131 return resultobj;
42132 fail:
42133 return NULL;
42134 }
42135
42136
42137 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42138 PyObject *resultobj;
42139 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42140 PyObject *result;
42141 PyObject * obj0 = 0 ;
42142 char *kwnames[] = {
42143 (char *) "self", NULL
42144 };
42145
42146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42148 if (SWIG_arg_fail(1)) SWIG_fail;
42149 {
42150 PyThreadState* __tstate = wxPyBeginAllowThreads();
42151 result = (PyObject *)wxGBPosition_Get(arg1);
42152
42153 wxPyEndAllowThreads(__tstate);
42154 if (PyErr_Occurred()) SWIG_fail;
42155 }
42156 resultobj = result;
42157 return resultobj;
42158 fail:
42159 return NULL;
42160 }
42161
42162
42163 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42164 PyObject *obj;
42165 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42166 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42167 Py_INCREF(obj);
42168 return Py_BuildValue((char *)"");
42169 }
42170 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42171 PyObject *resultobj;
42172 int arg1 = (int) 1 ;
42173 int arg2 = (int) 1 ;
42174 wxGBSpan *result;
42175 PyObject * obj0 = 0 ;
42176 PyObject * obj1 = 0 ;
42177 char *kwnames[] = {
42178 (char *) "rowspan",(char *) "colspan", NULL
42179 };
42180
42181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42182 if (obj0) {
42183 {
42184 arg1 = (int)(SWIG_As_int(obj0));
42185 if (SWIG_arg_fail(1)) SWIG_fail;
42186 }
42187 }
42188 if (obj1) {
42189 {
42190 arg2 = (int)(SWIG_As_int(obj1));
42191 if (SWIG_arg_fail(2)) SWIG_fail;
42192 }
42193 }
42194 {
42195 PyThreadState* __tstate = wxPyBeginAllowThreads();
42196 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42197
42198 wxPyEndAllowThreads(__tstate);
42199 if (PyErr_Occurred()) SWIG_fail;
42200 }
42201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42202 return resultobj;
42203 fail:
42204 return NULL;
42205 }
42206
42207
42208 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42209 PyObject *resultobj;
42210 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42211 int result;
42212 PyObject * obj0 = 0 ;
42213 char *kwnames[] = {
42214 (char *) "self", NULL
42215 };
42216
42217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42219 if (SWIG_arg_fail(1)) SWIG_fail;
42220 {
42221 PyThreadState* __tstate = wxPyBeginAllowThreads();
42222 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42223
42224 wxPyEndAllowThreads(__tstate);
42225 if (PyErr_Occurred()) SWIG_fail;
42226 }
42227 {
42228 resultobj = SWIG_From_int((int)(result));
42229 }
42230 return resultobj;
42231 fail:
42232 return NULL;
42233 }
42234
42235
42236 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42237 PyObject *resultobj;
42238 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42239 int result;
42240 PyObject * obj0 = 0 ;
42241 char *kwnames[] = {
42242 (char *) "self", NULL
42243 };
42244
42245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42247 if (SWIG_arg_fail(1)) SWIG_fail;
42248 {
42249 PyThreadState* __tstate = wxPyBeginAllowThreads();
42250 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42251
42252 wxPyEndAllowThreads(__tstate);
42253 if (PyErr_Occurred()) SWIG_fail;
42254 }
42255 {
42256 resultobj = SWIG_From_int((int)(result));
42257 }
42258 return resultobj;
42259 fail:
42260 return NULL;
42261 }
42262
42263
42264 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42265 PyObject *resultobj;
42266 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42267 int arg2 ;
42268 PyObject * obj0 = 0 ;
42269 PyObject * obj1 = 0 ;
42270 char *kwnames[] = {
42271 (char *) "self",(char *) "rowspan", NULL
42272 };
42273
42274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42276 if (SWIG_arg_fail(1)) SWIG_fail;
42277 {
42278 arg2 = (int)(SWIG_As_int(obj1));
42279 if (SWIG_arg_fail(2)) SWIG_fail;
42280 }
42281 {
42282 PyThreadState* __tstate = wxPyBeginAllowThreads();
42283 (arg1)->SetRowspan(arg2);
42284
42285 wxPyEndAllowThreads(__tstate);
42286 if (PyErr_Occurred()) SWIG_fail;
42287 }
42288 Py_INCREF(Py_None); resultobj = Py_None;
42289 return resultobj;
42290 fail:
42291 return NULL;
42292 }
42293
42294
42295 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42296 PyObject *resultobj;
42297 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42298 int arg2 ;
42299 PyObject * obj0 = 0 ;
42300 PyObject * obj1 = 0 ;
42301 char *kwnames[] = {
42302 (char *) "self",(char *) "colspan", NULL
42303 };
42304
42305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42307 if (SWIG_arg_fail(1)) SWIG_fail;
42308 {
42309 arg2 = (int)(SWIG_As_int(obj1));
42310 if (SWIG_arg_fail(2)) SWIG_fail;
42311 }
42312 {
42313 PyThreadState* __tstate = wxPyBeginAllowThreads();
42314 (arg1)->SetColspan(arg2);
42315
42316 wxPyEndAllowThreads(__tstate);
42317 if (PyErr_Occurred()) SWIG_fail;
42318 }
42319 Py_INCREF(Py_None); resultobj = Py_None;
42320 return resultobj;
42321 fail:
42322 return NULL;
42323 }
42324
42325
42326 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42327 PyObject *resultobj;
42328 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42329 wxGBSpan *arg2 = 0 ;
42330 bool result;
42331 wxGBSpan temp2 ;
42332 PyObject * obj0 = 0 ;
42333 PyObject * obj1 = 0 ;
42334 char *kwnames[] = {
42335 (char *) "self",(char *) "other", NULL
42336 };
42337
42338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42340 if (SWIG_arg_fail(1)) SWIG_fail;
42341 {
42342 arg2 = &temp2;
42343 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42344 }
42345 {
42346 PyThreadState* __tstate = wxPyBeginAllowThreads();
42347 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
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_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42362 PyObject *resultobj;
42363 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42364 wxGBSpan *arg2 = 0 ;
42365 bool result;
42366 wxGBSpan temp2 ;
42367 PyObject * obj0 = 0 ;
42368 PyObject * obj1 = 0 ;
42369 char *kwnames[] = {
42370 (char *) "self",(char *) "other", NULL
42371 };
42372
42373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42375 if (SWIG_arg_fail(1)) SWIG_fail;
42376 {
42377 arg2 = &temp2;
42378 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42379 }
42380 {
42381 PyThreadState* __tstate = wxPyBeginAllowThreads();
42382 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42383
42384 wxPyEndAllowThreads(__tstate);
42385 if (PyErr_Occurred()) SWIG_fail;
42386 }
42387 {
42388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42389 }
42390 return resultobj;
42391 fail:
42392 return NULL;
42393 }
42394
42395
42396 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42397 PyObject *resultobj;
42398 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42399 int arg2 = (int) 1 ;
42400 int arg3 = (int) 1 ;
42401 PyObject * obj0 = 0 ;
42402 PyObject * obj1 = 0 ;
42403 PyObject * obj2 = 0 ;
42404 char *kwnames[] = {
42405 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42406 };
42407
42408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42410 if (SWIG_arg_fail(1)) SWIG_fail;
42411 if (obj1) {
42412 {
42413 arg2 = (int)(SWIG_As_int(obj1));
42414 if (SWIG_arg_fail(2)) SWIG_fail;
42415 }
42416 }
42417 if (obj2) {
42418 {
42419 arg3 = (int)(SWIG_As_int(obj2));
42420 if (SWIG_arg_fail(3)) SWIG_fail;
42421 }
42422 }
42423 {
42424 PyThreadState* __tstate = wxPyBeginAllowThreads();
42425 wxGBSpan_Set(arg1,arg2,arg3);
42426
42427 wxPyEndAllowThreads(__tstate);
42428 if (PyErr_Occurred()) SWIG_fail;
42429 }
42430 Py_INCREF(Py_None); resultobj = Py_None;
42431 return resultobj;
42432 fail:
42433 return NULL;
42434 }
42435
42436
42437 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42438 PyObject *resultobj;
42439 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42440 PyObject *result;
42441 PyObject * obj0 = 0 ;
42442 char *kwnames[] = {
42443 (char *) "self", NULL
42444 };
42445
42446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42448 if (SWIG_arg_fail(1)) SWIG_fail;
42449 {
42450 PyThreadState* __tstate = wxPyBeginAllowThreads();
42451 result = (PyObject *)wxGBSpan_Get(arg1);
42452
42453 wxPyEndAllowThreads(__tstate);
42454 if (PyErr_Occurred()) SWIG_fail;
42455 }
42456 resultobj = result;
42457 return resultobj;
42458 fail:
42459 return NULL;
42460 }
42461
42462
42463 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42464 PyObject *obj;
42465 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42466 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42467 Py_INCREF(obj);
42468 return Py_BuildValue((char *)"");
42469 }
42470 static int _wrap_DefaultSpan_set(PyObject *) {
42471 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42472 return 1;
42473 }
42474
42475
42476 static PyObject *_wrap_DefaultSpan_get(void) {
42477 PyObject *pyobj;
42478
42479 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42480 return pyobj;
42481 }
42482
42483
42484 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42485 PyObject *resultobj;
42486 wxGBSizerItem *result;
42487 char *kwnames[] = {
42488 NULL
42489 };
42490
42491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42492 {
42493 PyThreadState* __tstate = wxPyBeginAllowThreads();
42494 result = (wxGBSizerItem *)new wxGBSizerItem();
42495
42496 wxPyEndAllowThreads(__tstate);
42497 if (PyErr_Occurred()) SWIG_fail;
42498 }
42499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42500 return resultobj;
42501 fail:
42502 return NULL;
42503 }
42504
42505
42506 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42507 PyObject *resultobj;
42508 wxWindow *arg1 = (wxWindow *) 0 ;
42509 wxGBPosition *arg2 = 0 ;
42510 wxGBSpan *arg3 = 0 ;
42511 int arg4 ;
42512 int arg5 ;
42513 PyObject *arg6 = (PyObject *) NULL ;
42514 wxGBSizerItem *result;
42515 wxGBPosition temp2 ;
42516 wxGBSpan temp3 ;
42517 PyObject * obj0 = 0 ;
42518 PyObject * obj1 = 0 ;
42519 PyObject * obj2 = 0 ;
42520 PyObject * obj3 = 0 ;
42521 PyObject * obj4 = 0 ;
42522 PyObject * obj5 = 0 ;
42523 char *kwnames[] = {
42524 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42525 };
42526
42527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42529 if (SWIG_arg_fail(1)) SWIG_fail;
42530 {
42531 arg2 = &temp2;
42532 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42533 }
42534 {
42535 arg3 = &temp3;
42536 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42537 }
42538 {
42539 arg4 = (int)(SWIG_As_int(obj3));
42540 if (SWIG_arg_fail(4)) SWIG_fail;
42541 }
42542 {
42543 arg5 = (int)(SWIG_As_int(obj4));
42544 if (SWIG_arg_fail(5)) SWIG_fail;
42545 }
42546 if (obj5) {
42547 arg6 = obj5;
42548 }
42549 {
42550 PyThreadState* __tstate = wxPyBeginAllowThreads();
42551 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42552
42553 wxPyEndAllowThreads(__tstate);
42554 if (PyErr_Occurred()) SWIG_fail;
42555 }
42556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42557 return resultobj;
42558 fail:
42559 return NULL;
42560 }
42561
42562
42563 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42564 PyObject *resultobj;
42565 wxSizer *arg1 = (wxSizer *) 0 ;
42566 wxGBPosition *arg2 = 0 ;
42567 wxGBSpan *arg3 = 0 ;
42568 int arg4 ;
42569 int arg5 ;
42570 PyObject *arg6 = (PyObject *) NULL ;
42571 wxGBSizerItem *result;
42572 wxGBPosition temp2 ;
42573 wxGBSpan temp3 ;
42574 PyObject * obj0 = 0 ;
42575 PyObject * obj1 = 0 ;
42576 PyObject * obj2 = 0 ;
42577 PyObject * obj3 = 0 ;
42578 PyObject * obj4 = 0 ;
42579 PyObject * obj5 = 0 ;
42580 char *kwnames[] = {
42581 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42582 };
42583
42584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42586 if (SWIG_arg_fail(1)) SWIG_fail;
42587 {
42588 arg2 = &temp2;
42589 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42590 }
42591 {
42592 arg3 = &temp3;
42593 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42594 }
42595 {
42596 arg4 = (int)(SWIG_As_int(obj3));
42597 if (SWIG_arg_fail(4)) SWIG_fail;
42598 }
42599 {
42600 arg5 = (int)(SWIG_As_int(obj4));
42601 if (SWIG_arg_fail(5)) SWIG_fail;
42602 }
42603 if (obj5) {
42604 arg6 = obj5;
42605 }
42606 {
42607 PyThreadState* __tstate = wxPyBeginAllowThreads();
42608 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42609
42610 wxPyEndAllowThreads(__tstate);
42611 if (PyErr_Occurred()) SWIG_fail;
42612 }
42613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42614 return resultobj;
42615 fail:
42616 return NULL;
42617 }
42618
42619
42620 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42621 PyObject *resultobj;
42622 int arg1 ;
42623 int arg2 ;
42624 wxGBPosition *arg3 = 0 ;
42625 wxGBSpan *arg4 = 0 ;
42626 int arg5 ;
42627 int arg6 ;
42628 PyObject *arg7 = (PyObject *) NULL ;
42629 wxGBSizerItem *result;
42630 wxGBPosition temp3 ;
42631 wxGBSpan temp4 ;
42632 PyObject * obj0 = 0 ;
42633 PyObject * obj1 = 0 ;
42634 PyObject * obj2 = 0 ;
42635 PyObject * obj3 = 0 ;
42636 PyObject * obj4 = 0 ;
42637 PyObject * obj5 = 0 ;
42638 PyObject * obj6 = 0 ;
42639 char *kwnames[] = {
42640 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42641 };
42642
42643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42644 {
42645 arg1 = (int)(SWIG_As_int(obj0));
42646 if (SWIG_arg_fail(1)) SWIG_fail;
42647 }
42648 {
42649 arg2 = (int)(SWIG_As_int(obj1));
42650 if (SWIG_arg_fail(2)) SWIG_fail;
42651 }
42652 {
42653 arg3 = &temp3;
42654 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42655 }
42656 {
42657 arg4 = &temp4;
42658 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42659 }
42660 {
42661 arg5 = (int)(SWIG_As_int(obj4));
42662 if (SWIG_arg_fail(5)) SWIG_fail;
42663 }
42664 {
42665 arg6 = (int)(SWIG_As_int(obj5));
42666 if (SWIG_arg_fail(6)) SWIG_fail;
42667 }
42668 if (obj6) {
42669 arg7 = obj6;
42670 }
42671 {
42672 PyThreadState* __tstate = wxPyBeginAllowThreads();
42673 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42674
42675 wxPyEndAllowThreads(__tstate);
42676 if (PyErr_Occurred()) SWIG_fail;
42677 }
42678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42679 return resultobj;
42680 fail:
42681 return NULL;
42682 }
42683
42684
42685 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42686 PyObject *resultobj;
42687 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42688 wxGBPosition result;
42689 PyObject * obj0 = 0 ;
42690 char *kwnames[] = {
42691 (char *) "self", NULL
42692 };
42693
42694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42696 if (SWIG_arg_fail(1)) SWIG_fail;
42697 {
42698 PyThreadState* __tstate = wxPyBeginAllowThreads();
42699 result = ((wxGBSizerItem const *)arg1)->GetPos();
42700
42701 wxPyEndAllowThreads(__tstate);
42702 if (PyErr_Occurred()) SWIG_fail;
42703 }
42704 {
42705 wxGBPosition * resultptr;
42706 resultptr = new wxGBPosition((wxGBPosition &)(result));
42707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42708 }
42709 return resultobj;
42710 fail:
42711 return NULL;
42712 }
42713
42714
42715 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42716 PyObject *resultobj;
42717 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42718 wxGBSpan result;
42719 PyObject * obj0 = 0 ;
42720 char *kwnames[] = {
42721 (char *) "self", NULL
42722 };
42723
42724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42726 if (SWIG_arg_fail(1)) SWIG_fail;
42727 {
42728 PyThreadState* __tstate = wxPyBeginAllowThreads();
42729 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42730
42731 wxPyEndAllowThreads(__tstate);
42732 if (PyErr_Occurred()) SWIG_fail;
42733 }
42734 {
42735 wxGBSpan * resultptr;
42736 resultptr = new wxGBSpan((wxGBSpan &)(result));
42737 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42738 }
42739 return resultobj;
42740 fail:
42741 return NULL;
42742 }
42743
42744
42745 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42746 PyObject *resultobj;
42747 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42748 wxGBPosition *arg2 = 0 ;
42749 bool result;
42750 wxGBPosition temp2 ;
42751 PyObject * obj0 = 0 ;
42752 PyObject * obj1 = 0 ;
42753 char *kwnames[] = {
42754 (char *) "self",(char *) "pos", NULL
42755 };
42756
42757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42759 if (SWIG_arg_fail(1)) SWIG_fail;
42760 {
42761 arg2 = &temp2;
42762 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42763 }
42764 {
42765 PyThreadState* __tstate = wxPyBeginAllowThreads();
42766 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42767
42768 wxPyEndAllowThreads(__tstate);
42769 if (PyErr_Occurred()) SWIG_fail;
42770 }
42771 {
42772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42773 }
42774 return resultobj;
42775 fail:
42776 return NULL;
42777 }
42778
42779
42780 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42781 PyObject *resultobj;
42782 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42783 wxGBSpan *arg2 = 0 ;
42784 bool result;
42785 wxGBSpan temp2 ;
42786 PyObject * obj0 = 0 ;
42787 PyObject * obj1 = 0 ;
42788 char *kwnames[] = {
42789 (char *) "self",(char *) "span", NULL
42790 };
42791
42792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42794 if (SWIG_arg_fail(1)) SWIG_fail;
42795 {
42796 arg2 = &temp2;
42797 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42798 }
42799 {
42800 PyThreadState* __tstate = wxPyBeginAllowThreads();
42801 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42802
42803 wxPyEndAllowThreads(__tstate);
42804 if (PyErr_Occurred()) SWIG_fail;
42805 }
42806 {
42807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42808 }
42809 return resultobj;
42810 fail:
42811 return NULL;
42812 }
42813
42814
42815 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42816 PyObject *resultobj;
42817 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42818 wxGBSizerItem *arg2 = 0 ;
42819 bool result;
42820 PyObject * obj0 = 0 ;
42821 PyObject * obj1 = 0 ;
42822 char *kwnames[] = {
42823 (char *) "self",(char *) "other", NULL
42824 };
42825
42826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42828 if (SWIG_arg_fail(1)) SWIG_fail;
42829 {
42830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42831 if (SWIG_arg_fail(2)) SWIG_fail;
42832 if (arg2 == NULL) {
42833 SWIG_null_ref("wxGBSizerItem");
42834 }
42835 if (SWIG_arg_fail(2)) SWIG_fail;
42836 }
42837 {
42838 PyThreadState* __tstate = wxPyBeginAllowThreads();
42839 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42840
42841 wxPyEndAllowThreads(__tstate);
42842 if (PyErr_Occurred()) SWIG_fail;
42843 }
42844 {
42845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42846 }
42847 return resultobj;
42848 fail:
42849 return NULL;
42850 }
42851
42852
42853 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42854 PyObject *resultobj;
42855 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42856 wxGBPosition *arg2 = 0 ;
42857 wxGBSpan *arg3 = 0 ;
42858 bool result;
42859 wxGBPosition temp2 ;
42860 wxGBSpan temp3 ;
42861 PyObject * obj0 = 0 ;
42862 PyObject * obj1 = 0 ;
42863 PyObject * obj2 = 0 ;
42864 char *kwnames[] = {
42865 (char *) "self",(char *) "pos",(char *) "span", NULL
42866 };
42867
42868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42870 if (SWIG_arg_fail(1)) SWIG_fail;
42871 {
42872 arg2 = &temp2;
42873 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42874 }
42875 {
42876 arg3 = &temp3;
42877 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42878 }
42879 {
42880 PyThreadState* __tstate = wxPyBeginAllowThreads();
42881 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42882
42883 wxPyEndAllowThreads(__tstate);
42884 if (PyErr_Occurred()) SWIG_fail;
42885 }
42886 {
42887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42888 }
42889 return resultobj;
42890 fail:
42891 return NULL;
42892 }
42893
42894
42895 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42896 PyObject *resultobj;
42897 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42898 wxGBPosition result;
42899 PyObject * obj0 = 0 ;
42900 char *kwnames[] = {
42901 (char *) "self", NULL
42902 };
42903
42904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42906 if (SWIG_arg_fail(1)) SWIG_fail;
42907 {
42908 PyThreadState* __tstate = wxPyBeginAllowThreads();
42909 result = wxGBSizerItem_GetEndPos(arg1);
42910
42911 wxPyEndAllowThreads(__tstate);
42912 if (PyErr_Occurred()) SWIG_fail;
42913 }
42914 {
42915 wxGBPosition * resultptr;
42916 resultptr = new wxGBPosition((wxGBPosition &)(result));
42917 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42918 }
42919 return resultobj;
42920 fail:
42921 return NULL;
42922 }
42923
42924
42925 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42926 PyObject *resultobj;
42927 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42928 wxGridBagSizer *result;
42929 PyObject * obj0 = 0 ;
42930 char *kwnames[] = {
42931 (char *) "self", NULL
42932 };
42933
42934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42936 if (SWIG_arg_fail(1)) SWIG_fail;
42937 {
42938 PyThreadState* __tstate = wxPyBeginAllowThreads();
42939 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42940
42941 wxPyEndAllowThreads(__tstate);
42942 if (PyErr_Occurred()) SWIG_fail;
42943 }
42944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42945 return resultobj;
42946 fail:
42947 return NULL;
42948 }
42949
42950
42951 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42952 PyObject *resultobj;
42953 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42954 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42955 PyObject * obj0 = 0 ;
42956 PyObject * obj1 = 0 ;
42957 char *kwnames[] = {
42958 (char *) "self",(char *) "sizer", NULL
42959 };
42960
42961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42963 if (SWIG_arg_fail(1)) SWIG_fail;
42964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42965 if (SWIG_arg_fail(2)) SWIG_fail;
42966 {
42967 PyThreadState* __tstate = wxPyBeginAllowThreads();
42968 (arg1)->SetGBSizer(arg2);
42969
42970 wxPyEndAllowThreads(__tstate);
42971 if (PyErr_Occurred()) SWIG_fail;
42972 }
42973 Py_INCREF(Py_None); resultobj = Py_None;
42974 return resultobj;
42975 fail:
42976 return NULL;
42977 }
42978
42979
42980 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42981 PyObject *obj;
42982 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42983 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42984 Py_INCREF(obj);
42985 return Py_BuildValue((char *)"");
42986 }
42987 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42988 PyObject *resultobj;
42989 int arg1 = (int) 0 ;
42990 int arg2 = (int) 0 ;
42991 wxGridBagSizer *result;
42992 PyObject * obj0 = 0 ;
42993 PyObject * obj1 = 0 ;
42994 char *kwnames[] = {
42995 (char *) "vgap",(char *) "hgap", NULL
42996 };
42997
42998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42999 if (obj0) {
43000 {
43001 arg1 = (int)(SWIG_As_int(obj0));
43002 if (SWIG_arg_fail(1)) SWIG_fail;
43003 }
43004 }
43005 if (obj1) {
43006 {
43007 arg2 = (int)(SWIG_As_int(obj1));
43008 if (SWIG_arg_fail(2)) SWIG_fail;
43009 }
43010 }
43011 {
43012 PyThreadState* __tstate = wxPyBeginAllowThreads();
43013 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43014
43015 wxPyEndAllowThreads(__tstate);
43016 if (PyErr_Occurred()) SWIG_fail;
43017 }
43018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43019 return resultobj;
43020 fail:
43021 return NULL;
43022 }
43023
43024
43025 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43026 PyObject *resultobj;
43027 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43028 PyObject *arg2 = (PyObject *) 0 ;
43029 wxGBPosition *arg3 = 0 ;
43030 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43031 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43032 int arg5 = (int) 0 ;
43033 int arg6 = (int) 0 ;
43034 PyObject *arg7 = (PyObject *) NULL ;
43035 wxGBSizerItem *result;
43036 wxGBPosition temp3 ;
43037 wxGBSpan temp4 ;
43038 PyObject * obj0 = 0 ;
43039 PyObject * obj1 = 0 ;
43040 PyObject * obj2 = 0 ;
43041 PyObject * obj3 = 0 ;
43042 PyObject * obj4 = 0 ;
43043 PyObject * obj5 = 0 ;
43044 PyObject * obj6 = 0 ;
43045 char *kwnames[] = {
43046 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43047 };
43048
43049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43051 if (SWIG_arg_fail(1)) SWIG_fail;
43052 arg2 = obj1;
43053 {
43054 arg3 = &temp3;
43055 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43056 }
43057 if (obj3) {
43058 {
43059 arg4 = &temp4;
43060 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43061 }
43062 }
43063 if (obj4) {
43064 {
43065 arg5 = (int)(SWIG_As_int(obj4));
43066 if (SWIG_arg_fail(5)) SWIG_fail;
43067 }
43068 }
43069 if (obj5) {
43070 {
43071 arg6 = (int)(SWIG_As_int(obj5));
43072 if (SWIG_arg_fail(6)) SWIG_fail;
43073 }
43074 }
43075 if (obj6) {
43076 arg7 = obj6;
43077 }
43078 {
43079 PyThreadState* __tstate = wxPyBeginAllowThreads();
43080 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43081
43082 wxPyEndAllowThreads(__tstate);
43083 if (PyErr_Occurred()) SWIG_fail;
43084 }
43085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43086 return resultobj;
43087 fail:
43088 return NULL;
43089 }
43090
43091
43092 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43093 PyObject *resultobj;
43094 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43095 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43096 wxGBSizerItem *result;
43097 PyObject * obj0 = 0 ;
43098 PyObject * obj1 = 0 ;
43099 char *kwnames[] = {
43100 (char *) "self",(char *) "item", NULL
43101 };
43102
43103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43105 if (SWIG_arg_fail(1)) SWIG_fail;
43106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43107 if (SWIG_arg_fail(2)) SWIG_fail;
43108 {
43109 PyThreadState* __tstate = wxPyBeginAllowThreads();
43110 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43111
43112 wxPyEndAllowThreads(__tstate);
43113 if (PyErr_Occurred()) SWIG_fail;
43114 }
43115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43116 return resultobj;
43117 fail:
43118 return NULL;
43119 }
43120
43121
43122 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43123 PyObject *resultobj;
43124 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43125 int arg2 ;
43126 int arg3 ;
43127 wxSize result;
43128 PyObject * obj0 = 0 ;
43129 PyObject * obj1 = 0 ;
43130 PyObject * obj2 = 0 ;
43131 char *kwnames[] = {
43132 (char *) "self",(char *) "row",(char *) "col", NULL
43133 };
43134
43135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43137 if (SWIG_arg_fail(1)) SWIG_fail;
43138 {
43139 arg2 = (int)(SWIG_As_int(obj1));
43140 if (SWIG_arg_fail(2)) SWIG_fail;
43141 }
43142 {
43143 arg3 = (int)(SWIG_As_int(obj2));
43144 if (SWIG_arg_fail(3)) SWIG_fail;
43145 }
43146 {
43147 PyThreadState* __tstate = wxPyBeginAllowThreads();
43148 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43149
43150 wxPyEndAllowThreads(__tstate);
43151 if (PyErr_Occurred()) SWIG_fail;
43152 }
43153 {
43154 wxSize * resultptr;
43155 resultptr = new wxSize((wxSize &)(result));
43156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43157 }
43158 return resultobj;
43159 fail:
43160 return NULL;
43161 }
43162
43163
43164 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43165 PyObject *resultobj;
43166 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43167 wxSize result;
43168 PyObject * obj0 = 0 ;
43169 char *kwnames[] = {
43170 (char *) "self", NULL
43171 };
43172
43173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43175 if (SWIG_arg_fail(1)) SWIG_fail;
43176 {
43177 PyThreadState* __tstate = wxPyBeginAllowThreads();
43178 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43179
43180 wxPyEndAllowThreads(__tstate);
43181 if (PyErr_Occurred()) SWIG_fail;
43182 }
43183 {
43184 wxSize * resultptr;
43185 resultptr = new wxSize((wxSize &)(result));
43186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43187 }
43188 return resultobj;
43189 fail:
43190 return NULL;
43191 }
43192
43193
43194 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43195 PyObject *resultobj;
43196 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43197 wxSize *arg2 = 0 ;
43198 wxSize temp2 ;
43199 PyObject * obj0 = 0 ;
43200 PyObject * obj1 = 0 ;
43201 char *kwnames[] = {
43202 (char *) "self",(char *) "sz", NULL
43203 };
43204
43205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43207 if (SWIG_arg_fail(1)) SWIG_fail;
43208 {
43209 arg2 = &temp2;
43210 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43211 }
43212 {
43213 PyThreadState* __tstate = wxPyBeginAllowThreads();
43214 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43215
43216 wxPyEndAllowThreads(__tstate);
43217 if (PyErr_Occurred()) SWIG_fail;
43218 }
43219 Py_INCREF(Py_None); resultobj = Py_None;
43220 return resultobj;
43221 fail:
43222 return NULL;
43223 }
43224
43225
43226 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43227 PyObject *resultobj;
43228 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43229 wxWindow *arg2 = (wxWindow *) 0 ;
43230 wxGBPosition result;
43231 PyObject * obj0 = 0 ;
43232 PyObject * obj1 = 0 ;
43233
43234 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43236 if (SWIG_arg_fail(1)) SWIG_fail;
43237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43238 if (SWIG_arg_fail(2)) SWIG_fail;
43239 {
43240 PyThreadState* __tstate = wxPyBeginAllowThreads();
43241 result = (arg1)->GetItemPosition(arg2);
43242
43243 wxPyEndAllowThreads(__tstate);
43244 if (PyErr_Occurred()) SWIG_fail;
43245 }
43246 {
43247 wxGBPosition * resultptr;
43248 resultptr = new wxGBPosition((wxGBPosition &)(result));
43249 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43250 }
43251 return resultobj;
43252 fail:
43253 return NULL;
43254 }
43255
43256
43257 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43258 PyObject *resultobj;
43259 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43260 wxSizer *arg2 = (wxSizer *) 0 ;
43261 wxGBPosition result;
43262 PyObject * obj0 = 0 ;
43263 PyObject * obj1 = 0 ;
43264
43265 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43267 if (SWIG_arg_fail(1)) SWIG_fail;
43268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43269 if (SWIG_arg_fail(2)) SWIG_fail;
43270 {
43271 PyThreadState* __tstate = wxPyBeginAllowThreads();
43272 result = (arg1)->GetItemPosition(arg2);
43273
43274 wxPyEndAllowThreads(__tstate);
43275 if (PyErr_Occurred()) SWIG_fail;
43276 }
43277 {
43278 wxGBPosition * resultptr;
43279 resultptr = new wxGBPosition((wxGBPosition &)(result));
43280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43281 }
43282 return resultobj;
43283 fail:
43284 return NULL;
43285 }
43286
43287
43288 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43289 PyObject *resultobj;
43290 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43291 size_t arg2 ;
43292 wxGBPosition result;
43293 PyObject * obj0 = 0 ;
43294 PyObject * obj1 = 0 ;
43295
43296 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43298 if (SWIG_arg_fail(1)) SWIG_fail;
43299 {
43300 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43301 if (SWIG_arg_fail(2)) SWIG_fail;
43302 }
43303 {
43304 PyThreadState* __tstate = wxPyBeginAllowThreads();
43305 result = (arg1)->GetItemPosition(arg2);
43306
43307 wxPyEndAllowThreads(__tstate);
43308 if (PyErr_Occurred()) SWIG_fail;
43309 }
43310 {
43311 wxGBPosition * resultptr;
43312 resultptr = new wxGBPosition((wxGBPosition &)(result));
43313 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43314 }
43315 return resultobj;
43316 fail:
43317 return NULL;
43318 }
43319
43320
43321 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43322 int argc;
43323 PyObject *argv[3];
43324 int ii;
43325
43326 argc = PyObject_Length(args);
43327 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43328 argv[ii] = PyTuple_GetItem(args,ii);
43329 }
43330 if (argc == 2) {
43331 int _v;
43332 {
43333 void *ptr;
43334 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43335 _v = 0;
43336 PyErr_Clear();
43337 } else {
43338 _v = 1;
43339 }
43340 }
43341 if (_v) {
43342 {
43343 void *ptr;
43344 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43345 _v = 0;
43346 PyErr_Clear();
43347 } else {
43348 _v = 1;
43349 }
43350 }
43351 if (_v) {
43352 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43353 }
43354 }
43355 }
43356 if (argc == 2) {
43357 int _v;
43358 {
43359 void *ptr;
43360 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43361 _v = 0;
43362 PyErr_Clear();
43363 } else {
43364 _v = 1;
43365 }
43366 }
43367 if (_v) {
43368 {
43369 void *ptr;
43370 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43371 _v = 0;
43372 PyErr_Clear();
43373 } else {
43374 _v = 1;
43375 }
43376 }
43377 if (_v) {
43378 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43379 }
43380 }
43381 }
43382 if (argc == 2) {
43383 int _v;
43384 {
43385 void *ptr;
43386 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43387 _v = 0;
43388 PyErr_Clear();
43389 } else {
43390 _v = 1;
43391 }
43392 }
43393 if (_v) {
43394 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43395 if (_v) {
43396 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43397 }
43398 }
43399 }
43400
43401 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43402 return NULL;
43403 }
43404
43405
43406 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43407 PyObject *resultobj;
43408 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43409 wxWindow *arg2 = (wxWindow *) 0 ;
43410 wxGBPosition *arg3 = 0 ;
43411 bool result;
43412 wxGBPosition temp3 ;
43413 PyObject * obj0 = 0 ;
43414 PyObject * obj1 = 0 ;
43415 PyObject * obj2 = 0 ;
43416
43417 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43419 if (SWIG_arg_fail(1)) SWIG_fail;
43420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43421 if (SWIG_arg_fail(2)) SWIG_fail;
43422 {
43423 arg3 = &temp3;
43424 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43425 }
43426 {
43427 PyThreadState* __tstate = wxPyBeginAllowThreads();
43428 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43429
43430 wxPyEndAllowThreads(__tstate);
43431 if (PyErr_Occurred()) SWIG_fail;
43432 }
43433 {
43434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43435 }
43436 return resultobj;
43437 fail:
43438 return NULL;
43439 }
43440
43441
43442 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43443 PyObject *resultobj;
43444 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43445 wxSizer *arg2 = (wxSizer *) 0 ;
43446 wxGBPosition *arg3 = 0 ;
43447 bool result;
43448 wxGBPosition temp3 ;
43449 PyObject * obj0 = 0 ;
43450 PyObject * obj1 = 0 ;
43451 PyObject * obj2 = 0 ;
43452
43453 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43455 if (SWIG_arg_fail(1)) SWIG_fail;
43456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43457 if (SWIG_arg_fail(2)) SWIG_fail;
43458 {
43459 arg3 = &temp3;
43460 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43461 }
43462 {
43463 PyThreadState* __tstate = wxPyBeginAllowThreads();
43464 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43465
43466 wxPyEndAllowThreads(__tstate);
43467 if (PyErr_Occurred()) SWIG_fail;
43468 }
43469 {
43470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43471 }
43472 return resultobj;
43473 fail:
43474 return NULL;
43475 }
43476
43477
43478 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43479 PyObject *resultobj;
43480 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43481 size_t arg2 ;
43482 wxGBPosition *arg3 = 0 ;
43483 bool result;
43484 wxGBPosition temp3 ;
43485 PyObject * obj0 = 0 ;
43486 PyObject * obj1 = 0 ;
43487 PyObject * obj2 = 0 ;
43488
43489 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43491 if (SWIG_arg_fail(1)) SWIG_fail;
43492 {
43493 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43494 if (SWIG_arg_fail(2)) SWIG_fail;
43495 }
43496 {
43497 arg3 = &temp3;
43498 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43499 }
43500 {
43501 PyThreadState* __tstate = wxPyBeginAllowThreads();
43502 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43503
43504 wxPyEndAllowThreads(__tstate);
43505 if (PyErr_Occurred()) SWIG_fail;
43506 }
43507 {
43508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43509 }
43510 return resultobj;
43511 fail:
43512 return NULL;
43513 }
43514
43515
43516 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43517 int argc;
43518 PyObject *argv[4];
43519 int ii;
43520
43521 argc = PyObject_Length(args);
43522 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43523 argv[ii] = PyTuple_GetItem(args,ii);
43524 }
43525 if (argc == 3) {
43526 int _v;
43527 {
43528 void *ptr;
43529 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43530 _v = 0;
43531 PyErr_Clear();
43532 } else {
43533 _v = 1;
43534 }
43535 }
43536 if (_v) {
43537 {
43538 void *ptr;
43539 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43540 _v = 0;
43541 PyErr_Clear();
43542 } else {
43543 _v = 1;
43544 }
43545 }
43546 if (_v) {
43547 {
43548 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43549 }
43550 if (_v) {
43551 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43552 }
43553 }
43554 }
43555 }
43556 if (argc == 3) {
43557 int _v;
43558 {
43559 void *ptr;
43560 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43561 _v = 0;
43562 PyErr_Clear();
43563 } else {
43564 _v = 1;
43565 }
43566 }
43567 if (_v) {
43568 {
43569 void *ptr;
43570 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43571 _v = 0;
43572 PyErr_Clear();
43573 } else {
43574 _v = 1;
43575 }
43576 }
43577 if (_v) {
43578 {
43579 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43580 }
43581 if (_v) {
43582 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43583 }
43584 }
43585 }
43586 }
43587 if (argc == 3) {
43588 int _v;
43589 {
43590 void *ptr;
43591 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43592 _v = 0;
43593 PyErr_Clear();
43594 } else {
43595 _v = 1;
43596 }
43597 }
43598 if (_v) {
43599 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43600 if (_v) {
43601 {
43602 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43603 }
43604 if (_v) {
43605 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43606 }
43607 }
43608 }
43609 }
43610
43611 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43612 return NULL;
43613 }
43614
43615
43616 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43617 PyObject *resultobj;
43618 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43619 wxWindow *arg2 = (wxWindow *) 0 ;
43620 wxGBSpan result;
43621 PyObject * obj0 = 0 ;
43622 PyObject * obj1 = 0 ;
43623
43624 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43626 if (SWIG_arg_fail(1)) SWIG_fail;
43627 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43628 if (SWIG_arg_fail(2)) SWIG_fail;
43629 {
43630 PyThreadState* __tstate = wxPyBeginAllowThreads();
43631 result = (arg1)->GetItemSpan(arg2);
43632
43633 wxPyEndAllowThreads(__tstate);
43634 if (PyErr_Occurred()) SWIG_fail;
43635 }
43636 {
43637 wxGBSpan * resultptr;
43638 resultptr = new wxGBSpan((wxGBSpan &)(result));
43639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43640 }
43641 return resultobj;
43642 fail:
43643 return NULL;
43644 }
43645
43646
43647 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43648 PyObject *resultobj;
43649 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43650 wxSizer *arg2 = (wxSizer *) 0 ;
43651 wxGBSpan result;
43652 PyObject * obj0 = 0 ;
43653 PyObject * obj1 = 0 ;
43654
43655 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43657 if (SWIG_arg_fail(1)) SWIG_fail;
43658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43659 if (SWIG_arg_fail(2)) SWIG_fail;
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (arg1)->GetItemSpan(arg2);
43663
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 {
43668 wxGBSpan * resultptr;
43669 resultptr = new wxGBSpan((wxGBSpan &)(result));
43670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43671 }
43672 return resultobj;
43673 fail:
43674 return NULL;
43675 }
43676
43677
43678 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43679 PyObject *resultobj;
43680 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43681 size_t arg2 ;
43682 wxGBSpan result;
43683 PyObject * obj0 = 0 ;
43684 PyObject * obj1 = 0 ;
43685
43686 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43688 if (SWIG_arg_fail(1)) SWIG_fail;
43689 {
43690 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43691 if (SWIG_arg_fail(2)) SWIG_fail;
43692 }
43693 {
43694 PyThreadState* __tstate = wxPyBeginAllowThreads();
43695 result = (arg1)->GetItemSpan(arg2);
43696
43697 wxPyEndAllowThreads(__tstate);
43698 if (PyErr_Occurred()) SWIG_fail;
43699 }
43700 {
43701 wxGBSpan * resultptr;
43702 resultptr = new wxGBSpan((wxGBSpan &)(result));
43703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43704 }
43705 return resultobj;
43706 fail:
43707 return NULL;
43708 }
43709
43710
43711 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43712 int argc;
43713 PyObject *argv[3];
43714 int ii;
43715
43716 argc = PyObject_Length(args);
43717 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43718 argv[ii] = PyTuple_GetItem(args,ii);
43719 }
43720 if (argc == 2) {
43721 int _v;
43722 {
43723 void *ptr;
43724 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43725 _v = 0;
43726 PyErr_Clear();
43727 } else {
43728 _v = 1;
43729 }
43730 }
43731 if (_v) {
43732 {
43733 void *ptr;
43734 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43735 _v = 0;
43736 PyErr_Clear();
43737 } else {
43738 _v = 1;
43739 }
43740 }
43741 if (_v) {
43742 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43743 }
43744 }
43745 }
43746 if (argc == 2) {
43747 int _v;
43748 {
43749 void *ptr;
43750 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43751 _v = 0;
43752 PyErr_Clear();
43753 } else {
43754 _v = 1;
43755 }
43756 }
43757 if (_v) {
43758 {
43759 void *ptr;
43760 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43761 _v = 0;
43762 PyErr_Clear();
43763 } else {
43764 _v = 1;
43765 }
43766 }
43767 if (_v) {
43768 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43769 }
43770 }
43771 }
43772 if (argc == 2) {
43773 int _v;
43774 {
43775 void *ptr;
43776 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43777 _v = 0;
43778 PyErr_Clear();
43779 } else {
43780 _v = 1;
43781 }
43782 }
43783 if (_v) {
43784 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43785 if (_v) {
43786 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43787 }
43788 }
43789 }
43790
43791 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43792 return NULL;
43793 }
43794
43795
43796 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43797 PyObject *resultobj;
43798 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43799 wxWindow *arg2 = (wxWindow *) 0 ;
43800 wxGBSpan *arg3 = 0 ;
43801 bool result;
43802 wxGBSpan temp3 ;
43803 PyObject * obj0 = 0 ;
43804 PyObject * obj1 = 0 ;
43805 PyObject * obj2 = 0 ;
43806
43807 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43809 if (SWIG_arg_fail(1)) SWIG_fail;
43810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43811 if (SWIG_arg_fail(2)) SWIG_fail;
43812 {
43813 arg3 = &temp3;
43814 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43815 }
43816 {
43817 PyThreadState* __tstate = wxPyBeginAllowThreads();
43818 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43819
43820 wxPyEndAllowThreads(__tstate);
43821 if (PyErr_Occurred()) SWIG_fail;
43822 }
43823 {
43824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43825 }
43826 return resultobj;
43827 fail:
43828 return NULL;
43829 }
43830
43831
43832 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43833 PyObject *resultobj;
43834 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43835 wxSizer *arg2 = (wxSizer *) 0 ;
43836 wxGBSpan *arg3 = 0 ;
43837 bool result;
43838 wxGBSpan temp3 ;
43839 PyObject * obj0 = 0 ;
43840 PyObject * obj1 = 0 ;
43841 PyObject * obj2 = 0 ;
43842
43843 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43845 if (SWIG_arg_fail(1)) SWIG_fail;
43846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43847 if (SWIG_arg_fail(2)) SWIG_fail;
43848 {
43849 arg3 = &temp3;
43850 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43851 }
43852 {
43853 PyThreadState* __tstate = wxPyBeginAllowThreads();
43854 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43855
43856 wxPyEndAllowThreads(__tstate);
43857 if (PyErr_Occurred()) SWIG_fail;
43858 }
43859 {
43860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43861 }
43862 return resultobj;
43863 fail:
43864 return NULL;
43865 }
43866
43867
43868 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43869 PyObject *resultobj;
43870 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43871 size_t arg2 ;
43872 wxGBSpan *arg3 = 0 ;
43873 bool result;
43874 wxGBSpan temp3 ;
43875 PyObject * obj0 = 0 ;
43876 PyObject * obj1 = 0 ;
43877 PyObject * obj2 = 0 ;
43878
43879 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43881 if (SWIG_arg_fail(1)) SWIG_fail;
43882 {
43883 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43884 if (SWIG_arg_fail(2)) SWIG_fail;
43885 }
43886 {
43887 arg3 = &temp3;
43888 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43889 }
43890 {
43891 PyThreadState* __tstate = wxPyBeginAllowThreads();
43892 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43893
43894 wxPyEndAllowThreads(__tstate);
43895 if (PyErr_Occurred()) SWIG_fail;
43896 }
43897 {
43898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43899 }
43900 return resultobj;
43901 fail:
43902 return NULL;
43903 }
43904
43905
43906 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43907 int argc;
43908 PyObject *argv[4];
43909 int ii;
43910
43911 argc = PyObject_Length(args);
43912 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43913 argv[ii] = PyTuple_GetItem(args,ii);
43914 }
43915 if (argc == 3) {
43916 int _v;
43917 {
43918 void *ptr;
43919 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43920 _v = 0;
43921 PyErr_Clear();
43922 } else {
43923 _v = 1;
43924 }
43925 }
43926 if (_v) {
43927 {
43928 void *ptr;
43929 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43930 _v = 0;
43931 PyErr_Clear();
43932 } else {
43933 _v = 1;
43934 }
43935 }
43936 if (_v) {
43937 {
43938 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43939 }
43940 if (_v) {
43941 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43942 }
43943 }
43944 }
43945 }
43946 if (argc == 3) {
43947 int _v;
43948 {
43949 void *ptr;
43950 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43951 _v = 0;
43952 PyErr_Clear();
43953 } else {
43954 _v = 1;
43955 }
43956 }
43957 if (_v) {
43958 {
43959 void *ptr;
43960 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43961 _v = 0;
43962 PyErr_Clear();
43963 } else {
43964 _v = 1;
43965 }
43966 }
43967 if (_v) {
43968 {
43969 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43970 }
43971 if (_v) {
43972 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43973 }
43974 }
43975 }
43976 }
43977 if (argc == 3) {
43978 int _v;
43979 {
43980 void *ptr;
43981 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43982 _v = 0;
43983 PyErr_Clear();
43984 } else {
43985 _v = 1;
43986 }
43987 }
43988 if (_v) {
43989 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43990 if (_v) {
43991 {
43992 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43993 }
43994 if (_v) {
43995 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43996 }
43997 }
43998 }
43999 }
44000
44001 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44002 return NULL;
44003 }
44004
44005
44006 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44007 PyObject *resultobj;
44008 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44009 wxWindow *arg2 = (wxWindow *) 0 ;
44010 wxGBSizerItem *result;
44011 PyObject * obj0 = 0 ;
44012 PyObject * obj1 = 0 ;
44013
44014 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
44021 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44022
44023 wxPyEndAllowThreads(__tstate);
44024 if (PyErr_Occurred()) SWIG_fail;
44025 }
44026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44027 return resultobj;
44028 fail:
44029 return NULL;
44030 }
44031
44032
44033 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44034 PyObject *resultobj;
44035 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44036 wxSizer *arg2 = (wxSizer *) 0 ;
44037 wxGBSizerItem *result;
44038 PyObject * obj0 = 0 ;
44039 PyObject * obj1 = 0 ;
44040
44041 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44043 if (SWIG_arg_fail(1)) SWIG_fail;
44044 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44045 if (SWIG_arg_fail(2)) SWIG_fail;
44046 {
44047 PyThreadState* __tstate = wxPyBeginAllowThreads();
44048 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44049
44050 wxPyEndAllowThreads(__tstate);
44051 if (PyErr_Occurred()) SWIG_fail;
44052 }
44053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44054 return resultobj;
44055 fail:
44056 return NULL;
44057 }
44058
44059
44060 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44061 int argc;
44062 PyObject *argv[3];
44063 int ii;
44064
44065 argc = PyObject_Length(args);
44066 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44067 argv[ii] = PyTuple_GetItem(args,ii);
44068 }
44069 if (argc == 2) {
44070 int _v;
44071 {
44072 void *ptr;
44073 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44074 _v = 0;
44075 PyErr_Clear();
44076 } else {
44077 _v = 1;
44078 }
44079 }
44080 if (_v) {
44081 {
44082 void *ptr;
44083 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44084 _v = 0;
44085 PyErr_Clear();
44086 } else {
44087 _v = 1;
44088 }
44089 }
44090 if (_v) {
44091 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44092 }
44093 }
44094 }
44095 if (argc == 2) {
44096 int _v;
44097 {
44098 void *ptr;
44099 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44100 _v = 0;
44101 PyErr_Clear();
44102 } else {
44103 _v = 1;
44104 }
44105 }
44106 if (_v) {
44107 {
44108 void *ptr;
44109 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44110 _v = 0;
44111 PyErr_Clear();
44112 } else {
44113 _v = 1;
44114 }
44115 }
44116 if (_v) {
44117 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44118 }
44119 }
44120 }
44121
44122 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44123 return NULL;
44124 }
44125
44126
44127 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44128 PyObject *resultobj;
44129 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44130 wxGBPosition *arg2 = 0 ;
44131 wxGBSizerItem *result;
44132 wxGBPosition temp2 ;
44133 PyObject * obj0 = 0 ;
44134 PyObject * obj1 = 0 ;
44135 char *kwnames[] = {
44136 (char *) "self",(char *) "pos", NULL
44137 };
44138
44139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44141 if (SWIG_arg_fail(1)) SWIG_fail;
44142 {
44143 arg2 = &temp2;
44144 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44145 }
44146 {
44147 PyThreadState* __tstate = wxPyBeginAllowThreads();
44148 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44149
44150 wxPyEndAllowThreads(__tstate);
44151 if (PyErr_Occurred()) SWIG_fail;
44152 }
44153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44154 return resultobj;
44155 fail:
44156 return NULL;
44157 }
44158
44159
44160 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44161 PyObject *resultobj;
44162 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44163 wxPoint *arg2 = 0 ;
44164 wxGBSizerItem *result;
44165 wxPoint temp2 ;
44166 PyObject * obj0 = 0 ;
44167 PyObject * obj1 = 0 ;
44168 char *kwnames[] = {
44169 (char *) "self",(char *) "pt", NULL
44170 };
44171
44172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44174 if (SWIG_arg_fail(1)) SWIG_fail;
44175 {
44176 arg2 = &temp2;
44177 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44178 }
44179 {
44180 PyThreadState* __tstate = wxPyBeginAllowThreads();
44181 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44182
44183 wxPyEndAllowThreads(__tstate);
44184 if (PyErr_Occurred()) SWIG_fail;
44185 }
44186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44187 return resultobj;
44188 fail:
44189 return NULL;
44190 }
44191
44192
44193 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44194 PyObject *resultobj;
44195 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44196 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44197 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44198 bool result;
44199 PyObject * obj0 = 0 ;
44200 PyObject * obj1 = 0 ;
44201 PyObject * obj2 = 0 ;
44202 char *kwnames[] = {
44203 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44204 };
44205
44206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44208 if (SWIG_arg_fail(1)) SWIG_fail;
44209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44210 if (SWIG_arg_fail(2)) SWIG_fail;
44211 if (obj2) {
44212 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44213 if (SWIG_arg_fail(3)) SWIG_fail;
44214 }
44215 {
44216 PyThreadState* __tstate = wxPyBeginAllowThreads();
44217 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44218
44219 wxPyEndAllowThreads(__tstate);
44220 if (PyErr_Occurred()) SWIG_fail;
44221 }
44222 {
44223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44224 }
44225 return resultobj;
44226 fail:
44227 return NULL;
44228 }
44229
44230
44231 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44232 PyObject *resultobj;
44233 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44234 wxGBPosition *arg2 = 0 ;
44235 wxGBSpan *arg3 = 0 ;
44236 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44237 bool result;
44238 wxGBPosition temp2 ;
44239 wxGBSpan temp3 ;
44240 PyObject * obj0 = 0 ;
44241 PyObject * obj1 = 0 ;
44242 PyObject * obj2 = 0 ;
44243 PyObject * obj3 = 0 ;
44244 char *kwnames[] = {
44245 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44246 };
44247
44248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44250 if (SWIG_arg_fail(1)) SWIG_fail;
44251 {
44252 arg2 = &temp2;
44253 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44254 }
44255 {
44256 arg3 = &temp3;
44257 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44258 }
44259 if (obj3) {
44260 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44261 if (SWIG_arg_fail(4)) SWIG_fail;
44262 }
44263 {
44264 PyThreadState* __tstate = wxPyBeginAllowThreads();
44265 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44266
44267 wxPyEndAllowThreads(__tstate);
44268 if (PyErr_Occurred()) SWIG_fail;
44269 }
44270 {
44271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44272 }
44273 return resultobj;
44274 fail:
44275 return NULL;
44276 }
44277
44278
44279 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44280 PyObject *obj;
44281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44282 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44283 Py_INCREF(obj);
44284 return Py_BuildValue((char *)"");
44285 }
44286 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44287 PyObject *resultobj;
44288 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44289 wxRelationship arg2 ;
44290 wxWindow *arg3 = (wxWindow *) 0 ;
44291 wxEdge arg4 ;
44292 int arg5 = (int) 0 ;
44293 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44294 PyObject * obj0 = 0 ;
44295 PyObject * obj1 = 0 ;
44296 PyObject * obj2 = 0 ;
44297 PyObject * obj3 = 0 ;
44298 PyObject * obj4 = 0 ;
44299 PyObject * obj5 = 0 ;
44300 char *kwnames[] = {
44301 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44302 };
44303
44304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44306 if (SWIG_arg_fail(1)) SWIG_fail;
44307 {
44308 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44309 if (SWIG_arg_fail(2)) SWIG_fail;
44310 }
44311 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44312 if (SWIG_arg_fail(3)) SWIG_fail;
44313 {
44314 arg4 = (wxEdge)(SWIG_As_int(obj3));
44315 if (SWIG_arg_fail(4)) SWIG_fail;
44316 }
44317 if (obj4) {
44318 {
44319 arg5 = (int)(SWIG_As_int(obj4));
44320 if (SWIG_arg_fail(5)) SWIG_fail;
44321 }
44322 }
44323 if (obj5) {
44324 {
44325 arg6 = (int)(SWIG_As_int(obj5));
44326 if (SWIG_arg_fail(6)) SWIG_fail;
44327 }
44328 }
44329 {
44330 PyThreadState* __tstate = wxPyBeginAllowThreads();
44331 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44332
44333 wxPyEndAllowThreads(__tstate);
44334 if (PyErr_Occurred()) SWIG_fail;
44335 }
44336 Py_INCREF(Py_None); resultobj = Py_None;
44337 return resultobj;
44338 fail:
44339 return NULL;
44340 }
44341
44342
44343 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44344 PyObject *resultobj;
44345 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44346 wxWindow *arg2 = (wxWindow *) 0 ;
44347 int arg3 = (int) 0 ;
44348 PyObject * obj0 = 0 ;
44349 PyObject * obj1 = 0 ;
44350 PyObject * obj2 = 0 ;
44351 char *kwnames[] = {
44352 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44353 };
44354
44355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44357 if (SWIG_arg_fail(1)) SWIG_fail;
44358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44359 if (SWIG_arg_fail(2)) SWIG_fail;
44360 if (obj2) {
44361 {
44362 arg3 = (int)(SWIG_As_int(obj2));
44363 if (SWIG_arg_fail(3)) SWIG_fail;
44364 }
44365 }
44366 {
44367 PyThreadState* __tstate = wxPyBeginAllowThreads();
44368 (arg1)->LeftOf(arg2,arg3);
44369
44370 wxPyEndAllowThreads(__tstate);
44371 if (PyErr_Occurred()) SWIG_fail;
44372 }
44373 Py_INCREF(Py_None); resultobj = Py_None;
44374 return resultobj;
44375 fail:
44376 return NULL;
44377 }
44378
44379
44380 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44381 PyObject *resultobj;
44382 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44383 wxWindow *arg2 = (wxWindow *) 0 ;
44384 int arg3 = (int) 0 ;
44385 PyObject * obj0 = 0 ;
44386 PyObject * obj1 = 0 ;
44387 PyObject * obj2 = 0 ;
44388 char *kwnames[] = {
44389 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44390 };
44391
44392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44394 if (SWIG_arg_fail(1)) SWIG_fail;
44395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44396 if (SWIG_arg_fail(2)) SWIG_fail;
44397 if (obj2) {
44398 {
44399 arg3 = (int)(SWIG_As_int(obj2));
44400 if (SWIG_arg_fail(3)) SWIG_fail;
44401 }
44402 }
44403 {
44404 PyThreadState* __tstate = wxPyBeginAllowThreads();
44405 (arg1)->RightOf(arg2,arg3);
44406
44407 wxPyEndAllowThreads(__tstate);
44408 if (PyErr_Occurred()) SWIG_fail;
44409 }
44410 Py_INCREF(Py_None); resultobj = Py_None;
44411 return resultobj;
44412 fail:
44413 return NULL;
44414 }
44415
44416
44417 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44418 PyObject *resultobj;
44419 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44420 wxWindow *arg2 = (wxWindow *) 0 ;
44421 int arg3 = (int) 0 ;
44422 PyObject * obj0 = 0 ;
44423 PyObject * obj1 = 0 ;
44424 PyObject * obj2 = 0 ;
44425 char *kwnames[] = {
44426 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44427 };
44428
44429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44431 if (SWIG_arg_fail(1)) SWIG_fail;
44432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44433 if (SWIG_arg_fail(2)) SWIG_fail;
44434 if (obj2) {
44435 {
44436 arg3 = (int)(SWIG_As_int(obj2));
44437 if (SWIG_arg_fail(3)) SWIG_fail;
44438 }
44439 }
44440 {
44441 PyThreadState* __tstate = wxPyBeginAllowThreads();
44442 (arg1)->Above(arg2,arg3);
44443
44444 wxPyEndAllowThreads(__tstate);
44445 if (PyErr_Occurred()) SWIG_fail;
44446 }
44447 Py_INCREF(Py_None); resultobj = Py_None;
44448 return resultobj;
44449 fail:
44450 return NULL;
44451 }
44452
44453
44454 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44455 PyObject *resultobj;
44456 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44457 wxWindow *arg2 = (wxWindow *) 0 ;
44458 int arg3 = (int) 0 ;
44459 PyObject * obj0 = 0 ;
44460 PyObject * obj1 = 0 ;
44461 PyObject * obj2 = 0 ;
44462 char *kwnames[] = {
44463 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44464 };
44465
44466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44468 if (SWIG_arg_fail(1)) SWIG_fail;
44469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44470 if (SWIG_arg_fail(2)) SWIG_fail;
44471 if (obj2) {
44472 {
44473 arg3 = (int)(SWIG_As_int(obj2));
44474 if (SWIG_arg_fail(3)) SWIG_fail;
44475 }
44476 }
44477 {
44478 PyThreadState* __tstate = wxPyBeginAllowThreads();
44479 (arg1)->Below(arg2,arg3);
44480
44481 wxPyEndAllowThreads(__tstate);
44482 if (PyErr_Occurred()) SWIG_fail;
44483 }
44484 Py_INCREF(Py_None); resultobj = Py_None;
44485 return resultobj;
44486 fail:
44487 return NULL;
44488 }
44489
44490
44491 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44492 PyObject *resultobj;
44493 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44494 wxWindow *arg2 = (wxWindow *) 0 ;
44495 wxEdge arg3 ;
44496 int arg4 = (int) 0 ;
44497 PyObject * obj0 = 0 ;
44498 PyObject * obj1 = 0 ;
44499 PyObject * obj2 = 0 ;
44500 PyObject * obj3 = 0 ;
44501 char *kwnames[] = {
44502 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44503 };
44504
44505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44507 if (SWIG_arg_fail(1)) SWIG_fail;
44508 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44509 if (SWIG_arg_fail(2)) SWIG_fail;
44510 {
44511 arg3 = (wxEdge)(SWIG_As_int(obj2));
44512 if (SWIG_arg_fail(3)) SWIG_fail;
44513 }
44514 if (obj3) {
44515 {
44516 arg4 = (int)(SWIG_As_int(obj3));
44517 if (SWIG_arg_fail(4)) SWIG_fail;
44518 }
44519 }
44520 {
44521 PyThreadState* __tstate = wxPyBeginAllowThreads();
44522 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44523
44524 wxPyEndAllowThreads(__tstate);
44525 if (PyErr_Occurred()) SWIG_fail;
44526 }
44527 Py_INCREF(Py_None); resultobj = Py_None;
44528 return resultobj;
44529 fail:
44530 return NULL;
44531 }
44532
44533
44534 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44535 PyObject *resultobj;
44536 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44537 wxWindow *arg2 = (wxWindow *) 0 ;
44538 wxEdge arg3 ;
44539 int arg4 ;
44540 PyObject * obj0 = 0 ;
44541 PyObject * obj1 = 0 ;
44542 PyObject * obj2 = 0 ;
44543 PyObject * obj3 = 0 ;
44544 char *kwnames[] = {
44545 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44546 };
44547
44548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44550 if (SWIG_arg_fail(1)) SWIG_fail;
44551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44552 if (SWIG_arg_fail(2)) SWIG_fail;
44553 {
44554 arg3 = (wxEdge)(SWIG_As_int(obj2));
44555 if (SWIG_arg_fail(3)) SWIG_fail;
44556 }
44557 {
44558 arg4 = (int)(SWIG_As_int(obj3));
44559 if (SWIG_arg_fail(4)) SWIG_fail;
44560 }
44561 {
44562 PyThreadState* __tstate = wxPyBeginAllowThreads();
44563 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44564
44565 wxPyEndAllowThreads(__tstate);
44566 if (PyErr_Occurred()) SWIG_fail;
44567 }
44568 Py_INCREF(Py_None); resultobj = Py_None;
44569 return resultobj;
44570 fail:
44571 return NULL;
44572 }
44573
44574
44575 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44576 PyObject *resultobj;
44577 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44578 int arg2 ;
44579 PyObject * obj0 = 0 ;
44580 PyObject * obj1 = 0 ;
44581 char *kwnames[] = {
44582 (char *) "self",(char *) "val", NULL
44583 };
44584
44585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44587 if (SWIG_arg_fail(1)) SWIG_fail;
44588 {
44589 arg2 = (int)(SWIG_As_int(obj1));
44590 if (SWIG_arg_fail(2)) SWIG_fail;
44591 }
44592 {
44593 PyThreadState* __tstate = wxPyBeginAllowThreads();
44594 (arg1)->Absolute(arg2);
44595
44596 wxPyEndAllowThreads(__tstate);
44597 if (PyErr_Occurred()) SWIG_fail;
44598 }
44599 Py_INCREF(Py_None); resultobj = Py_None;
44600 return resultobj;
44601 fail:
44602 return NULL;
44603 }
44604
44605
44606 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44607 PyObject *resultobj;
44608 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44609 PyObject * obj0 = 0 ;
44610 char *kwnames[] = {
44611 (char *) "self", NULL
44612 };
44613
44614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44616 if (SWIG_arg_fail(1)) SWIG_fail;
44617 {
44618 PyThreadState* __tstate = wxPyBeginAllowThreads();
44619 (arg1)->Unconstrained();
44620
44621 wxPyEndAllowThreads(__tstate);
44622 if (PyErr_Occurred()) SWIG_fail;
44623 }
44624 Py_INCREF(Py_None); resultobj = Py_None;
44625 return resultobj;
44626 fail:
44627 return NULL;
44628 }
44629
44630
44631 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44632 PyObject *resultobj;
44633 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44634 PyObject * obj0 = 0 ;
44635 char *kwnames[] = {
44636 (char *) "self", NULL
44637 };
44638
44639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44641 if (SWIG_arg_fail(1)) SWIG_fail;
44642 {
44643 PyThreadState* __tstate = wxPyBeginAllowThreads();
44644 (arg1)->AsIs();
44645
44646 wxPyEndAllowThreads(__tstate);
44647 if (PyErr_Occurred()) SWIG_fail;
44648 }
44649 Py_INCREF(Py_None); resultobj = Py_None;
44650 return resultobj;
44651 fail:
44652 return NULL;
44653 }
44654
44655
44656 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44657 PyObject *resultobj;
44658 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44659 wxWindow *result;
44660 PyObject * obj0 = 0 ;
44661 char *kwnames[] = {
44662 (char *) "self", NULL
44663 };
44664
44665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44667 if (SWIG_arg_fail(1)) SWIG_fail;
44668 {
44669 PyThreadState* __tstate = wxPyBeginAllowThreads();
44670 result = (wxWindow *)(arg1)->GetOtherWindow();
44671
44672 wxPyEndAllowThreads(__tstate);
44673 if (PyErr_Occurred()) SWIG_fail;
44674 }
44675 {
44676 resultobj = wxPyMake_wxObject(result, 0);
44677 }
44678 return resultobj;
44679 fail:
44680 return NULL;
44681 }
44682
44683
44684 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44685 PyObject *resultobj;
44686 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44687 wxEdge result;
44688 PyObject * obj0 = 0 ;
44689 char *kwnames[] = {
44690 (char *) "self", NULL
44691 };
44692
44693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44695 if (SWIG_arg_fail(1)) SWIG_fail;
44696 {
44697 PyThreadState* __tstate = wxPyBeginAllowThreads();
44698 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44699
44700 wxPyEndAllowThreads(__tstate);
44701 if (PyErr_Occurred()) SWIG_fail;
44702 }
44703 resultobj = SWIG_From_int((result));
44704 return resultobj;
44705 fail:
44706 return NULL;
44707 }
44708
44709
44710 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44711 PyObject *resultobj;
44712 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44713 wxEdge arg2 ;
44714 PyObject * obj0 = 0 ;
44715 PyObject * obj1 = 0 ;
44716 char *kwnames[] = {
44717 (char *) "self",(char *) "which", NULL
44718 };
44719
44720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44722 if (SWIG_arg_fail(1)) SWIG_fail;
44723 {
44724 arg2 = (wxEdge)(SWIG_As_int(obj1));
44725 if (SWIG_arg_fail(2)) SWIG_fail;
44726 }
44727 {
44728 PyThreadState* __tstate = wxPyBeginAllowThreads();
44729 (arg1)->SetEdge((wxEdge )arg2);
44730
44731 wxPyEndAllowThreads(__tstate);
44732 if (PyErr_Occurred()) SWIG_fail;
44733 }
44734 Py_INCREF(Py_None); resultobj = Py_None;
44735 return resultobj;
44736 fail:
44737 return NULL;
44738 }
44739
44740
44741 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44742 PyObject *resultobj;
44743 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44744 int arg2 ;
44745 PyObject * obj0 = 0 ;
44746 PyObject * obj1 = 0 ;
44747 char *kwnames[] = {
44748 (char *) "self",(char *) "v", NULL
44749 };
44750
44751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44753 if (SWIG_arg_fail(1)) SWIG_fail;
44754 {
44755 arg2 = (int)(SWIG_As_int(obj1));
44756 if (SWIG_arg_fail(2)) SWIG_fail;
44757 }
44758 {
44759 PyThreadState* __tstate = wxPyBeginAllowThreads();
44760 (arg1)->SetValue(arg2);
44761
44762 wxPyEndAllowThreads(__tstate);
44763 if (PyErr_Occurred()) SWIG_fail;
44764 }
44765 Py_INCREF(Py_None); resultobj = Py_None;
44766 return resultobj;
44767 fail:
44768 return NULL;
44769 }
44770
44771
44772 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44773 PyObject *resultobj;
44774 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44775 int result;
44776 PyObject * obj0 = 0 ;
44777 char *kwnames[] = {
44778 (char *) "self", NULL
44779 };
44780
44781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44783 if (SWIG_arg_fail(1)) SWIG_fail;
44784 {
44785 PyThreadState* __tstate = wxPyBeginAllowThreads();
44786 result = (int)(arg1)->GetMargin();
44787
44788 wxPyEndAllowThreads(__tstate);
44789 if (PyErr_Occurred()) SWIG_fail;
44790 }
44791 {
44792 resultobj = SWIG_From_int((int)(result));
44793 }
44794 return resultobj;
44795 fail:
44796 return NULL;
44797 }
44798
44799
44800 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44801 PyObject *resultobj;
44802 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44803 int arg2 ;
44804 PyObject * obj0 = 0 ;
44805 PyObject * obj1 = 0 ;
44806 char *kwnames[] = {
44807 (char *) "self",(char *) "m", NULL
44808 };
44809
44810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44812 if (SWIG_arg_fail(1)) SWIG_fail;
44813 {
44814 arg2 = (int)(SWIG_As_int(obj1));
44815 if (SWIG_arg_fail(2)) SWIG_fail;
44816 }
44817 {
44818 PyThreadState* __tstate = wxPyBeginAllowThreads();
44819 (arg1)->SetMargin(arg2);
44820
44821 wxPyEndAllowThreads(__tstate);
44822 if (PyErr_Occurred()) SWIG_fail;
44823 }
44824 Py_INCREF(Py_None); resultobj = Py_None;
44825 return resultobj;
44826 fail:
44827 return NULL;
44828 }
44829
44830
44831 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44832 PyObject *resultobj;
44833 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44834 int result;
44835 PyObject * obj0 = 0 ;
44836 char *kwnames[] = {
44837 (char *) "self", NULL
44838 };
44839
44840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44842 if (SWIG_arg_fail(1)) SWIG_fail;
44843 {
44844 PyThreadState* __tstate = wxPyBeginAllowThreads();
44845 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44846
44847 wxPyEndAllowThreads(__tstate);
44848 if (PyErr_Occurred()) SWIG_fail;
44849 }
44850 {
44851 resultobj = SWIG_From_int((int)(result));
44852 }
44853 return resultobj;
44854 fail:
44855 return NULL;
44856 }
44857
44858
44859 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44860 PyObject *resultobj;
44861 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44862 int result;
44863 PyObject * obj0 = 0 ;
44864 char *kwnames[] = {
44865 (char *) "self", NULL
44866 };
44867
44868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44870 if (SWIG_arg_fail(1)) SWIG_fail;
44871 {
44872 PyThreadState* __tstate = wxPyBeginAllowThreads();
44873 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44874
44875 wxPyEndAllowThreads(__tstate);
44876 if (PyErr_Occurred()) SWIG_fail;
44877 }
44878 {
44879 resultobj = SWIG_From_int((int)(result));
44880 }
44881 return resultobj;
44882 fail:
44883 return NULL;
44884 }
44885
44886
44887 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44888 PyObject *resultobj;
44889 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44890 int result;
44891 PyObject * obj0 = 0 ;
44892 char *kwnames[] = {
44893 (char *) "self", NULL
44894 };
44895
44896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44898 if (SWIG_arg_fail(1)) SWIG_fail;
44899 {
44900 PyThreadState* __tstate = wxPyBeginAllowThreads();
44901 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44902
44903 wxPyEndAllowThreads(__tstate);
44904 if (PyErr_Occurred()) SWIG_fail;
44905 }
44906 {
44907 resultobj = SWIG_From_int((int)(result));
44908 }
44909 return resultobj;
44910 fail:
44911 return NULL;
44912 }
44913
44914
44915 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44916 PyObject *resultobj;
44917 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44918 bool result;
44919 PyObject * obj0 = 0 ;
44920 char *kwnames[] = {
44921 (char *) "self", NULL
44922 };
44923
44924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44926 if (SWIG_arg_fail(1)) SWIG_fail;
44927 {
44928 PyThreadState* __tstate = wxPyBeginAllowThreads();
44929 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44930
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 {
44935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44936 }
44937 return resultobj;
44938 fail:
44939 return NULL;
44940 }
44941
44942
44943 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44944 PyObject *resultobj;
44945 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44946 bool arg2 ;
44947 PyObject * obj0 = 0 ;
44948 PyObject * obj1 = 0 ;
44949 char *kwnames[] = {
44950 (char *) "self",(char *) "d", NULL
44951 };
44952
44953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44955 if (SWIG_arg_fail(1)) SWIG_fail;
44956 {
44957 arg2 = (bool)(SWIG_As_bool(obj1));
44958 if (SWIG_arg_fail(2)) SWIG_fail;
44959 }
44960 {
44961 PyThreadState* __tstate = wxPyBeginAllowThreads();
44962 (arg1)->SetDone(arg2);
44963
44964 wxPyEndAllowThreads(__tstate);
44965 if (PyErr_Occurred()) SWIG_fail;
44966 }
44967 Py_INCREF(Py_None); resultobj = Py_None;
44968 return resultobj;
44969 fail:
44970 return NULL;
44971 }
44972
44973
44974 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44975 PyObject *resultobj;
44976 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44977 wxRelationship result;
44978 PyObject * obj0 = 0 ;
44979 char *kwnames[] = {
44980 (char *) "self", NULL
44981 };
44982
44983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44985 if (SWIG_arg_fail(1)) SWIG_fail;
44986 {
44987 PyThreadState* __tstate = wxPyBeginAllowThreads();
44988 result = (wxRelationship)(arg1)->GetRelationship();
44989
44990 wxPyEndAllowThreads(__tstate);
44991 if (PyErr_Occurred()) SWIG_fail;
44992 }
44993 resultobj = SWIG_From_int((result));
44994 return resultobj;
44995 fail:
44996 return NULL;
44997 }
44998
44999
45000 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45001 PyObject *resultobj;
45002 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45003 wxRelationship arg2 ;
45004 PyObject * obj0 = 0 ;
45005 PyObject * obj1 = 0 ;
45006 char *kwnames[] = {
45007 (char *) "self",(char *) "r", NULL
45008 };
45009
45010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45012 if (SWIG_arg_fail(1)) SWIG_fail;
45013 {
45014 arg2 = (wxRelationship)(SWIG_As_int(obj1));
45015 if (SWIG_arg_fail(2)) SWIG_fail;
45016 }
45017 {
45018 PyThreadState* __tstate = wxPyBeginAllowThreads();
45019 (arg1)->SetRelationship((wxRelationship )arg2);
45020
45021 wxPyEndAllowThreads(__tstate);
45022 if (PyErr_Occurred()) SWIG_fail;
45023 }
45024 Py_INCREF(Py_None); resultobj = Py_None;
45025 return resultobj;
45026 fail:
45027 return NULL;
45028 }
45029
45030
45031 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45032 PyObject *resultobj;
45033 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45034 wxWindow *arg2 = (wxWindow *) 0 ;
45035 bool result;
45036 PyObject * obj0 = 0 ;
45037 PyObject * obj1 = 0 ;
45038 char *kwnames[] = {
45039 (char *) "self",(char *) "otherW", NULL
45040 };
45041
45042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45044 if (SWIG_arg_fail(1)) SWIG_fail;
45045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45046 if (SWIG_arg_fail(2)) SWIG_fail;
45047 {
45048 PyThreadState* __tstate = wxPyBeginAllowThreads();
45049 result = (bool)(arg1)->ResetIfWin(arg2);
45050
45051 wxPyEndAllowThreads(__tstate);
45052 if (PyErr_Occurred()) SWIG_fail;
45053 }
45054 {
45055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45056 }
45057 return resultobj;
45058 fail:
45059 return NULL;
45060 }
45061
45062
45063 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45064 PyObject *resultobj;
45065 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45066 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45067 wxWindow *arg3 = (wxWindow *) 0 ;
45068 bool result;
45069 PyObject * obj0 = 0 ;
45070 PyObject * obj1 = 0 ;
45071 PyObject * obj2 = 0 ;
45072 char *kwnames[] = {
45073 (char *) "self",(char *) "constraints",(char *) "win", NULL
45074 };
45075
45076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45078 if (SWIG_arg_fail(1)) SWIG_fail;
45079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45080 if (SWIG_arg_fail(2)) SWIG_fail;
45081 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45082 if (SWIG_arg_fail(3)) SWIG_fail;
45083 {
45084 PyThreadState* __tstate = wxPyBeginAllowThreads();
45085 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45086
45087 wxPyEndAllowThreads(__tstate);
45088 if (PyErr_Occurred()) SWIG_fail;
45089 }
45090 {
45091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45092 }
45093 return resultobj;
45094 fail:
45095 return NULL;
45096 }
45097
45098
45099 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45100 PyObject *resultobj;
45101 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45102 wxEdge arg2 ;
45103 wxWindow *arg3 = (wxWindow *) 0 ;
45104 wxWindow *arg4 = (wxWindow *) 0 ;
45105 int result;
45106 PyObject * obj0 = 0 ;
45107 PyObject * obj1 = 0 ;
45108 PyObject * obj2 = 0 ;
45109 PyObject * obj3 = 0 ;
45110 char *kwnames[] = {
45111 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45112 };
45113
45114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45116 if (SWIG_arg_fail(1)) SWIG_fail;
45117 {
45118 arg2 = (wxEdge)(SWIG_As_int(obj1));
45119 if (SWIG_arg_fail(2)) SWIG_fail;
45120 }
45121 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45122 if (SWIG_arg_fail(3)) SWIG_fail;
45123 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45124 if (SWIG_arg_fail(4)) SWIG_fail;
45125 {
45126 PyThreadState* __tstate = wxPyBeginAllowThreads();
45127 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45128
45129 wxPyEndAllowThreads(__tstate);
45130 if (PyErr_Occurred()) SWIG_fail;
45131 }
45132 {
45133 resultobj = SWIG_From_int((int)(result));
45134 }
45135 return resultobj;
45136 fail:
45137 return NULL;
45138 }
45139
45140
45141 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45142 PyObject *obj;
45143 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45144 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45145 Py_INCREF(obj);
45146 return Py_BuildValue((char *)"");
45147 }
45148 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45149 PyObject *resultobj;
45150 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45151 wxIndividualLayoutConstraint *result;
45152 PyObject * obj0 = 0 ;
45153 char *kwnames[] = {
45154 (char *) "self", NULL
45155 };
45156
45157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45159 if (SWIG_arg_fail(1)) SWIG_fail;
45160 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45161
45162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45163 return resultobj;
45164 fail:
45165 return NULL;
45166 }
45167
45168
45169 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45170 PyObject *resultobj;
45171 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45172 wxIndividualLayoutConstraint *result;
45173 PyObject * obj0 = 0 ;
45174 char *kwnames[] = {
45175 (char *) "self", NULL
45176 };
45177
45178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45180 if (SWIG_arg_fail(1)) SWIG_fail;
45181 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45182
45183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45184 return resultobj;
45185 fail:
45186 return NULL;
45187 }
45188
45189
45190 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45191 PyObject *resultobj;
45192 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45193 wxIndividualLayoutConstraint *result;
45194 PyObject * obj0 = 0 ;
45195 char *kwnames[] = {
45196 (char *) "self", NULL
45197 };
45198
45199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45201 if (SWIG_arg_fail(1)) SWIG_fail;
45202 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45203
45204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45205 return resultobj;
45206 fail:
45207 return NULL;
45208 }
45209
45210
45211 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45212 PyObject *resultobj;
45213 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45214 wxIndividualLayoutConstraint *result;
45215 PyObject * obj0 = 0 ;
45216 char *kwnames[] = {
45217 (char *) "self", NULL
45218 };
45219
45220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45222 if (SWIG_arg_fail(1)) SWIG_fail;
45223 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45224
45225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45226 return resultobj;
45227 fail:
45228 return NULL;
45229 }
45230
45231
45232 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45233 PyObject *resultobj;
45234 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45235 wxIndividualLayoutConstraint *result;
45236 PyObject * obj0 = 0 ;
45237 char *kwnames[] = {
45238 (char *) "self", NULL
45239 };
45240
45241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45243 if (SWIG_arg_fail(1)) SWIG_fail;
45244 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45245
45246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45247 return resultobj;
45248 fail:
45249 return NULL;
45250 }
45251
45252
45253 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45254 PyObject *resultobj;
45255 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45256 wxIndividualLayoutConstraint *result;
45257 PyObject * obj0 = 0 ;
45258 char *kwnames[] = {
45259 (char *) "self", NULL
45260 };
45261
45262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45264 if (SWIG_arg_fail(1)) SWIG_fail;
45265 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45266
45267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45268 return resultobj;
45269 fail:
45270 return NULL;
45271 }
45272
45273
45274 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45275 PyObject *resultobj;
45276 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45277 wxIndividualLayoutConstraint *result;
45278 PyObject * obj0 = 0 ;
45279 char *kwnames[] = {
45280 (char *) "self", NULL
45281 };
45282
45283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45285 if (SWIG_arg_fail(1)) SWIG_fail;
45286 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45287
45288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45289 return resultobj;
45290 fail:
45291 return NULL;
45292 }
45293
45294
45295 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45296 PyObject *resultobj;
45297 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45298 wxIndividualLayoutConstraint *result;
45299 PyObject * obj0 = 0 ;
45300 char *kwnames[] = {
45301 (char *) "self", NULL
45302 };
45303
45304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45306 if (SWIG_arg_fail(1)) SWIG_fail;
45307 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45308
45309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45310 return resultobj;
45311 fail:
45312 return NULL;
45313 }
45314
45315
45316 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45317 PyObject *resultobj;
45318 wxLayoutConstraints *result;
45319 char *kwnames[] = {
45320 NULL
45321 };
45322
45323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45324 {
45325 PyThreadState* __tstate = wxPyBeginAllowThreads();
45326 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45327
45328 wxPyEndAllowThreads(__tstate);
45329 if (PyErr_Occurred()) SWIG_fail;
45330 }
45331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45332 return resultobj;
45333 fail:
45334 return NULL;
45335 }
45336
45337
45338 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45339 PyObject *resultobj;
45340 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45341 wxWindow *arg2 = (wxWindow *) 0 ;
45342 int *arg3 = (int *) 0 ;
45343 bool result;
45344 int temp3 ;
45345 int res3 = 0 ;
45346 PyObject * obj0 = 0 ;
45347 PyObject * obj1 = 0 ;
45348 char *kwnames[] = {
45349 (char *) "self",(char *) "win", NULL
45350 };
45351
45352 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45355 if (SWIG_arg_fail(1)) SWIG_fail;
45356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45357 if (SWIG_arg_fail(2)) SWIG_fail;
45358 {
45359 PyThreadState* __tstate = wxPyBeginAllowThreads();
45360 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45361
45362 wxPyEndAllowThreads(__tstate);
45363 if (PyErr_Occurred()) SWIG_fail;
45364 }
45365 {
45366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45367 }
45368 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45369 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45370 return resultobj;
45371 fail:
45372 return NULL;
45373 }
45374
45375
45376 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45377 PyObject *resultobj;
45378 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45379 bool result;
45380 PyObject * obj0 = 0 ;
45381 char *kwnames[] = {
45382 (char *) "self", NULL
45383 };
45384
45385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45387 if (SWIG_arg_fail(1)) SWIG_fail;
45388 {
45389 PyThreadState* __tstate = wxPyBeginAllowThreads();
45390 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45391
45392 wxPyEndAllowThreads(__tstate);
45393 if (PyErr_Occurred()) SWIG_fail;
45394 }
45395 {
45396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45397 }
45398 return resultobj;
45399 fail:
45400 return NULL;
45401 }
45402
45403
45404 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45405 PyObject *obj;
45406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45407 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45408 Py_INCREF(obj);
45409 return Py_BuildValue((char *)"");
45410 }
45411 static PyMethodDef SwigMethods[] = {
45412 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45413 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45414 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45417 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45438 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45451 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45466 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45520 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45548 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45567 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45569 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45577 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45578 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45590 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45602 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45606 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45612 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45622 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45632 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45639 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45719 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45721 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45723 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45725 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45727 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45729 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45731 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45733 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45735 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45737 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45739 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45741 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45743 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45757 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45775 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45778 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45781 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45793 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45798 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45804 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45810 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45873 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45880 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45916 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45926 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45932 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45934 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45936 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45939 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45943 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45946 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45949 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45951 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45956 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45964 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45968 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45971 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45973 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45977 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45994 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45996 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45999 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46001 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46005 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46009 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46020 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46023 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46026 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46030 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46037 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46042 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46047 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46051 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46096 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46116 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46123 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46127 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46137 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46310 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46351 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46366 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46369 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46424 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46453 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46497 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46505 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46524 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46525 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46562 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46592 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46595 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46599 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46602 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46612 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46624 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46636 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46646 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46656 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46670 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46677 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46678 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46679 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46680 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46681 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46686 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46713 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46725 { NULL, NULL, 0, NULL }
46726 };
46727
46728
46729 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46730
46731 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46732 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46733 }
46734 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46735 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46736 }
46737 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46738 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46739 }
46740 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46741 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46742 }
46743 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46744 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46745 }
46746 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46747 return (void *)((wxSizer *) ((wxGridSizer *) x));
46748 }
46749 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46750 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46751 }
46752 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46753 return (void *)((wxSizer *) ((wxPySizer *) x));
46754 }
46755 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46756 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46757 }
46758 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46759 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46760 }
46761 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46762 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46763 }
46764 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46765 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46766 }
46767 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46768 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46769 }
46770 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46771 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46772 }
46773 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46774 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46775 }
46776 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46777 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46778 }
46779 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46780 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46781 }
46782 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46783 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46784 }
46785 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46786 return (void *)((wxEvent *) ((wxPyEvent *) x));
46787 }
46788 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46789 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46790 }
46791 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46792 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46793 }
46794 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46795 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46796 }
46797 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46798 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46799 }
46800 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46801 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46802 }
46803 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46804 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46805 }
46806 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46807 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46808 }
46809 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46810 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46811 }
46812 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46813 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46814 }
46815 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46816 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46817 }
46818 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46819 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46820 }
46821 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46822 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46823 }
46824 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46825 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46826 }
46827 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46828 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46829 }
46830 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46831 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46832 }
46833 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46834 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46835 }
46836 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46837 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46838 }
46839 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46840 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46841 }
46842 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46843 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46844 }
46845 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46846 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46847 }
46848 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46849 return (void *)((wxEvent *) ((wxShowEvent *) x));
46850 }
46851 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46852 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46853 }
46854 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46855 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46856 }
46857 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46858 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46859 }
46860 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46861 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46862 }
46863 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46864 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46865 }
46866 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46867 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46868 }
46869 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46870 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46871 }
46872 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46873 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46874 }
46875 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46876 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46877 }
46878 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46879 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46880 }
46881 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46882 return (void *)((wxControl *) ((wxControlWithItems *) x));
46883 }
46884 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46885 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46886 }
46887 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46888 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46889 }
46890 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46891 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46892 }
46893 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46894 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46895 }
46896 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46897 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46898 }
46899 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46900 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46901 }
46902 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46903 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46904 }
46905 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46906 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46907 }
46908 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46909 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46910 }
46911 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46912 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46913 }
46914 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46915 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46916 }
46917 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46918 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46919 }
46920 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46921 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46922 }
46923 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46924 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46925 }
46926 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46927 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46928 }
46929 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46930 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46931 }
46932 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46933 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46934 }
46935 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46936 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46937 }
46938 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46939 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46940 }
46941 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46942 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46943 }
46944 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46945 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46946 }
46947 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46948 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46949 }
46950 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46951 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46952 }
46953 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46954 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46955 }
46956 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46957 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46958 }
46959 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46960 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46961 }
46962 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46963 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46964 }
46965 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46966 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46967 }
46968 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46969 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46970 }
46971 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46972 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46973 }
46974 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46975 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46976 }
46977 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46978 return (void *)((wxObject *) ((wxSizerItem *) x));
46979 }
46980 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46981 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46982 }
46983 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46984 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46985 }
46986 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46987 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46988 }
46989 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46990 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46991 }
46992 static void *_p_wxSizerTo_p_wxObject(void *x) {
46993 return (void *)((wxObject *) ((wxSizer *) x));
46994 }
46995 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46996 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46997 }
46998 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46999 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47000 }
47001 static void *_p_wxEventTo_p_wxObject(void *x) {
47002 return (void *)((wxObject *) ((wxEvent *) x));
47003 }
47004 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47005 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47006 }
47007 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47008 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47009 }
47010 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47011 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47012 }
47013 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47014 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47015 }
47016 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47017 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47018 }
47019 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47020 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47021 }
47022 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47023 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47024 }
47025 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47026 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47027 }
47028 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47029 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47030 }
47031 static void *_p_wxControlTo_p_wxObject(void *x) {
47032 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47033 }
47034 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47035 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47036 }
47037 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47038 return (void *)((wxObject *) ((wxFSFile *) x));
47039 }
47040 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47041 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47042 }
47043 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47044 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47045 }
47046 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47047 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47048 }
47049 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47050 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47051 }
47052 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47053 return (void *)((wxObject *) ((wxMenuItem *) x));
47054 }
47055 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47056 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47057 }
47058 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47059 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47060 }
47061 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47062 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47063 }
47064 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47065 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47066 }
47067 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47068 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47069 }
47070 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47071 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47072 }
47073 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47074 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47075 }
47076 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47077 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47078 }
47079 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47080 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47081 }
47082 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47083 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47084 }
47085 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47086 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47087 }
47088 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47089 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47090 }
47091 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47092 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47093 }
47094 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47095 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47096 }
47097 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47098 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47099 }
47100 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47101 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47102 }
47103 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47104 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47105 }
47106 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47107 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47108 }
47109 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47110 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47111 }
47112 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47113 return (void *)((wxObject *) ((wxImageHandler *) x));
47114 }
47115 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47116 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47117 }
47118 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47119 return (void *)((wxObject *) ((wxEvtHandler *) x));
47120 }
47121 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47122 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47123 }
47124 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47125 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47126 }
47127 static void *_p_wxImageTo_p_wxObject(void *x) {
47128 return (void *)((wxObject *) ((wxImage *) x));
47129 }
47130 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47131 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47132 }
47133 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47134 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47135 }
47136 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47137 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47138 }
47139 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47140 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47141 }
47142 static void *_p_wxWindowTo_p_wxObject(void *x) {
47143 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47144 }
47145 static void *_p_wxMenuTo_p_wxObject(void *x) {
47146 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47147 }
47148 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47149 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47150 }
47151 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47152 return (void *)((wxObject *) ((wxFileSystem *) x));
47153 }
47154 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47155 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47156 }
47157 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47158 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47159 }
47160 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47161 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47162 }
47163 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47164 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47165 }
47166 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47167 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47168 }
47169 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47170 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47171 }
47172 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47173 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47174 }
47175 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47176 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47177 }
47178 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47179 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47180 }
47181 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47182 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47183 }
47184 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47185 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47186 }
47187 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47188 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47189 }
47190 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47191 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47192 }
47193 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47194 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47195 }
47196 static void *_p_wxControlTo_p_wxWindow(void *x) {
47197 return (void *)((wxWindow *) ((wxControl *) x));
47198 }
47199 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47200 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47201 }
47202 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47203 return (void *)((wxWindow *) ((wxMenuBar *) x));
47204 }
47205 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47206 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47207 }
47208 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47209 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47210 }
47211 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47212 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47213 }
47214 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47215 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47216 }
47217 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47218 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47219 }
47220 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47221 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47222 }
47223 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47224 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47225 }
47226 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47227 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47228 }
47229 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47230 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47231 }
47232 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47233 return (void *)((wxValidator *) ((wxPyValidator *) x));
47234 }
47235 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}};
47236 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}};
47237 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}};
47238 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}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245 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}};
47246 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}};
47247 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}};
47248 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}};
47249 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47250 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}};
47251 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}};
47252 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}};
47253 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}};
47254 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}};
47255 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}};
47256 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}};
47257 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}};
47258 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}};
47259 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}};
47260 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}};
47261 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}};
47262 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}};
47263 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}};
47264 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}};
47265 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}};
47266 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}};
47267 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}};
47268 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}};
47269 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}};
47270 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}};
47271 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}};
47272 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}};
47273 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}};
47274 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}};
47275 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}};
47276 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}};
47277 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}};
47278 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}};
47279 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}};
47280 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}};
47281 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}};
47282 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}};
47283 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}};
47284 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}};
47285 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}};
47286 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}};
47287 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}};
47288 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}};
47289 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}};
47290 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}};
47291 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}};
47292 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}};
47293 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}};
47294 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}};
47295 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}};
47296 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}};
47297 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}};
47298 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}};
47299 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}};
47300 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}};
47301 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}};
47302 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}};
47303 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}};
47304 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}};
47305 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}};
47306 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}};
47307 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}};
47308 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}};
47309 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}};
47310 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}};
47311 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}};
47312 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}};
47313 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}};
47314 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}};
47315 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}};
47316 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}};
47317 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}};
47318 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}};
47319 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}};
47320 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}};
47321 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}};
47322 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}};
47323 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}};
47324 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}};
47325 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}};
47326 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}};
47327 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}};
47328 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}};
47329 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}};
47330 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}};
47331 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}};
47332 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}};
47333 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}};
47334 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}};
47335 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}};
47336 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}};
47337 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}};
47338 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}};
47339 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}};
47340 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}};
47341 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}};
47342 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}};
47343 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}};
47344 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}};
47345 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}};
47346 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}};
47347 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}};
47348 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}};
47349 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}};
47350 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}};
47351 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}};
47352 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}};
47353 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}};
47354 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}};
47355 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}};
47356 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}};
47357 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}};
47358 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}};
47359 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}};
47360 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}};
47361 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}};
47362 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}};
47363
47364 static swig_type_info *swig_types_initial[] = {
47365 _swigt__p_wxLayoutConstraints,
47366 _swigt__p_wxRealPoint,
47367 _swigt__p_wxSizerItem,
47368 _swigt__p_wxGBSizerItem,
47369 _swigt__p_wxScrollEvent,
47370 _swigt__p_wxEventLoop,
47371 _swigt__p_wxIndividualLayoutConstraint,
47372 _swigt__p_wxSizer,
47373 _swigt__p_wxBoxSizer,
47374 _swigt__p_wxStaticBoxSizer,
47375 _swigt__p_wxGridBagSizer,
47376 _swigt__p_wxAcceleratorEntry,
47377 _swigt__p_wxUpdateUIEvent,
47378 _swigt__p_wxEvent,
47379 _swigt__p_buffer,
47380 _swigt__p_wxMenu,
47381 _swigt__p_wxGridSizer,
47382 _swigt__p_wxFlexGridSizer,
47383 _swigt__p_wxInitDialogEvent,
47384 _swigt__p_wxItemContainer,
47385 _swigt__p_wxNcPaintEvent,
47386 _swigt__p_wxPaintEvent,
47387 _swigt__p_wxSysColourChangedEvent,
47388 _swigt__p_wxMouseCaptureChangedEvent,
47389 _swigt__p_wxDisplayChangedEvent,
47390 _swigt__p_wxPaletteChangedEvent,
47391 _swigt__p_wxControl,
47392 _swigt__p_wxFont,
47393 _swigt__p_wxMenuBarBase,
47394 _swigt__p_wxSetCursorEvent,
47395 _swigt__p_wxFSFile,
47396 _swigt__p_wxCaret,
47397 _swigt__ptrdiff_t,
47398 _swigt__std__ptrdiff_t,
47399 _swigt__p_wxRegion,
47400 _swigt__p_wxPoint2D,
47401 _swigt__p_int,
47402 _swigt__p_wxSize,
47403 _swigt__p_wxDC,
47404 _swigt__p_wxPySizer,
47405 _swigt__p_wxVisualAttributes,
47406 _swigt__p_wxNotifyEvent,
47407 _swigt__p_wxPyEvent,
47408 _swigt__p_wxPropagationDisabler,
47409 _swigt__p_form_ops_t,
47410 _swigt__p_wxAppTraits,
47411 _swigt__p_wxArrayString,
47412 _swigt__p_wxShowEvent,
47413 _swigt__p_wxToolTip,
47414 _swigt__p_wxMoveEvent,
47415 _swigt__p_wxSizeEvent,
47416 _swigt__p_wxActivateEvent,
47417 _swigt__p_wxIconizeEvent,
47418 _swigt__p_wxMaximizeEvent,
47419 _swigt__p_wxQueryNewPaletteEvent,
47420 _swigt__p_wxWindowCreateEvent,
47421 _swigt__p_wxIdleEvent,
47422 _swigt__p_wxDateEvent,
47423 _swigt__p_wxMenuItem,
47424 _swigt__p_wxStaticBox,
47425 _swigt__p_long,
47426 _swigt__p_wxDuplexMode,
47427 _swigt__p_wxTIFFHandler,
47428 _swigt__p_wxXPMHandler,
47429 _swigt__p_wxPNMHandler,
47430 _swigt__p_wxJPEGHandler,
47431 _swigt__p_wxPCXHandler,
47432 _swigt__p_wxGIFHandler,
47433 _swigt__p_wxPNGHandler,
47434 _swigt__p_wxANIHandler,
47435 _swigt__p_wxMemoryFSHandler,
47436 _swigt__p_wxZipFSHandler,
47437 _swigt__p_wxInternetFSHandler,
47438 _swigt__p_wxPyFileSystemHandler,
47439 _swigt__p_wxEvtHandler,
47440 _swigt__p_wxCURHandler,
47441 _swigt__p_wxICOHandler,
47442 _swigt__p_wxBMPHandler,
47443 _swigt__p_wxImageHandler,
47444 _swigt__p_wxFileSystemHandler,
47445 _swigt__p_wxRect,
47446 _swigt__p_wxButton,
47447 _swigt__p_wxGBSpan,
47448 _swigt__p_wxPropagateOnce,
47449 _swigt__p_wxAcceleratorTable,
47450 _swigt__p_wxStdDialogButtonSizer,
47451 _swigt__p_char,
47452 _swigt__p_wxGBPosition,
47453 _swigt__p_wxImage,
47454 _swigt__p_wxFrame,
47455 _swigt__p_wxScrollWinEvent,
47456 _swigt__p_wxPaperSize,
47457 _swigt__p_wxImageHistogram,
47458 _swigt__p_wxPoint,
47459 _swigt__p_wxCursor,
47460 _swigt__p_wxObject,
47461 _swigt__p_wxInputStream,
47462 _swigt__p_wxOutputStream,
47463 _swigt__p_wxPyInputStream,
47464 _swigt__p_wxDateTime,
47465 _swigt__p_wxKeyEvent,
47466 _swigt__p_wxNavigationKeyEvent,
47467 _swigt__p_wxWindowDestroyEvent,
47468 _swigt__p_unsigned_long,
47469 _swigt__p_wxWindow,
47470 _swigt__p_wxMenuBar,
47471 _swigt__p_wxFileSystem,
47472 _swigt__p_wxBitmap,
47473 _swigt__unsigned_int,
47474 _swigt__p_unsigned_int,
47475 _swigt__p_wxMenuEvent,
47476 _swigt__p_wxContextMenuEvent,
47477 _swigt__p_unsigned_char,
47478 _swigt__p_wxEraseEvent,
47479 _swigt__p_wxMouseEvent,
47480 _swigt__p_wxCloseEvent,
47481 _swigt__p_wxPyApp,
47482 _swigt__p_wxCommandEvent,
47483 _swigt__p_wxPyCommandEvent,
47484 _swigt__p_wxPyDropTarget,
47485 _swigt__p_wxQuantize,
47486 _swigt__p_wxFocusEvent,
47487 _swigt__p_wxChildFocusEvent,
47488 _swigt__p_wxDropFilesEvent,
47489 _swigt__p_wxControlWithItems,
47490 _swigt__p_wxColour,
47491 _swigt__p_wxValidator,
47492 _swigt__p_wxPyValidator,
47493 0
47494 };
47495
47496
47497 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47498
47499 static swig_const_info swig_const_table[] = {
47500 {0, 0, 0, 0.0, 0, 0}};
47501
47502 #ifdef __cplusplus
47503 }
47504 #endif
47505
47506
47507 #ifdef __cplusplus
47508 extern "C" {
47509 #endif
47510
47511 /* Python-specific SWIG API */
47512 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47513 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47514 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47515
47516 /* -----------------------------------------------------------------------------
47517 * global variable support code.
47518 * ----------------------------------------------------------------------------- */
47519
47520 typedef struct swig_globalvar {
47521 char *name; /* Name of global variable */
47522 PyObject *(*get_attr)(); /* Return the current value */
47523 int (*set_attr)(PyObject *); /* Set the value */
47524 struct swig_globalvar *next;
47525 } swig_globalvar;
47526
47527 typedef struct swig_varlinkobject {
47528 PyObject_HEAD
47529 swig_globalvar *vars;
47530 } swig_varlinkobject;
47531
47532 static PyObject *
47533 swig_varlink_repr(swig_varlinkobject *v) {
47534 v = v;
47535 return PyString_FromString("<Swig global variables>");
47536 }
47537
47538 static int
47539 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47540 swig_globalvar *var;
47541 flags = flags;
47542 fprintf(fp,"Swig global variables { ");
47543 for (var = v->vars; var; var=var->next) {
47544 fprintf(fp,"%s", var->name);
47545 if (var->next) fprintf(fp,", ");
47546 }
47547 fprintf(fp," }\n");
47548 return 0;
47549 }
47550
47551 static PyObject *
47552 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47553 swig_globalvar *var = v->vars;
47554 while (var) {
47555 if (strcmp(var->name,n) == 0) {
47556 return (*var->get_attr)();
47557 }
47558 var = var->next;
47559 }
47560 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47561 return NULL;
47562 }
47563
47564 static int
47565 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47566 swig_globalvar *var = v->vars;
47567 while (var) {
47568 if (strcmp(var->name,n) == 0) {
47569 return (*var->set_attr)(p);
47570 }
47571 var = var->next;
47572 }
47573 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47574 return 1;
47575 }
47576
47577 static PyTypeObject varlinktype = {
47578 PyObject_HEAD_INIT(0)
47579 0, /* Number of items in variable part (ob_size) */
47580 (char *)"swigvarlink", /* Type name (tp_name) */
47581 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47582 0, /* Itemsize (tp_itemsize) */
47583 0, /* Deallocator (tp_dealloc) */
47584 (printfunc) swig_varlink_print, /* Print (tp_print) */
47585 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47586 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47587 0, /* tp_compare */
47588 (reprfunc) swig_varlink_repr, /* tp_repr */
47589 0, /* tp_as_number */
47590 0, /* tp_as_sequence */
47591 0, /* tp_as_mapping */
47592 0, /* tp_hash */
47593 0, /* tp_call */
47594 0, /* tp_str */
47595 0, /* tp_getattro */
47596 0, /* tp_setattro */
47597 0, /* tp_as_buffer */
47598 0, /* tp_flags */
47599 0, /* tp_doc */
47600 #if PY_VERSION_HEX >= 0x02000000
47601 0, /* tp_traverse */
47602 0, /* tp_clear */
47603 #endif
47604 #if PY_VERSION_HEX >= 0x02010000
47605 0, /* tp_richcompare */
47606 0, /* tp_weaklistoffset */
47607 #endif
47608 #if PY_VERSION_HEX >= 0x02020000
47609 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47610 #endif
47611 #if PY_VERSION_HEX >= 0x02030000
47612 0, /* tp_del */
47613 #endif
47614 #ifdef COUNT_ALLOCS
47615 0,0,0,0 /* tp_alloc -> tp_next */
47616 #endif
47617 };
47618
47619 /* Create a variable linking object for use later */
47620 static PyObject *
47621 SWIG_Python_newvarlink(void) {
47622 swig_varlinkobject *result = 0;
47623 result = PyMem_NEW(swig_varlinkobject,1);
47624 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47625 result->ob_type = &varlinktype;
47626 result->vars = 0;
47627 result->ob_refcnt = 0;
47628 Py_XINCREF((PyObject *) result);
47629 return ((PyObject*) result);
47630 }
47631
47632 static void
47633 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47634 swig_varlinkobject *v;
47635 swig_globalvar *gv;
47636 v= (swig_varlinkobject *) p;
47637 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47638 gv->name = (char *) malloc(strlen(name)+1);
47639 strcpy(gv->name,name);
47640 gv->get_attr = get_attr;
47641 gv->set_attr = set_attr;
47642 gv->next = v->vars;
47643 v->vars = gv;
47644 }
47645
47646 /* -----------------------------------------------------------------------------
47647 * constants/methods manipulation
47648 * ----------------------------------------------------------------------------- */
47649
47650 /* Install Constants */
47651 static void
47652 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47653 PyObject *obj = 0;
47654 size_t i;
47655 for (i = 0; constants[i].type; i++) {
47656 switch(constants[i].type) {
47657 case SWIG_PY_INT:
47658 obj = PyInt_FromLong(constants[i].lvalue);
47659 break;
47660 case SWIG_PY_FLOAT:
47661 obj = PyFloat_FromDouble(constants[i].dvalue);
47662 break;
47663 case SWIG_PY_STRING:
47664 if (constants[i].pvalue) {
47665 obj = PyString_FromString((char *) constants[i].pvalue);
47666 } else {
47667 Py_INCREF(Py_None);
47668 obj = Py_None;
47669 }
47670 break;
47671 case SWIG_PY_POINTER:
47672 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47673 break;
47674 case SWIG_PY_BINARY:
47675 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47676 break;
47677 default:
47678 obj = 0;
47679 break;
47680 }
47681 if (obj) {
47682 PyDict_SetItemString(d,constants[i].name,obj);
47683 Py_DECREF(obj);
47684 }
47685 }
47686 }
47687
47688 /* -----------------------------------------------------------------------------*/
47689 /* Fix SwigMethods to carry the callback ptrs when needed */
47690 /* -----------------------------------------------------------------------------*/
47691
47692 static void
47693 SWIG_Python_FixMethods(PyMethodDef *methods,
47694 swig_const_info *const_table,
47695 swig_type_info **types,
47696 swig_type_info **types_initial) {
47697 size_t i;
47698 for (i = 0; methods[i].ml_name; ++i) {
47699 char *c = methods[i].ml_doc;
47700 if (c && (c = strstr(c, "swig_ptr: "))) {
47701 int j;
47702 swig_const_info *ci = 0;
47703 char *name = c + 10;
47704 for (j = 0; const_table[j].type; j++) {
47705 if (strncmp(const_table[j].name, name,
47706 strlen(const_table[j].name)) == 0) {
47707 ci = &(const_table[j]);
47708 break;
47709 }
47710 }
47711 if (ci) {
47712 size_t shift = (ci->ptype) - types;
47713 swig_type_info *ty = types_initial[shift];
47714 size_t ldoc = (c - methods[i].ml_doc);
47715 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47716 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47717 char *buff = ndoc;
47718 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47719 strncpy(buff, methods[i].ml_doc, ldoc);
47720 buff += ldoc;
47721 strncpy(buff, "swig_ptr: ", 10);
47722 buff += 10;
47723 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47724 methods[i].ml_doc = ndoc;
47725 }
47726 }
47727 }
47728 }
47729
47730 /* -----------------------------------------------------------------------------*
47731 * Initialize type list
47732 * -----------------------------------------------------------------------------*/
47733
47734 #if PY_MAJOR_VERSION < 2
47735 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47736 is copied out of Python/modsupport.c in python version 2.3.4 */
47737 static int
47738 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47739 {
47740 PyObject *dict;
47741 if (!PyModule_Check(m)) {
47742 PyErr_SetString(PyExc_TypeError,
47743 "PyModule_AddObject() needs module as first arg");
47744 return -1;
47745 }
47746 if (!o) {
47747 PyErr_SetString(PyExc_TypeError,
47748 "PyModule_AddObject() needs non-NULL value");
47749 return -1;
47750 }
47751
47752 dict = PyModule_GetDict(m);
47753 if (dict == NULL) {
47754 /* Internal error -- modules must have a dict! */
47755 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47756 PyModule_GetName(m));
47757 return -1;
47758 }
47759 if (PyDict_SetItemString(dict, name, o))
47760 return -1;
47761 Py_DECREF(o);
47762 return 0;
47763 }
47764 #endif
47765
47766 static swig_type_info **
47767 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47768 static PyMethodDef swig_empty_runtime_method_table[] = {
47769 {
47770 NULL, NULL, 0, NULL
47771 }
47772 };/* Sentinel */
47773
47774 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47775 swig_empty_runtime_method_table);
47776 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47777 if (pointer && module) {
47778 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47779 }
47780 return type_list_handle;
47781 }
47782
47783 static swig_type_info **
47784 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47785 swig_type_info **type_pointer;
47786
47787 /* first check if module already created */
47788 type_pointer = SWIG_Python_GetTypeListHandle();
47789 if (type_pointer) {
47790 return type_pointer;
47791 } else {
47792 /* create a new module and variable */
47793 return SWIG_Python_SetTypeListHandle(type_list_handle);
47794 }
47795 }
47796
47797 #ifdef __cplusplus
47798 }
47799 #endif
47800
47801 /* -----------------------------------------------------------------------------*
47802 * Partial Init method
47803 * -----------------------------------------------------------------------------*/
47804
47805 #ifdef SWIG_LINK_RUNTIME
47806 #ifdef __cplusplus
47807 extern "C"
47808 #endif
47809 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47810 #endif
47811
47812 #ifdef __cplusplus
47813 extern "C"
47814 #endif
47815 SWIGEXPORT(void) SWIG_init(void) {
47816 static PyObject *SWIG_globals = 0;
47817 static int typeinit = 0;
47818 PyObject *m, *d;
47819 int i;
47820 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47821
47822 /* Fix SwigMethods to carry the callback ptrs when needed */
47823 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47824
47825 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47826 d = PyModule_GetDict(m);
47827
47828 if (!typeinit) {
47829 #ifdef SWIG_LINK_RUNTIME
47830 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47831 #else
47832 # ifndef SWIG_STATIC_RUNTIME
47833 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47834 # endif
47835 #endif
47836 for (i = 0; swig_types_initial[i]; i++) {
47837 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47838 }
47839 typeinit = 1;
47840 }
47841 SWIG_InstallConstants(d,swig_const_table);
47842
47843
47844 #ifndef wxPyUSE_EXPORT
47845 // Make our API structure a CObject so other modules can import it
47846 // from this module.
47847 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47848 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47849 Py_XDECREF(cobj);
47850 #endif
47851
47852 {
47853 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48856 }
48857 {
48858 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48859 }
48860 {
48861 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48862 }
48863 {
48864 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48865 }
48866 {
48867 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48868 }
48869 {
48870 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48871 }
48872 {
48873 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48874 }
48875 {
48876 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48877 }
48878 {
48879 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48880 }
48881 {
48882 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48883 }
48884 {
48885 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48886 }
48887 {
48888 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48889 }
48890 {
48891 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48892 }
48893 {
48894 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48895 }
48896 {
48897 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48898 }
48899 {
48900 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48901 }
48902 {
48903 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48904 }
48905 {
48906 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48907 }
48908 {
48909 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48910 }
48911 {
48912 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48913 }
48914 {
48915 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48922 }
48923 {
48924 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48925 }
48926 {
48927 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48928 }
48929 {
48930 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48931 }
48932 {
48933 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48934 }
48935 {
48936 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48937 }
48938 {
48939 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48940 }
48941 {
48942 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48943 }
48944 {
48945 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48946 }
48947 {
48948 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48949 }
48950 {
48951 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48952 }
48953 {
48954 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48955 }
48956 {
48957 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48964 }
48965 {
48966 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48967 }
48968 {
48969 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48970 }
48971 {
48972 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48973 }
48974 {
48975 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48976 }
48977 {
48978 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48979 }
48980 {
48981 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48982 }
48983 {
48984 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48985 }
48986 {
48987 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48988 }
48989 {
48990 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48991 }
48992 {
48993 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48994 }
48995 {
48996 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48997 }
48998 {
48999 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
49000 }
49001 {
49002 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
49003 }
49004 {
49005 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
49006 }
49007 {
49008 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
49009 }
49010 {
49011 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
49012 }
49013 {
49014 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
49015 }
49016 {
49017 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
49018 }
49019 {
49020 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
49024 }
49025 {
49026 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
49027 }
49028 {
49029 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
49030 }
49031 {
49032 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
49039 }
49040 {
49041 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
49042 }
49043 {
49044 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
49045 }
49046 {
49047 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
49054 }
49055 {
49056 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
49057 }
49058 {
49059 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
49060 }
49061 {
49062 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
49063 }
49064 {
49065 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
49066 }
49067 {
49068 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49069 }
49070 {
49071 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49072 }
49073 {
49074 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49075 }
49076 {
49077 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49078 }
49079 {
49080 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49081 }
49082 {
49083 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49084 }
49085 {
49086 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49087 }
49088 {
49089 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49090 }
49091 {
49092 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49096 }
49097 {
49098 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49099 }
49100 {
49101 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49192 }
49193 {
49194 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49231 }
49232 {
49233 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49240 }
49241 {
49242 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49339 }
49340 {
49341 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49342 }
49343 {
49344 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49345 }
49346 {
49347 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49348 }
49349 {
49350 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49408 }
49409 {
49410 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49411 }
49412 {
49413 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49414 }
49415 {
49416 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49417 }
49418 {
49419 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49420 }
49421 {
49422 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD)));
49423 }
49424 {
49425 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int((int)(wxPAPER_A6)));
49426 }
49427 {
49428 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int((int)(wxPAPER_JENV_KAKU2)));
49429 }
49430 {
49431 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int((int)(wxPAPER_JENV_KAKU3)));
49432 }
49433 {
49434 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int((int)(wxPAPER_JENV_CHOU3)));
49435 }
49436 {
49437 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int((int)(wxPAPER_JENV_CHOU4)));
49438 }
49439 {
49440 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int((int)(wxPAPER_LETTER_ROTATED)));
49441 }
49442 {
49443 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int((int)(wxPAPER_A3_ROTATED)));
49444 }
49445 {
49446 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int((int)(wxPAPER_A4_ROTATED)));
49447 }
49448 {
49449 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int((int)(wxPAPER_A5_ROTATED)));
49450 }
49451 {
49452 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B4_JIS_ROTATED)));
49453 }
49454 {
49455 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B5_JIS_ROTATED)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int((int)(wxPAPER_A6_ROTATED)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU2_ROTATED)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU3_ROTATED)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU3_ROTATED)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU4_ROTATED)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int((int)(wxPAPER_B6_JIS)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B6_JIS_ROTATED)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int((int)(wxPAPER_12X11)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int((int)(wxPAPER_JENV_YOU4)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_YOU4_ROTATED)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int((int)(wxPAPER_P16K)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int((int)(wxPAPER_P32K)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int((int)(wxPAPER_P32KBIG)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int((int)(wxPAPER_PENV_1)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int((int)(wxPAPER_PENV_2)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int((int)(wxPAPER_PENV_3)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int((int)(wxPAPER_PENV_4)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int((int)(wxPAPER_PENV_5)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int((int)(wxPAPER_PENV_6)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int((int)(wxPAPER_PENV_7)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int((int)(wxPAPER_PENV_8)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int((int)(wxPAPER_PENV_9)));
49528 }
49529 {
49530 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int((int)(wxPAPER_PENV_10)));
49531 }
49532 {
49533 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int((int)(wxPAPER_P16K_ROTATED)));
49534 }
49535 {
49536 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int((int)(wxPAPER_P32K_ROTATED)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int((int)(wxPAPER_P32KBIG_ROTATED)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_1_ROTATED)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_2_ROTATED)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_3_ROTATED)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_4_ROTATED)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_5_ROTATED)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_6_ROTATED)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_7_ROTATED)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_8_ROTATED)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_9_ROTATED)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_10_ROTATED)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49591 }
49592 {
49593 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49597 }
49598 {
49599 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49600 }
49601 {
49602 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49603 }
49604 {
49605 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49606 }
49607 {
49608 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49609 }
49610 {
49611 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49615 }
49616 {
49617 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49618 }
49619 {
49620 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49621 }
49622 {
49623 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49624 }
49625 {
49626 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49627 }
49628 {
49629 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49630 }
49631 {
49632 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49633 }
49634 {
49635 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49636 }
49637 {
49638 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49639 }
49640 {
49641 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49648 }
49649 {
49650 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49651 }
49652 {
49653 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49666 }
49667 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49668 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49669 {
49670 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49671 }
49672 {
49673 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49674 }
49675 {
49676 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49677 }
49678 {
49679 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49680 }
49681 {
49682 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49683 }
49684 {
49685 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49686 }
49687 {
49688 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49689 }
49690 {
49691 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49692 }
49693 {
49694 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49695 }
49696 {
49697 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49698 }
49699 {
49700 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49701 }
49702 {
49703 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49704 }
49705 {
49706 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49707 }
49708 {
49709 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49710 }
49711 {
49712 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49713 }
49714 {
49715 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49716 }
49717 {
49718 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49719 }
49720 {
49721 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49722 }
49723 {
49724 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49725 }
49726 {
49727 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49728 }
49729 {
49730 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49731 }
49732 {
49733 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49734 }
49735 {
49736 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49737 }
49738 {
49739 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49740 }
49741 {
49742 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49743 }
49744 {
49745 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49746 }
49747 {
49748 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49749 }
49750 {
49751 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49752 }
49753 {
49754 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49758 }
49759 {
49760 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49761 }
49762 {
49763 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49764 }
49765 {
49766 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49788 }
49789 {
49790 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49791 }
49792 {
49793 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49794 }
49795 {
49796 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49797 }
49798 {
49799 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49800 }
49801 {
49802 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49803 }
49804 {
49805 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49806 }
49807 {
49808 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49809 }
49810 {
49811 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49821 }
49822 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49823 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49824 {
49825 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49826 }
49827 {
49828 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49829 }
49830 {
49831 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49832 }
49833
49834 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49835
49836
49837 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49838
49839 {
49840 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49841 }
49842 {
49843 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49847 }
49848 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49849 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49850 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49851 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49852 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49853 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49854 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49855 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49856 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49857 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49858 {
49859 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49863 }
49864 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49865 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49866 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49867 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49868 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49869 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49870 {
49871 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49893 }
49894 {
49895 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49896 }
49897 {
49898 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49899 }
49900 {
49901 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49902 }
49903 {
49904 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49908 }
49909 {
49910 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49911 }
49912 {
49913 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49914 }
49915 {
49916 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49917 }
49918 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49919 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49920 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49921 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49922 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49923 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49924 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49925 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49926 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49927 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49928 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49929 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49930 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49931 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49932 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49933 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49934 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49935 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49936 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49937 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49938 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49939 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49940 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49941 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49942 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49943 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49944 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49945 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49946 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49947 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49948 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49949 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49950 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49951 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49952 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49953 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49954 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49955 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49956 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49957 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49958 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49959 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49960 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49961 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49962 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49963 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49964 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49965 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49966 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49967 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49968 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49969 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49970 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49971 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49972 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49973 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49974 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49975 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49976 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49977 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49978 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49979 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49980 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
49981 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49982 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49983 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49984 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49985 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49986 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49987 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49988 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49989 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49990 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49991 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49992 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49993 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49994 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49995 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49996 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49997 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49998 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49999 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
50000 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
50001 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
50002 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
50003 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
50004 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
50005 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
50006 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
50007 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
50008 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
50009 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
50010 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
50011 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
50012 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
50013 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
50014 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
50015 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
50016 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
50017 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
50018 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
50019 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
50020 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
50021 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
50022 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
50023 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
50024 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
50025 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
50026 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
50027 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
50028 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
50029 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
50030 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
50031 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
50032 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
50033 {
50034 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
50035 }
50036 {
50037 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
50038 }
50039 {
50040 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
50041 }
50042 {
50043 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
50044 }
50045 {
50046 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
50047 }
50048 {
50049 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
50050 }
50051 {
50052 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
50053 }
50054 {
50055 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
50056 }
50057 {
50058 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
50059 }
50060 {
50061 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
50062 }
50063 {
50064 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
50065 }
50066 {
50067 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
50068 }
50069 {
50070 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
50071 }
50072 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
50073 {
50074 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
50075 }
50076 {
50077 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
50078 }
50079 {
50080 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
50081 }
50082 {
50083 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
50084 }
50085 {
50086 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
50087 }
50088 {
50089 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
50090 }
50091 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
50092 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
50093 {
50094 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
50095 }
50096 {
50097 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
50098 }
50099 {
50100 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
50101 }
50102 {
50103 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
50104 }
50105 {
50106 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
50107 }
50108 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
50109 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
50110 {
50111 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
50112 }
50113 {
50114 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
50115 }
50116 {
50117 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
50118 }
50119 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
50120 {
50121 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
50122 }
50123 {
50124 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
50125 }
50126 {
50127 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
50128 }
50129 {
50130 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
50131 }
50132 {
50133 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
50134 }
50135 {
50136 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
50137 }
50138 {
50139 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
50140 }
50141 {
50142 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
50143 }
50144 {
50145 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
50146 }
50147 {
50148 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
50149 }
50150 {
50151 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
50152 }
50153 {
50154 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
50155 }
50156 {
50157 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
50158 }
50159 {
50160 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
50161 }
50162 {
50163 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
50164 }
50165 {
50166 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
50167 }
50168 {
50169 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
50170 }
50171 {
50172 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
50173 }
50174 {
50175 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
50176 }
50177
50178 // Initialize threading, some globals and such
50179 __wxPyPreStart(d);
50180
50181
50182 // Although these are defined in __version__ they need to be here too so
50183 // that an assert can be done to ensure that the wxPython and the wxWindows
50184 // versions match.
50185 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
50186 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
50187 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
50188
50189 }
50190
wxWidgets (Impactor)