]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Change reference from GetForce to CanVeto
[wxWidgets.git] / wxPython / src / gtk / _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_wxPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxNcPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_wxImage_HSVValue swig_types[36]
1379 #define SWIGTYPE_p_int swig_types[37]
1380 #define SWIGTYPE_p_wxSize swig_types[38]
1381 #define SWIGTYPE_p_wxDC swig_types[39]
1382 #define SWIGTYPE_p_wxPySizer swig_types[40]
1383 #define SWIGTYPE_p_wxVisualAttributes swig_types[41]
1384 #define SWIGTYPE_p_wxImage_RGBValue swig_types[42]
1385 #define SWIGTYPE_p_wxNotifyEvent swig_types[43]
1386 #define SWIGTYPE_p_wxPyEvent swig_types[44]
1387 #define SWIGTYPE_p_wxPropagationDisabler swig_types[45]
1388 #define SWIGTYPE_p_form_ops_t swig_types[46]
1389 #define SWIGTYPE_p_wxAppTraits swig_types[47]
1390 #define SWIGTYPE_p_wxArrayString swig_types[48]
1391 #define SWIGTYPE_p_wxShowEvent swig_types[49]
1392 #define SWIGTYPE_p_wxToolTip swig_types[50]
1393 #define SWIGTYPE_p_wxMoveEvent swig_types[51]
1394 #define SWIGTYPE_p_wxSizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxActivateEvent swig_types[53]
1396 #define SWIGTYPE_p_wxIconizeEvent swig_types[54]
1397 #define SWIGTYPE_p_wxMaximizeEvent swig_types[55]
1398 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[56]
1399 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
1401 #define SWIGTYPE_p_wxDateEvent swig_types[59]
1402 #define SWIGTYPE_p_wxMenuItem swig_types[60]
1403 #define SWIGTYPE_p_wxStaticBox swig_types[61]
1404 #define SWIGTYPE_p_long swig_types[62]
1405 #define SWIGTYPE_p_wxDuplexMode swig_types[63]
1406 #define SWIGTYPE_p_wxTIFFHandler swig_types[64]
1407 #define SWIGTYPE_p_wxXPMHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPNMHandler swig_types[66]
1409 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPCXHandler swig_types[68]
1411 #define SWIGTYPE_p_wxGIFHandler swig_types[69]
1412 #define SWIGTYPE_p_wxPNGHandler swig_types[70]
1413 #define SWIGTYPE_p_wxANIHandler swig_types[71]
1414 #define SWIGTYPE_p_wxPyImageHandler swig_types[72]
1415 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
1416 #define SWIGTYPE_p_wxZipFSHandler swig_types[74]
1417 #define SWIGTYPE_p_wxInternetFSHandler swig_types[75]
1418 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[76]
1419 #define SWIGTYPE_p_wxEvtHandler swig_types[77]
1420 #define SWIGTYPE_p_wxCURHandler swig_types[78]
1421 #define SWIGTYPE_p_wxICOHandler swig_types[79]
1422 #define SWIGTYPE_p_wxBMPHandler swig_types[80]
1423 #define SWIGTYPE_p_wxImageHandler swig_types[81]
1424 #define SWIGTYPE_p_wxFileSystemHandler swig_types[82]
1425 #define SWIGTYPE_p_wxRect swig_types[83]
1426 #define SWIGTYPE_p_wxButton swig_types[84]
1427 #define SWIGTYPE_p_wxGBSpan swig_types[85]
1428 #define SWIGTYPE_p_wxPropagateOnce swig_types[86]
1429 #define SWIGTYPE_p_wxAcceleratorTable swig_types[87]
1430 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[88]
1431 #define SWIGTYPE_p_char swig_types[89]
1432 #define SWIGTYPE_p_wxGBPosition swig_types[90]
1433 #define SWIGTYPE_p_wxImage swig_types[91]
1434 #define SWIGTYPE_p_wxFrame swig_types[92]
1435 #define SWIGTYPE_p_wxScrollWinEvent swig_types[93]
1436 #define SWIGTYPE_p_wxPaperSize swig_types[94]
1437 #define SWIGTYPE_p_wxImageHistogram swig_types[95]
1438 #define SWIGTYPE_p_wxPoint swig_types[96]
1439 #define SWIGTYPE_p_wxCursor swig_types[97]
1440 #define SWIGTYPE_p_wxObject swig_types[98]
1441 #define SWIGTYPE_p_wxInputStream swig_types[99]
1442 #define SWIGTYPE_p_wxOutputStream swig_types[100]
1443 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
1444 #define SWIGTYPE_p_wxDateTime swig_types[102]
1445 #define SWIGTYPE_p_wxKeyEvent swig_types[103]
1446 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[104]
1447 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[105]
1448 #define SWIGTYPE_p_unsigned_long swig_types[106]
1449 #define SWIGTYPE_p_wxWindow swig_types[107]
1450 #define SWIGTYPE_p_wxMenuBar swig_types[108]
1451 #define SWIGTYPE_p_wxFileSystem swig_types[109]
1452 #define SWIGTYPE_p_wxBitmap swig_types[110]
1453 #define SWIGTYPE_unsigned_int swig_types[111]
1454 #define SWIGTYPE_p_unsigned_int swig_types[112]
1455 #define SWIGTYPE_p_wxMenuEvent swig_types[113]
1456 #define SWIGTYPE_p_wxContextMenuEvent swig_types[114]
1457 #define SWIGTYPE_p_unsigned_char swig_types[115]
1458 #define SWIGTYPE_p_wxMouseEvent swig_types[116]
1459 #define SWIGTYPE_p_wxEraseEvent swig_types[117]
1460 #define SWIGTYPE_p_wxCloseEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyApp swig_types[119]
1462 #define SWIGTYPE_p_wxCommandEvent swig_types[120]
1463 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
1464 #define SWIGTYPE_p_wxPyDropTarget swig_types[122]
1465 #define SWIGTYPE_p_wxQuantize swig_types[123]
1466 #define SWIGTYPE_p_wxFocusEvent swig_types[124]
1467 #define SWIGTYPE_p_wxChildFocusEvent swig_types[125]
1468 #define SWIGTYPE_p_wxDropFilesEvent swig_types[126]
1469 #define SWIGTYPE_p_wxControlWithItems swig_types[127]
1470 #define SWIGTYPE_p_wxColour swig_types[128]
1471 #define SWIGTYPE_p_wxValidator swig_types[129]
1472 #define SWIGTYPE_p_wxPyValidator swig_types[130]
1473 static swig_type_info *swig_types[132];
1474
1475 /* -------- TYPES TABLE (END) -------- */
1476
1477
1478 /*-----------------------------------------------
1479 @(target):= _core_.so
1480 ------------------------------------------------*/
1481 #define SWIG_init init_core_
1482
1483 #define SWIG_name "_core_"
1484
1485 #include "wx/wxPython/wxPython_int.h"
1486 #include "wx/wxPython/pyclasses.h"
1487
1488
1489 #ifndef wxPyUSE_EXPORT
1490 // Helper functions for dealing with SWIG objects and such. These are
1491 // located here so they know about the SWIG types and functions declared
1492 // in the wrapper code.
1493
1494 #include <wx/hashmap.h>
1495 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1496
1497
1498 // Maintains a hashmap of className to swig_type_info pointers. Given the
1499 // name of a class either looks up the type info in the cache, or scans the
1500 // SWIG tables for it.
1501 extern PyObject* wxPyPtrTypeMap;
1502 static
1503 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1504
1505 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1506
1507 if (typeInfoCache == NULL)
1508 typeInfoCache = new wxPyTypeInfoHashMap;
1509
1510 wxString name(className);
1511 swig_type_info* swigType = (*typeInfoCache)[name];
1512
1513 if (! swigType) {
1514 // it wasn't in the cache, so look it up from SWIG
1515 name.Append(wxT(" *"));
1516 swigType = SWIG_TypeQuery(name.mb_str());
1517
1518 // if it still wasn't found, try looking for a mapped name
1519 if (!swigType) {
1520 PyObject* item;
1521 name = className;
1522
1523 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1524 (char*)(const char*)name.mbc_str())) != NULL) {
1525 name = wxString(PyString_AsString(item), *wxConvCurrent);
1526 name.Append(wxT(" *"));
1527 swigType = SWIG_TypeQuery(name.mb_str());
1528 }
1529 }
1530 if (swigType) {
1531 // and add it to the map if found
1532 (*typeInfoCache)[className] = swigType;
1533 }
1534 }
1535 return swigType;
1536 }
1537
1538
1539 // Check if a class name is a type known to SWIG
1540 bool wxPyCheckSwigType(const wxChar* className) {
1541
1542 swig_type_info* swigType = wxPyFindSwigType(className);
1543 return swigType != NULL;
1544 }
1545
1546
1547 // Given a pointer to a C++ object and a class name, construct a Python proxy
1548 // object for it.
1549 PyObject* wxPyConstructObject(void* ptr,
1550 const wxChar* className,
1551 int setThisOwn) {
1552
1553 swig_type_info* swigType = wxPyFindSwigType(className);
1554 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1555
1556 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1557 }
1558
1559
1560 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1561 // Ensures that the proxy object is of the specified (or derived) type. If
1562 // not able to perform the conversion then a Python exception is set and the
1563 // error should be handled properly in the caller. Returns True on success.
1564 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1565 const wxChar* className) {
1566
1567 swig_type_info* swigType = wxPyFindSwigType(className);
1568 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1569
1570 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1571 }
1572
1573
1574 // Make a SWIGified pointer object suitable for a .this attribute
1575 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1576
1577 PyObject* robj = NULL;
1578
1579 swig_type_info* swigType = wxPyFindSwigType(className);
1580 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1581
1582 #ifdef SWIG_COBJECT_TYPES
1583 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1584 #else
1585 {
1586 char result[1024];
1587 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1588 PyString_FromString(result) : 0;
1589 }
1590 #endif
1591
1592 return robj;
1593 }
1594
1595
1596 // Python's PyInstance_Check does not return True for instances of new-style
1597 // classes. This should get close enough for both new and old classes but I
1598 // should re-evaluate the need for doing instance checks...
1599 bool wxPyInstance_Check(PyObject* obj) {
1600 return PyObject_HasAttrString(obj, "__class__") != 0;
1601 }
1602
1603
1604
1605 // This one checks if the object is an instance of a SWIG proxy class (it has
1606 // a .this attribute, and the .this attribute is a PySwigObject.)
1607 bool wxPySwigInstance_Check(PyObject* obj) {
1608 static PyObject* this_str = NULL;
1609 if (this_str == NULL)
1610 this_str = PyString_FromString("this");
1611
1612 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1613 if (this_attr) {
1614 bool retval = (PySwigObject_Check(this_attr) != 0);
1615 Py_DECREF(this_attr);
1616 return retval;
1617 }
1618
1619 PyErr_Clear();
1620 return false;
1621 }
1622
1623
1624
1625 // Export a C API in a struct. Other modules will be able to load this from
1626 // the wx._core_ module and will then have safe access to these functions,
1627 // even if they are located in another shared library.
1628 static wxPyCoreAPI API = {
1629
1630 wxPyCheckSwigType,
1631 wxPyConstructObject,
1632 wxPyConvertSwigPtr,
1633 wxPyMakeSwigPtr,
1634
1635 wxPyBeginAllowThreads,
1636 wxPyEndAllowThreads,
1637 wxPyBeginBlockThreads,
1638 wxPyEndBlockThreads,
1639
1640 wxPy_ConvertList,
1641
1642 wxString_in_helper,
1643 Py2wxString,
1644 wx2PyString,
1645
1646 byte_LIST_helper,
1647 int_LIST_helper,
1648 long_LIST_helper,
1649 string_LIST_helper,
1650 wxPoint_LIST_helper,
1651 wxBitmap_LIST_helper,
1652 wxString_LIST_helper,
1653 wxAcceleratorEntry_LIST_helper,
1654
1655 wxSize_helper,
1656 wxPoint_helper,
1657 wxRealPoint_helper,
1658 wxRect_helper,
1659 wxColour_helper,
1660 wxPoint2D_helper,
1661
1662 wxPySimple_typecheck,
1663 wxColour_typecheck,
1664
1665 wxPyCBH_setCallbackInfo,
1666 wxPyCBH_findCallback,
1667 wxPyCBH_callCallback,
1668 wxPyCBH_callCallbackObj,
1669 wxPyCBH_delete,
1670
1671 wxPyMake_wxObject,
1672 wxPyMake_wxSizer,
1673 wxPyPtrTypeMap_Add,
1674 wxPy2int_seq_helper,
1675 wxPy4int_seq_helper,
1676 wxArrayString2PyList_helper,
1677 wxArrayInt2PyList_helper,
1678
1679 wxPyClientData_dtor,
1680 wxPyUserData_dtor,
1681 wxPyOORClientData_dtor,
1682
1683 wxPyCBInputStream_create,
1684 wxPyCBInputStream_copy,
1685
1686 wxPyInstance_Check,
1687 wxPySwigInstance_Check,
1688
1689 wxPyCheckForApp
1690
1691 };
1692
1693 #endif
1694
1695
1696 #if !WXWIN_COMPATIBILITY_2_4
1697 #define wxHIDE_READONLY 0
1698 #endif
1699
1700
1701 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1702 #define SWIG_From_int PyInt_FromLong
1703 /*@@*/
1704
1705 static const wxString wxPyEmptyString(wxEmptyString);
1706 static wxString wxObject_GetClassName(wxObject *self){
1707 return self->GetClassInfo()->GetClassName();
1708 }
1709 static void wxObject_Destroy(wxObject *self){
1710 delete self;
1711 }
1712
1713 #ifndef __WXMAC__
1714 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1715 #endif
1716
1717
1718 #include <limits.h>
1719
1720
1721 SWIGINTERN int
1722 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1723 const char *errmsg)
1724 {
1725 if (value < min_value) {
1726 if (errmsg) {
1727 PyErr_Format(PyExc_OverflowError,
1728 "value %ld is less than '%s' minimum %ld",
1729 value, errmsg, min_value);
1730 }
1731 return 0;
1732 } else if (value > max_value) {
1733 if (errmsg) {
1734 PyErr_Format(PyExc_OverflowError,
1735 "value %ld is greater than '%s' maximum %ld",
1736 value, errmsg, max_value);
1737 }
1738 return 0;
1739 }
1740 return 1;
1741 }
1742
1743
1744 SWIGINTERN int
1745 SWIG_AsVal_long(PyObject* obj, long* val)
1746 {
1747 if (PyNumber_Check(obj)) {
1748 if (val) *val = PyInt_AsLong(obj);
1749 return 1;
1750 }
1751 else {
1752 SWIG_type_error("number", obj);
1753 }
1754 return 0;
1755 }
1756
1757
1758 #if INT_MAX != LONG_MAX
1759 SWIGINTERN int
1760 SWIG_AsVal_int(PyObject *obj, int *val)
1761 {
1762 const char* errmsg = val ? "int" : (char*)0;
1763 long v;
1764 if (SWIG_AsVal_long(obj, &v)) {
1765 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1766 if (val) *val = (int)(v);
1767 return 1;
1768 } else {
1769 return 0;
1770 }
1771 } else {
1772 PyErr_Clear();
1773 }
1774 if (val) {
1775 SWIG_type_error(errmsg, obj);
1776 }
1777 return 0;
1778 }
1779 #else
1780 SWIGINTERNSHORT int
1781 SWIG_AsVal_int(PyObject *obj, int *val)
1782 {
1783 return SWIG_AsVal_long(obj,(long*)val);
1784 }
1785 #endif
1786
1787
1788 SWIGINTERNSHORT int
1789 SWIG_As_int(PyObject* obj)
1790 {
1791 int v;
1792 if (!SWIG_AsVal_int(obj, &v)) {
1793 /*
1794 this is needed to make valgrind/purify happier.
1795 */
1796 memset((void*)&v, 0, sizeof(int));
1797 }
1798 return v;
1799 }
1800
1801
1802 SWIGINTERNSHORT int
1803 SWIG_Check_int(PyObject* obj)
1804 {
1805 return SWIG_AsVal_int(obj, (int*)0);
1806 }
1807
1808 static PyObject *wxSize_Get(wxSize *self){
1809 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1810 PyObject* tup = PyTuple_New(2);
1811 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1812 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1813 wxPyEndBlockThreads(blocked);
1814 return tup;
1815 }
1816
1817 SWIGINTERN int
1818 SWIG_AsVal_double(PyObject *obj, double* val)
1819 {
1820 if (PyNumber_Check(obj)) {
1821 if (val) *val = PyFloat_AsDouble(obj);
1822 return 1;
1823 }
1824 else {
1825 SWIG_type_error("number", obj);
1826 }
1827 return 0;
1828 }
1829
1830
1831 SWIGINTERNSHORT double
1832 SWIG_As_double(PyObject* obj)
1833 {
1834 double v;
1835 if (!SWIG_AsVal_double(obj, &v)) {
1836 /*
1837 this is needed to make valgrind/purify happier.
1838 */
1839 memset((void*)&v, 0, sizeof(double));
1840 }
1841 return v;
1842 }
1843
1844
1845 SWIGINTERNSHORT int
1846 SWIG_Check_double(PyObject* obj)
1847 {
1848 return SWIG_AsVal_double(obj, (double*)0);
1849 }
1850
1851
1852 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1853 #define SWIG_From_double PyFloat_FromDouble
1854 /*@@*/
1855
1856 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1857 self->x = x;
1858 self->y = y;
1859 }
1860 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1861 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1862 PyObject* tup = PyTuple_New(2);
1863 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1864 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1865 wxPyEndBlockThreads(blocked);
1866 return tup;
1867 }
1868
1869 SWIGINTERNSHORT long
1870 SWIG_As_long(PyObject* obj)
1871 {
1872 long v;
1873 if (!SWIG_AsVal_long(obj, &v)) {
1874 /*
1875 this is needed to make valgrind/purify happier.
1876 */
1877 memset((void*)&v, 0, sizeof(long));
1878 }
1879 return v;
1880 }
1881
1882
1883 SWIGINTERNSHORT int
1884 SWIG_Check_long(PyObject* obj)
1885 {
1886 return SWIG_AsVal_long(obj, (long*)0);
1887 }
1888
1889 static void wxPoint_Set(wxPoint *self,long x,long y){
1890 self->x = x;
1891 self->y = y;
1892 }
1893 static PyObject *wxPoint_Get(wxPoint *self){
1894 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1895 PyObject* tup = PyTuple_New(2);
1896 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1897 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1898 wxPyEndBlockThreads(blocked);
1899 return tup;
1900 }
1901 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1902 self->x = x;
1903 self->y = y;
1904 self->width = width;
1905 self->height = height;
1906 }
1907 static PyObject *wxRect_Get(wxRect *self){
1908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1909 PyObject* tup = PyTuple_New(4);
1910 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1911 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1912 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1913 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1914 wxPyEndBlockThreads(blocked);
1915 return tup;
1916 }
1917
1918 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1919 wxRegion reg1(*r1);
1920 wxRegion reg2(*r2);
1921 wxRect dest(0,0,0,0);
1922 PyObject* obj;
1923
1924 reg1.Intersect(reg2);
1925 dest = reg1.GetBox();
1926
1927 if (dest != wxRect(0,0,0,0)) {
1928 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1929 wxRect* newRect = new wxRect(dest);
1930 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1931 wxPyEndBlockThreads(blocked);
1932 return obj;
1933 }
1934 Py_INCREF(Py_None);
1935 return Py_None;
1936 }
1937
1938
1939 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1940 PyObject* o2;
1941 PyObject* o3;
1942
1943 if (!target) {
1944 target = o;
1945 } else if (target == Py_None) {
1946 Py_DECREF(Py_None);
1947 target = o;
1948 } else {
1949 if (!PyTuple_Check(target)) {
1950 o2 = target;
1951 target = PyTuple_New(1);
1952 PyTuple_SetItem(target, 0, o2);
1953 }
1954 o3 = PyTuple_New(1);
1955 PyTuple_SetItem(o3, 0, o);
1956
1957 o2 = target;
1958 target = PySequence_Concat(o2, o3);
1959 Py_DECREF(o2);
1960 Py_DECREF(o3);
1961 }
1962 return target;
1963 }
1964
1965
1966 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1967 self->m_x = x;
1968 self->m_y = y;
1969 }
1970 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1971 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1972 PyObject* tup = PyTuple_New(2);
1973 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1974 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1975 wxPyEndBlockThreads(blocked);
1976 return tup;
1977 }
1978
1979 #include "wx/wxPython/pyistream.h"
1980
1981 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1982 wxInputStream* wxis = wxPyCBInputStream::create(p);
1983 if (wxis)
1984 return new wxPyInputStream(wxis);
1985 else
1986 return NULL;
1987 }
1988
1989 SWIGINTERNSHORT PyObject*
1990 SWIG_From_char(char c)
1991 {
1992 return PyString_FromStringAndSize(&c,1);
1993 }
1994
1995
1996 SWIGINTERNSHORT PyObject*
1997 SWIG_From_unsigned_SS_long(unsigned long value)
1998 {
1999 return (value > LONG_MAX) ?
2000 PyLong_FromUnsignedLong(value)
2001 : PyInt_FromLong((long)(value));
2002 }
2003
2004
2005 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2006 SWIGINTERN int
2007 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2008 {
2009 static swig_type_info* pchar_info = 0;
2010 char* vptr = 0;
2011 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2012 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2013 if (cptr) *cptr = vptr;
2014 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2015 return SWIG_OLDOBJ;
2016 } else {
2017 PyErr_Clear();
2018 if (PyString_Check(obj)) {
2019 if (cptr) {
2020 *cptr = PyString_AS_STRING(obj);
2021 if (psize) {
2022 *psize = PyString_GET_SIZE(obj) + 1;
2023 }
2024 }
2025 return SWIG_PYSTR;
2026 }
2027 }
2028 if (cptr) {
2029 SWIG_type_error("char *", obj);
2030 }
2031 return 0;
2032 }
2033
2034
2035 SWIGINTERN int
2036 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2037 {
2038 char* cptr; size_t csize;
2039 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2040 /* in C you can do:
2041
2042 char x[5] = "hello";
2043
2044 ie, assing the array using an extra '0' char.
2045 */
2046 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2047 if (csize <= size) {
2048 if (val) {
2049 if (csize) memcpy(val, cptr, csize);
2050 if (csize < size) memset(val + csize, 0, size - csize);
2051 }
2052 return 1;
2053 }
2054 }
2055 if (val) {
2056 PyErr_Format(PyExc_TypeError,
2057 "a char array of maximum size %lu is expected",
2058 (unsigned long) size);
2059 }
2060 return 0;
2061 }
2062
2063
2064 SWIGINTERN int
2065 SWIG_AsVal_char(PyObject *obj, char *val)
2066 {
2067 const char* errmsg = val ? "char" : (char*)0;
2068 long v;
2069 if (SWIG_AsVal_long(obj, &v)) {
2070 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2071 if (val) *val = (char)(v);
2072 return 1;
2073 } else {
2074 return 0;
2075 }
2076 } else {
2077 PyErr_Clear();
2078 return SWIG_AsCharArray(obj, val, 1);
2079 }
2080 }
2081
2082
2083 SWIGINTERNSHORT char
2084 SWIG_As_char(PyObject* obj)
2085 {
2086 char v;
2087 if (!SWIG_AsVal_char(obj, &v)) {
2088 /*
2089 this is needed to make valgrind/purify happier.
2090 */
2091 memset((void*)&v, 0, sizeof(char));
2092 }
2093 return v;
2094 }
2095
2096
2097 SWIGINTERNSHORT int
2098 SWIG_Check_char(PyObject* obj)
2099 {
2100 return SWIG_AsVal_char(obj, (char*)0);
2101 }
2102
2103
2104 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2105 #define SWIG_From_long PyInt_FromLong
2106 /*@@*/
2107
2108 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2109 // We use only strings for the streams, not unicode
2110 PyObject* str = PyObject_Str(obj);
2111 if (! str) {
2112 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2113 return;
2114 }
2115 self->Write(PyString_AS_STRING(str),
2116 PyString_GET_SIZE(str));
2117 Py_DECREF(str);
2118 }
2119
2120 #include "wx/wxPython/pyistream.h"
2121
2122
2123 class wxPyFileSystemHandler : public wxFileSystemHandler
2124 {
2125 public:
2126 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2127
2128 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2129 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2130 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2131 DEC_PYCALLBACK_STRING__pure(FindNext);
2132
2133 wxString GetProtocol(const wxString& location) {
2134 return wxFileSystemHandler::GetProtocol(location);
2135 }
2136
2137 wxString GetLeftLocation(const wxString& location) {
2138 return wxFileSystemHandler::GetLeftLocation(location);
2139 }
2140
2141 wxString GetAnchor(const wxString& location) {
2142 return wxFileSystemHandler::GetAnchor(location);
2143 }
2144
2145 wxString GetRightLocation(const wxString& location) {
2146 return wxFileSystemHandler::GetRightLocation(location);
2147 }
2148
2149 wxString GetMimeTypeFromExt(const wxString& location) {
2150 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2151 }
2152
2153 PYPRIVATE;
2154 };
2155
2156
2157 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2158 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2159 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2160 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2161
2162
2163 SWIGINTERN int
2164 SWIG_AsVal_bool(PyObject *obj, bool *val)
2165 {
2166 if (obj == Py_True) {
2167 if (val) *val = true;
2168 return 1;
2169 }
2170 if (obj == Py_False) {
2171 if (val) *val = false;
2172 return 1;
2173 }
2174 int res = 0;
2175 if (SWIG_AsVal_int(obj, &res)) {
2176 if (val) *val = res ? true : false;
2177 return 1;
2178 } else {
2179 PyErr_Clear();
2180 }
2181 if (val) {
2182 SWIG_type_error("bool", obj);
2183 }
2184 return 0;
2185 }
2186
2187
2188 SWIGINTERNSHORT bool
2189 SWIG_As_bool(PyObject* obj)
2190 {
2191 bool v;
2192 if (!SWIG_AsVal_bool(obj, &v)) {
2193 /*
2194 this is needed to make valgrind/purify happier.
2195 */
2196 memset((void*)&v, 0, sizeof(bool));
2197 }
2198 return v;
2199 }
2200
2201
2202 SWIGINTERNSHORT int
2203 SWIG_Check_bool(PyObject* obj)
2204 {
2205 return SWIG_AsVal_bool(obj, (bool*)0);
2206 }
2207
2208 static wxString FileSystem_URLToFileName(wxString const &url){
2209 wxFileName fname = wxFileSystem::URLToFileName(url);
2210 return fname.GetFullPath();
2211 }
2212
2213 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2214 wxImage& image,
2215 long type) {
2216 wxMemoryFSHandler::AddFile(filename, image, type);
2217 }
2218
2219 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2220 const wxBitmap& bitmap,
2221 long type) {
2222 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2223 }
2224
2225 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2226 PyObject* data) {
2227 if (! PyString_Check(data)) {
2228 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2229 "Expected string object"));
2230 return;
2231 }
2232
2233 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2234 void* ptr = (void*)PyString_AsString(data);
2235 size_t size = PyString_Size(data);
2236 wxPyEndBlockThreads(blocked);
2237
2238 wxMemoryFSHandler::AddFile(filename, ptr, size);
2239 }
2240
2241
2242 #include "wx/wxPython/pyistream.h"
2243
2244
2245 SWIGINTERN int
2246 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2247 {
2248 long v = 0;
2249 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2250 SWIG_type_error("unsigned number", obj);
2251 }
2252 else if (val)
2253 *val = (unsigned long)v;
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERNSHORT int
2259 SWIG_CheckUnsignedLongInRange(unsigned long value,
2260 unsigned long max_value,
2261 const char *errmsg)
2262 {
2263 if (value > max_value) {
2264 if (errmsg) {
2265 PyErr_Format(PyExc_OverflowError,
2266 "value %lu is greater than '%s' minimum %lu",
2267 value, errmsg, max_value);
2268 }
2269 return 0;
2270 }
2271 return 1;
2272 }
2273
2274
2275 SWIGINTERN int
2276 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2277 {
2278 const char* errmsg = val ? "unsigned char" : (char*)0;
2279 unsigned long v;
2280 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2281 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2282 if (val) *val = (unsigned char)(v);
2283 return 1;
2284 } else {
2285 return 0;
2286 }
2287 } else {
2288 PyErr_Clear();
2289 }
2290 if (val) {
2291 SWIG_type_error(errmsg, obj);
2292 }
2293 return 0;
2294 }
2295
2296
2297 SWIGINTERNSHORT unsigned char
2298 SWIG_As_unsigned_SS_char(PyObject* obj)
2299 {
2300 unsigned char v;
2301 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2302 /*
2303 this is needed to make valgrind/purify happier.
2304 */
2305 memset((void*)&v, 0, sizeof(unsigned char));
2306 }
2307 return v;
2308 }
2309
2310
2311 SWIGINTERNSHORT int
2312 SWIG_Check_unsigned_SS_char(PyObject* obj)
2313 {
2314 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2315 }
2316
2317
2318 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2319 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2320 /*@@*/
2321
2322
2323
2324 SWIGINTERNSHORT unsigned long
2325 SWIG_As_unsigned_SS_long(PyObject* obj)
2326 {
2327 unsigned long v;
2328 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2329 /*
2330 this is needed to make valgrind/purify happier.
2331 */
2332 memset((void*)&v, 0, sizeof(unsigned long));
2333 }
2334 return v;
2335 }
2336
2337
2338 SWIGINTERNSHORT int
2339 SWIG_Check_unsigned_SS_long(PyObject* obj)
2340 {
2341 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2342 }
2343
2344 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2345 wxImageHistogramEntry e = (*self)[key];
2346 return e.value;
2347 }
2348 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2349 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2350 wxImageHistogramEntry e = (*self)[key];
2351 return e.value;
2352 }
2353 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2354 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2355 colour.Green(),
2356 colour.Blue());
2357 wxImageHistogramEntry e = (*self)[key];
2358 return e.value;
2359 }
2360
2361 typedef unsigned char* buffer;
2362
2363
2364 // Pull the nested class out to the top level for SWIG's sake
2365 #define wxImage_RGBValue wxImage::RGBValue
2366 #define wxImage_HSVValue wxImage::HSVValue
2367
2368 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2369 if (width > 0 && height > 0)
2370 return new wxImage(width, height, clear);
2371 else
2372 return new wxImage;
2373 }
2374 static wxImage *new_wxImage(wxBitmap const &bitmap){
2375 return new wxImage(bitmap.ConvertToImage());
2376 }
2377 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2378 if (DATASIZE != width*height*3) {
2379 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2380 return NULL;
2381 }
2382
2383 // Copy the source data so the wxImage can clean it up later
2384 buffer copy = (buffer)malloc(DATASIZE);
2385 if (copy == NULL) {
2386 wxPyBLOCK_THREADS(PyErr_NoMemory());
2387 return NULL;
2388 }
2389 memcpy(copy, data, DATASIZE);
2390 return new wxImage(width, height, copy, false);
2391 }
2392 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2393 if (DATASIZE != width*height*3) {
2394 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2395 return NULL;
2396 }
2397 if (ALPHASIZE != width*height) {
2398 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2399 return NULL;
2400 }
2401
2402 // Copy the source data so the wxImage can clean it up later
2403 buffer dcopy = (buffer)malloc(DATASIZE);
2404 if (dcopy == NULL) {
2405 wxPyBLOCK_THREADS(PyErr_NoMemory());
2406 return NULL;
2407 }
2408 memcpy(dcopy, data, DATASIZE);
2409
2410 buffer acopy = (buffer)malloc(ALPHASIZE);
2411 if (acopy == NULL) {
2412 wxPyBLOCK_THREADS(PyErr_NoMemory());
2413 return NULL;
2414 }
2415 memcpy(acopy, alpha, ALPHASIZE);
2416
2417 return new wxImage(width, height, dcopy, acopy, false);
2418 }
2419 static wxSize wxImage_GetSize(wxImage *self){
2420 wxSize size(self->GetWidth(), self->GetHeight());
2421 return size;
2422 }
2423 static PyObject *wxImage_GetData(wxImage *self){
2424 buffer data = self->GetData();
2425 int len = self->GetWidth() * self->GetHeight() * 3;
2426 PyObject* rv;
2427 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2428 return rv;
2429 }
2430 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2431 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2432 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2433 return;
2434 }
2435 buffer copy = (buffer)malloc(DATASIZE);
2436 if (copy == NULL) {
2437 wxPyBLOCK_THREADS(PyErr_NoMemory());
2438 return;
2439 }
2440 memcpy(copy, data, DATASIZE);
2441 self->SetData(copy, false);
2442 // wxImage takes ownership of copy...
2443 }
2444 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2445 buffer data = self->GetData();
2446 int len = self->GetWidth() * self->GetHeight() * 3;
2447 PyObject* rv;
2448 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2449 return rv;
2450 }
2451 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2452 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2453 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2454 return;
2455 }
2456 self->SetData(data, true);
2457 }
2458 static PyObject *wxImage_GetAlphaData(wxImage *self){
2459 buffer data = self->GetAlpha();
2460 if (! data) {
2461 RETURN_NONE();
2462 } else {
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2466 return rv;
2467 }
2468 }
2469 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2470 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2471 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2472 return;
2473 }
2474 buffer acopy = (buffer)malloc(ALPHASIZE);
2475 if (acopy == NULL) {
2476 wxPyBLOCK_THREADS(PyErr_NoMemory());
2477 return;
2478 }
2479 memcpy(acopy, alpha, ALPHASIZE);
2480 self->SetAlpha(acopy, false);
2481 // wxImage takes ownership of acopy...
2482 }
2483 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2484 buffer data = self->GetAlpha();
2485 int len = self->GetWidth() * self->GetHeight();
2486 PyObject* rv;
2487 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2488 return rv;
2489 }
2490 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2491 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2492 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2493 return;
2494 }
2495 self->SetAlpha(alpha, true);
2496 }
2497 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2498 wxBitmap bitmap(*self, depth);
2499 return bitmap;
2500 }
2501 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2502 wxImage mono = self->ConvertToMono( red, green, blue );
2503 wxBitmap bitmap( mono, 1 );
2504 return bitmap;
2505 }
2506 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2507 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2508 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2509 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2510 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2511 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2512 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2513 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2514 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2515 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2516 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2517 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2518 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2519 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2520 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2521
2522 #include <wx/quantize.h>
2523
2524 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2525 return wxQuantize::Quantize(src, dest,
2526 //NULL, // palette
2527 desiredNoColours,
2528 NULL, // eightBitData
2529 flags);
2530 }
2531 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2532 if (PyCallable_Check(func)) {
2533 self->Connect(id, lastId, eventType,
2534 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2535 new wxPyCallback(func));
2536 }
2537 else if (func == Py_None) {
2538 self->Disconnect(id, lastId, eventType,
2539 (wxObjectEventFunction)
2540 &wxPyCallback::EventThunker);
2541 }
2542 else {
2543 wxPyBLOCK_THREADS(
2544 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2545 }
2546 }
2547 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2548 return self->Disconnect(id, lastId, eventType,
2549 (wxObjectEventFunction)
2550 &wxPyCallback::EventThunker);
2551 }
2552 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2553 if (_self && _self != Py_None) {
2554 self->SetClientObject(new wxPyOORClientData(_self, incref));
2555 }
2556 else {
2557 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2558 if (data) {
2559 self->SetClientObject(NULL); // This will delete it too
2560 }
2561 }
2562 }
2563
2564 #if ! wxUSE_HOTKEY
2565 #define wxEVT_HOTKEY -9999
2566 #endif
2567
2568
2569 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2570 #if wxUSE_UNICODE
2571 return self->GetUnicodeKey();
2572 #else
2573 return 0;
2574 #endif
2575 }
2576
2577 #if UINT_MAX < LONG_MAX
2578 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2579 #define SWIG_From_unsigned_SS_int SWIG_From_long
2580 /*@@*/
2581 #else
2582 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2583 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2584 /*@@*/
2585 #endif
2586
2587
2588 #if UINT_MAX != ULONG_MAX
2589 SWIGINTERN int
2590 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2591 {
2592 const char* errmsg = val ? "unsigned int" : (char*)0;
2593 unsigned long v;
2594 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2595 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2596 if (val) *val = (unsigned int)(v);
2597 return 1;
2598 }
2599 } else {
2600 PyErr_Clear();
2601 }
2602 if (val) {
2603 SWIG_type_error(errmsg, obj);
2604 }
2605 return 0;
2606 }
2607 #else
2608 SWIGINTERNSHORT unsigned int
2609 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2610 {
2611 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2612 }
2613 #endif
2614
2615
2616 SWIGINTERNSHORT unsigned int
2617 SWIG_As_unsigned_SS_int(PyObject* obj)
2618 {
2619 unsigned int v;
2620 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2621 /*
2622 this is needed to make valgrind/purify happier.
2623 */
2624 memset((void*)&v, 0, sizeof(unsigned int));
2625 }
2626 return v;
2627 }
2628
2629
2630 SWIGINTERNSHORT int
2631 SWIG_Check_unsigned_SS_int(PyObject* obj)
2632 {
2633 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2634 }
2635
2636 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2637 self->m_size = size;
2638 }
2639 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2640 int count = self->GetNumberOfFiles();
2641 wxString* files = self->GetFiles();
2642 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2643 PyObject* list = PyList_New(count);
2644
2645 if (!list) {
2646 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2647 wxPyEndBlockThreads(blocked);
2648 return NULL;
2649 }
2650
2651 for (int i=0; i<count; i++) {
2652 PyList_SetItem(list, i, wx2PyString(files[i]));
2653 }
2654 wxPyEndBlockThreads(blocked);
2655 return list;
2656 }
2657
2658
2659 static wxPyApp *new_wxPyApp(){
2660 wxPythonApp = new wxPyApp();
2661 return wxPythonApp;
2662 }
2663 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2664
2665 void wxApp_CleanUp() {
2666 __wxPyCleanup();
2667 }
2668
2669
2670 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2671
2672
2673 SWIGINTERNSHORT int
2674 SWIG_AsCharPtr(PyObject *obj, char **val)
2675 {
2676 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2677 return 1;
2678 }
2679 if (val) {
2680 PyErr_Clear();
2681 SWIG_type_error("char *", obj);
2682 }
2683 return 0;
2684 }
2685
2686
2687 SWIGINTERN PyObject *
2688 SWIG_FromCharPtr(const char* cptr)
2689 {
2690 if (cptr) {
2691 size_t size = strlen(cptr);
2692 if (size > INT_MAX) {
2693 return SWIG_NewPointerObj((char*)(cptr),
2694 SWIG_TypeQuery("char *"), 0);
2695 } else {
2696 if (size != 0) {
2697 return PyString_FromStringAndSize(cptr, size);
2698 } else {
2699 return PyString_FromString(cptr);
2700 }
2701 }
2702 }
2703 Py_INCREF(Py_None);
2704 return Py_None;
2705 }
2706
2707
2708 #ifdef __WXMAC__
2709
2710 // A dummy class that raises an exception if used...
2711 class wxEventLoop
2712 {
2713 public:
2714 wxEventLoop() { wxPyRaiseNotImplemented(); }
2715 int Run() { return 0; }
2716 void Exit(int rc = 0) {}
2717 bool Pending() const { return false; }
2718 bool Dispatch() { return false; }
2719 bool IsRunning() const { return false; }
2720 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2721 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2722 };
2723
2724 #else
2725
2726 #include <wx/evtloop.h>
2727
2728 #endif
2729
2730
2731
2732 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2733 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2734 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2735 static PyObject *wxWindow_GetChildren(wxWindow *self){
2736 wxWindowList& list = self->GetChildren();
2737 return wxPy_ConvertList(&list);
2738 }
2739 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2740 #if wxUSE_HOTKEY
2741 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2742 #else
2743 return false;
2744 #endif
2745 }
2746 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2747
2748
2749
2750 return false;
2751
2752 }
2753 static long wxWindow_GetHandle(wxWindow *self){
2754 return wxPyGetWinHandle(self);
2755 }
2756 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2757 self->AssociateHandle((WXWidget)handle);
2758 }
2759 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2760
2761 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2762 return wxWindow::FindWindowById(id, parent);
2763 }
2764
2765 wxWindow* wxFindWindowByName( const wxString& name,
2766 const wxWindow *parent = NULL ) {
2767 return wxWindow::FindWindowByName(name, parent);
2768 }
2769
2770 wxWindow* wxFindWindowByLabel( const wxString& label,
2771 const wxWindow *parent = NULL ) {
2772 return wxWindow::FindWindowByLabel(label, parent);
2773 }
2774
2775
2776 #ifdef __WXMSW__
2777 #include <wx/msw/private.h> // to get wxGetWindowId
2778 #endif
2779
2780
2781 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2782 #ifdef __WXMSW__
2783 WXHWND hWnd = (WXHWND)_hWnd;
2784 long id = wxGetWindowId(hWnd);
2785 wxWindow* win = new wxWindow;
2786 if (parent)
2787 parent->AddChild(win);
2788 win->SetEventHandler(win);
2789 win->SetHWND(hWnd);
2790 win->SetId(id);
2791 win->SubclassWin(hWnd);
2792 win->AdoptAttributesFromHWND();
2793 win->SetupColours();
2794 return win;
2795 #else
2796 wxPyRaiseNotImplemented();
2797 return NULL;
2798 #endif
2799 }
2800
2801
2802 PyObject* GetTopLevelWindows() {
2803 return wxPy_ConvertList(&wxTopLevelWindows);
2804 }
2805
2806
2807 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2808 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2809 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2810
2811 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2812
2813 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2814 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2815 wxMenuItemList& list = self->GetMenuItems();
2816 return wxPy_ConvertList(&list);
2817 }
2818 static void MenuBar_SetAutoWindowMenu(bool enable){}
2819 static bool MenuBar_GetAutoWindowMenu(){ return false; }
2820 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2821 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2822 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2823 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2824 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2825 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2826 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2827 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2828 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2829 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2830 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2831 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2832 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2833 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2834 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2835 static const wxString wxPyControlNameStr(wxControlNameStr);
2836 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2837 if (clientData) {
2838 wxPyClientData* data = new wxPyClientData(clientData);
2839 return self->Append(item, data);
2840 } else
2841 return self->Append(item);
2842 }
2843 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2844 if (clientData) {
2845 wxPyClientData* data = new wxPyClientData(clientData);
2846 return self->Insert(item, pos, data);
2847 } else
2848 return self->Insert(item, pos);
2849 }
2850 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2851 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2852 if (data) {
2853 Py_INCREF(data->m_obj);
2854 return data->m_obj;
2855 } else {
2856 Py_INCREF(Py_None);
2857 return Py_None;
2858 }
2859 }
2860 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2861 wxPyClientData* data = new wxPyClientData(clientData);
2862 self->SetClientObject(n, data);
2863 }
2864
2865
2866 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2867 wxPyUserData* data = NULL;
2868 if ( userData ) {
2869 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2870 data = new wxPyUserData(userData);
2871 wxPyEndBlockThreads(blocked);
2872 }
2873 return new wxSizerItem(window, proportion, flag, border, data);
2874 }
2875 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2876 wxPyUserData* data = NULL;
2877 if ( userData ) {
2878 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2879 data = new wxPyUserData(userData);
2880 wxPyEndBlockThreads(blocked);
2881 }
2882 return new wxSizerItem(width, height, proportion, flag, border, data);
2883 }
2884 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2885 wxPyUserData* data = NULL;
2886 if ( userData ) {
2887 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2888 data = new wxPyUserData(userData);
2889 wxPyEndBlockThreads(blocked);
2890 }
2891 return new wxSizerItem(sizer, proportion, flag, border, data);
2892 }
2893
2894 #include <float.h>
2895 SWIGINTERN int
2896 SWIG_CheckDoubleInRange(double value, double min_value,
2897 double max_value, const char* errmsg)
2898 {
2899 if (value < min_value) {
2900 if (errmsg) {
2901 PyErr_Format(PyExc_OverflowError,
2902 "value %g is less than %s minimum %g",
2903 value, errmsg, min_value);
2904 }
2905 return 0;
2906 } else if (value > max_value) {
2907 if (errmsg) {
2908 PyErr_Format(PyExc_OverflowError,
2909 "value %g is greater than %s maximum %g",
2910 value, errmsg, max_value);
2911 }
2912 return 0;
2913 }
2914 return 1;
2915 }
2916
2917
2918 SWIGINTERN int
2919 SWIG_AsVal_float(PyObject *obj, float *val)
2920 {
2921 const char* errmsg = val ? "float" : (char*)0;
2922 double v;
2923 if (SWIG_AsVal_double(obj, &v)) {
2924 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2925 if (val) *val = (float)(v);
2926 return 1;
2927 } else {
2928 return 0;
2929 }
2930 } else {
2931 PyErr_Clear();
2932 }
2933 if (val) {
2934 SWIG_type_error(errmsg, obj);
2935 }
2936 return 0;
2937 }
2938
2939
2940 SWIGINTERNSHORT float
2941 SWIG_As_float(PyObject* obj)
2942 {
2943 float v;
2944 if (!SWIG_AsVal_float(obj, &v)) {
2945 /*
2946 this is needed to make valgrind/purify happier.
2947 */
2948 memset((void*)&v, 0, sizeof(float));
2949 }
2950 return v;
2951 }
2952
2953
2954 SWIGINTERNSHORT int
2955 SWIG_Check_float(PyObject* obj)
2956 {
2957 return SWIG_AsVal_float(obj, (float*)0);
2958 }
2959
2960
2961 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2962 #define SWIG_From_float PyFloat_FromDouble
2963 /*@@*/
2964
2965 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2966 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2967 if (data) {
2968 Py_INCREF(data->m_obj);
2969 return data->m_obj;
2970 } else {
2971 Py_INCREF(Py_None);
2972 return Py_None;
2973 }
2974 }
2975
2976 // Figure out the type of the sizer item
2977
2978 struct wxPySizerItemInfo {
2979 wxPySizerItemInfo()
2980 : window(NULL), sizer(NULL), gotSize(false),
2981 size(wxDefaultSize), gotPos(false), pos(-1)
2982 {}
2983
2984 wxWindow* window;
2985 wxSizer* sizer;
2986 bool gotSize;
2987 wxSize size;
2988 bool gotPos;
2989 int pos;
2990 };
2991
2992 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2993
2994 wxPySizerItemInfo info;
2995 wxSize size;
2996 wxSize* sizePtr = &size;
2997
2998 // Find out what the type of the item is
2999 // try wxWindow
3000 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3001 PyErr_Clear();
3002 info.window = NULL;
3003
3004 // try wxSizer
3005 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3006 PyErr_Clear();
3007 info.sizer = NULL;
3008
3009 // try wxSize or (w,h)
3010 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3011 info.size = *sizePtr;
3012 info.gotSize = true;
3013 }
3014
3015 // or a single int
3016 if (checkIdx && PyInt_Check(item)) {
3017 info.pos = PyInt_AsLong(item);
3018 info.gotPos = true;
3019 }
3020 }
3021 }
3022
3023 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3024 // no expected type, figure out what kind of error message to generate
3025 if ( !checkSize && !checkIdx )
3026 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3027 else if ( checkSize && !checkIdx )
3028 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3029 else if ( !checkSize && checkIdx)
3030 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3031 else
3032 // can this one happen?
3033 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3034 }
3035
3036 return info;
3037 }
3038
3039 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3040 if (!self->GetClientObject())
3041 self->SetClientObject(new wxPyOORClientData(_self));
3042 }
3043 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3044
3045 wxPyUserData* data = NULL;
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3048 if ( userData && (info.window || info.sizer || info.gotSize) )
3049 data = new wxPyUserData(userData);
3050 wxPyEndBlockThreads(blocked);
3051
3052 // Now call the real Add method if a valid item type was found
3053 if ( info.window )
3054 return self->Add(info.window, proportion, flag, border, data);
3055 else if ( info.sizer )
3056 return self->Add(info.sizer, proportion, flag, border, data);
3057 else if (info.gotSize)
3058 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3059 proportion, flag, border, data);
3060 else
3061 return NULL;
3062 }
3063 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3064
3065 wxPyUserData* data = NULL;
3066 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3067 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3068 if ( userData && (info.window || info.sizer || info.gotSize) )
3069 data = new wxPyUserData(userData);
3070 wxPyEndBlockThreads(blocked);
3071
3072 // Now call the real Insert method if a valid item type was found
3073 if ( info.window )
3074 return self->Insert(before, info.window, proportion, flag, border, data);
3075 else if ( info.sizer )
3076 return self->Insert(before, info.sizer, proportion, flag, border, data);
3077 else if (info.gotSize)
3078 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3079 proportion, flag, border, data);
3080 else
3081 return NULL;
3082 }
3083 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3084
3085 wxPyUserData* data = NULL;
3086 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3087 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3088 if ( userData && (info.window || info.sizer || info.gotSize) )
3089 data = new wxPyUserData(userData);
3090 wxPyEndBlockThreads(blocked);
3091
3092 // Now call the real Prepend method if a valid item type was found
3093 if ( info.window )
3094 return self->Prepend(info.window, proportion, flag, border, data);
3095 else if ( info.sizer )
3096 return self->Prepend(info.sizer, proportion, flag, border, data);
3097 else if (info.gotSize)
3098 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3099 proportion, flag, border, data);
3100 else
3101 return NULL;
3102 }
3103 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3105 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3106 wxPyEndBlockThreads(blocked);
3107 if ( info.window )
3108 return self->Remove(info.window);
3109 else if ( info.sizer )
3110 return self->Remove(info.sizer);
3111 else if ( info.gotPos )
3112 return self->Remove(info.pos);
3113 else
3114 return false;
3115 }
3116 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3117 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3118 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3119 wxPyEndBlockThreads(blocked);
3120 if ( info.window )
3121 return self->Detach(info.window);
3122 else if ( info.sizer )
3123 return self->Detach(info.sizer);
3124 else if ( info.gotPos )
3125 return self->Detach(info.pos);
3126 else
3127 return false;
3128 }
3129 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3132 wxPyEndBlockThreads(blocked);
3133 if ( info.window )
3134 return self->GetItem(info.window);
3135 else if ( info.sizer )
3136 return self->GetItem(info.sizer);
3137 else if ( info.gotPos )
3138 return self->GetItem(info.pos);
3139 else
3140 return NULL;
3141 }
3142 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3143 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3144 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3145 wxPyEndBlockThreads(blocked);
3146 if ( info.window )
3147 self->SetItemMinSize(info.window, size);
3148 else if ( info.sizer )
3149 self->SetItemMinSize(info.sizer, size);
3150 else if ( info.gotPos )
3151 self->SetItemMinSize(info.pos, size);
3152 }
3153 static PyObject *wxSizer_GetChildren(wxSizer *self){
3154 wxSizerItemList& list = self->GetChildren();
3155 return wxPy_ConvertList(&list);
3156 }
3157 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3159 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3160 wxPyEndBlockThreads(blocked);
3161 if ( info.window )
3162 return self->Show(info.window, show, recursive);
3163 else if ( info.sizer )
3164 return self->Show(info.sizer, show, recursive);
3165 else if ( info.gotPos )
3166 return self->Show(info.pos, show);
3167 else
3168 return false;
3169 }
3170 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3172 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3173 wxPyEndBlockThreads(blocked);
3174 if ( info.window )
3175 return self->IsShown(info.window);
3176 else if ( info.sizer )
3177 return self->IsShown(info.sizer);
3178 else if ( info.gotPos )
3179 return self->IsShown(info.pos);
3180 else
3181 return false;
3182 }
3183
3184 // See pyclasses.h
3185 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3186 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3187 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3188
3189
3190
3191
3192 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3193 {
3194 if (source == Py_None) {
3195 **obj = wxGBPosition(-1,-1);
3196 return true;
3197 }
3198 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3199 }
3200
3201 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3202 {
3203 if (source == Py_None) {
3204 **obj = wxGBSpan(-1,-1);
3205 return true;
3206 }
3207 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3208 }
3209
3210
3211 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3212 self->SetRow(row);
3213 self->SetCol(col);
3214 }
3215 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 PyObject* tup = PyTuple_New(2);
3218 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3219 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3220 wxPyEndBlockThreads(blocked);
3221 return tup;
3222 }
3223 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3224 self->SetRowspan(rowspan);
3225 self->SetColspan(colspan);
3226 }
3227 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3228 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3229 PyObject* tup = PyTuple_New(2);
3230 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3231 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3232 wxPyEndBlockThreads(blocked);
3233 return tup;
3234 }
3235 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3236 wxPyUserData* data = NULL;
3237 if ( userData ) {
3238 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3239 data = new wxPyUserData(userData);
3240 wxPyEndBlockThreads(blocked);
3241 }
3242 return new wxGBSizerItem(window, pos, span, flag, border, data);
3243 }
3244 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3245 wxPyUserData* data = NULL;
3246 if ( userData ) {
3247 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3248 data = new wxPyUserData(userData);
3249 wxPyEndBlockThreads(blocked);
3250 }
3251 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3252 }
3253 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3254 wxPyUserData* data = NULL;
3255 if ( userData ) {
3256 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3257 data = new wxPyUserData(userData);
3258 wxPyEndBlockThreads(blocked);
3259 }
3260 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3261 }
3262 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3263 int row, col;
3264 self->GetEndPos(row, col);
3265 return wxGBPosition(row, col);
3266 }
3267 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3268
3269 wxPyUserData* data = NULL;
3270 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3271 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3272 if ( userData && (info.window || info.sizer || info.gotSize) )
3273 data = new wxPyUserData(userData);
3274 wxPyEndBlockThreads(blocked);
3275
3276 // Now call the real Add method if a valid item type was found
3277 if ( info.window )
3278 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3279 else if ( info.sizer )
3280 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3281 else if (info.gotSize)
3282 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3283 pos, span, flag, border, data);
3284 return NULL;
3285 }
3286
3287
3288 #ifdef __cplusplus
3289 extern "C" {
3290 #endif
3291 static int _wrap_EmptyString_set(PyObject *) {
3292 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3293 return 1;
3294 }
3295
3296
3297 static PyObject *_wrap_EmptyString_get(void) {
3298 PyObject *pyobj;
3299
3300 {
3301 #if wxUSE_UNICODE
3302 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3303 #else
3304 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3305 #endif
3306 }
3307 return pyobj;
3308 }
3309
3310
3311 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3312 PyObject *resultobj;
3313 wxObject *arg1 = (wxObject *) 0 ;
3314 wxString result;
3315 PyObject * obj0 = 0 ;
3316 char *kwnames[] = {
3317 (char *) "self", NULL
3318 };
3319
3320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3322 if (SWIG_arg_fail(1)) SWIG_fail;
3323 {
3324 PyThreadState* __tstate = wxPyBeginAllowThreads();
3325 result = wxObject_GetClassName(arg1);
3326
3327 wxPyEndAllowThreads(__tstate);
3328 if (PyErr_Occurred()) SWIG_fail;
3329 }
3330 {
3331 #if wxUSE_UNICODE
3332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3333 #else
3334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3335 #endif
3336 }
3337 return resultobj;
3338 fail:
3339 return NULL;
3340 }
3341
3342
3343 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3344 PyObject *resultobj;
3345 wxObject *arg1 = (wxObject *) 0 ;
3346 PyObject * obj0 = 0 ;
3347 char *kwnames[] = {
3348 (char *) "self", NULL
3349 };
3350
3351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3353 if (SWIG_arg_fail(1)) SWIG_fail;
3354 {
3355 PyThreadState* __tstate = wxPyBeginAllowThreads();
3356 wxObject_Destroy(arg1);
3357
3358 wxPyEndAllowThreads(__tstate);
3359 if (PyErr_Occurred()) SWIG_fail;
3360 }
3361 Py_INCREF(Py_None); resultobj = Py_None;
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3369 PyObject *obj;
3370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3371 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3372 Py_INCREF(obj);
3373 return Py_BuildValue((char *)"");
3374 }
3375 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3376 PyObject *resultobj;
3377 wxSize *arg1 = (wxSize *) 0 ;
3378 int arg2 ;
3379 PyObject * obj0 = 0 ;
3380 PyObject * obj1 = 0 ;
3381 char *kwnames[] = {
3382 (char *) "self",(char *) "x", NULL
3383 };
3384
3385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3387 if (SWIG_arg_fail(1)) SWIG_fail;
3388 {
3389 arg2 = (int)(SWIG_As_int(obj1));
3390 if (SWIG_arg_fail(2)) SWIG_fail;
3391 }
3392 if (arg1) (arg1)->x = arg2;
3393
3394 Py_INCREF(Py_None); resultobj = Py_None;
3395 return resultobj;
3396 fail:
3397 return NULL;
3398 }
3399
3400
3401 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3402 PyObject *resultobj;
3403 wxSize *arg1 = (wxSize *) 0 ;
3404 int result;
3405 PyObject * obj0 = 0 ;
3406 char *kwnames[] = {
3407 (char *) "self", NULL
3408 };
3409
3410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3412 if (SWIG_arg_fail(1)) SWIG_fail;
3413 result = (int) ((arg1)->x);
3414
3415 {
3416 resultobj = SWIG_From_int((int)(result));
3417 }
3418 return resultobj;
3419 fail:
3420 return NULL;
3421 }
3422
3423
3424 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3425 PyObject *resultobj;
3426 wxSize *arg1 = (wxSize *) 0 ;
3427 int arg2 ;
3428 PyObject * obj0 = 0 ;
3429 PyObject * obj1 = 0 ;
3430 char *kwnames[] = {
3431 (char *) "self",(char *) "y", NULL
3432 };
3433
3434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3436 if (SWIG_arg_fail(1)) SWIG_fail;
3437 {
3438 arg2 = (int)(SWIG_As_int(obj1));
3439 if (SWIG_arg_fail(2)) SWIG_fail;
3440 }
3441 if (arg1) (arg1)->y = arg2;
3442
3443 Py_INCREF(Py_None); resultobj = Py_None;
3444 return resultobj;
3445 fail:
3446 return NULL;
3447 }
3448
3449
3450 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3451 PyObject *resultobj;
3452 wxSize *arg1 = (wxSize *) 0 ;
3453 int result;
3454 PyObject * obj0 = 0 ;
3455 char *kwnames[] = {
3456 (char *) "self", NULL
3457 };
3458
3459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3461 if (SWIG_arg_fail(1)) SWIG_fail;
3462 result = (int) ((arg1)->y);
3463
3464 {
3465 resultobj = SWIG_From_int((int)(result));
3466 }
3467 return resultobj;
3468 fail:
3469 return NULL;
3470 }
3471
3472
3473 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3474 PyObject *resultobj;
3475 int arg1 = (int) 0 ;
3476 int arg2 = (int) 0 ;
3477 wxSize *result;
3478 PyObject * obj0 = 0 ;
3479 PyObject * obj1 = 0 ;
3480 char *kwnames[] = {
3481 (char *) "w",(char *) "h", NULL
3482 };
3483
3484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3485 if (obj0) {
3486 {
3487 arg1 = (int)(SWIG_As_int(obj0));
3488 if (SWIG_arg_fail(1)) SWIG_fail;
3489 }
3490 }
3491 if (obj1) {
3492 {
3493 arg2 = (int)(SWIG_As_int(obj1));
3494 if (SWIG_arg_fail(2)) SWIG_fail;
3495 }
3496 }
3497 {
3498 PyThreadState* __tstate = wxPyBeginAllowThreads();
3499 result = (wxSize *)new wxSize(arg1,arg2);
3500
3501 wxPyEndAllowThreads(__tstate);
3502 if (PyErr_Occurred()) SWIG_fail;
3503 }
3504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3505 return resultobj;
3506 fail:
3507 return NULL;
3508 }
3509
3510
3511 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3512 PyObject *resultobj;
3513 wxSize *arg1 = (wxSize *) 0 ;
3514 PyObject * obj0 = 0 ;
3515 char *kwnames[] = {
3516 (char *) "self", NULL
3517 };
3518
3519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3521 if (SWIG_arg_fail(1)) SWIG_fail;
3522 {
3523 PyThreadState* __tstate = wxPyBeginAllowThreads();
3524 delete arg1;
3525
3526 wxPyEndAllowThreads(__tstate);
3527 if (PyErr_Occurred()) SWIG_fail;
3528 }
3529 Py_INCREF(Py_None); resultobj = Py_None;
3530 return resultobj;
3531 fail:
3532 return NULL;
3533 }
3534
3535
3536 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3537 PyObject *resultobj;
3538 wxSize *arg1 = (wxSize *) 0 ;
3539 wxSize *arg2 = 0 ;
3540 bool result;
3541 wxSize temp2 ;
3542 PyObject * obj0 = 0 ;
3543 PyObject * obj1 = 0 ;
3544 char *kwnames[] = {
3545 (char *) "self",(char *) "sz", NULL
3546 };
3547
3548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3550 if (SWIG_arg_fail(1)) SWIG_fail;
3551 {
3552 arg2 = &temp2;
3553 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3554 }
3555 {
3556 PyThreadState* __tstate = wxPyBeginAllowThreads();
3557 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3558
3559 wxPyEndAllowThreads(__tstate);
3560 if (PyErr_Occurred()) SWIG_fail;
3561 }
3562 {
3563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3564 }
3565 return resultobj;
3566 fail:
3567 return NULL;
3568 }
3569
3570
3571 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3572 PyObject *resultobj;
3573 wxSize *arg1 = (wxSize *) 0 ;
3574 wxSize *arg2 = 0 ;
3575 bool result;
3576 wxSize temp2 ;
3577 PyObject * obj0 = 0 ;
3578 PyObject * obj1 = 0 ;
3579 char *kwnames[] = {
3580 (char *) "self",(char *) "sz", NULL
3581 };
3582
3583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3585 if (SWIG_arg_fail(1)) SWIG_fail;
3586 {
3587 arg2 = &temp2;
3588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3589 }
3590 {
3591 PyThreadState* __tstate = wxPyBeginAllowThreads();
3592 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3593
3594 wxPyEndAllowThreads(__tstate);
3595 if (PyErr_Occurred()) SWIG_fail;
3596 }
3597 {
3598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3599 }
3600 return resultobj;
3601 fail:
3602 return NULL;
3603 }
3604
3605
3606 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3607 PyObject *resultobj;
3608 wxSize *arg1 = (wxSize *) 0 ;
3609 wxSize *arg2 = 0 ;
3610 wxSize result;
3611 wxSize temp2 ;
3612 PyObject * obj0 = 0 ;
3613 PyObject * obj1 = 0 ;
3614 char *kwnames[] = {
3615 (char *) "self",(char *) "sz", NULL
3616 };
3617
3618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3620 if (SWIG_arg_fail(1)) SWIG_fail;
3621 {
3622 arg2 = &temp2;
3623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3624 }
3625 {
3626 PyThreadState* __tstate = wxPyBeginAllowThreads();
3627 result = (arg1)->operator +((wxSize const &)*arg2);
3628
3629 wxPyEndAllowThreads(__tstate);
3630 if (PyErr_Occurred()) SWIG_fail;
3631 }
3632 {
3633 wxSize * resultptr;
3634 resultptr = new wxSize((wxSize &)(result));
3635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3636 }
3637 return resultobj;
3638 fail:
3639 return NULL;
3640 }
3641
3642
3643 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3644 PyObject *resultobj;
3645 wxSize *arg1 = (wxSize *) 0 ;
3646 wxSize *arg2 = 0 ;
3647 wxSize result;
3648 wxSize temp2 ;
3649 PyObject * obj0 = 0 ;
3650 PyObject * obj1 = 0 ;
3651 char *kwnames[] = {
3652 (char *) "self",(char *) "sz", NULL
3653 };
3654
3655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3657 if (SWIG_arg_fail(1)) SWIG_fail;
3658 {
3659 arg2 = &temp2;
3660 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3661 }
3662 {
3663 PyThreadState* __tstate = wxPyBeginAllowThreads();
3664 result = (arg1)->operator -((wxSize const &)*arg2);
3665
3666 wxPyEndAllowThreads(__tstate);
3667 if (PyErr_Occurred()) SWIG_fail;
3668 }
3669 {
3670 wxSize * resultptr;
3671 resultptr = new wxSize((wxSize &)(result));
3672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3673 }
3674 return resultobj;
3675 fail:
3676 return NULL;
3677 }
3678
3679
3680 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3681 PyObject *resultobj;
3682 wxSize *arg1 = (wxSize *) 0 ;
3683 wxSize *arg2 = 0 ;
3684 wxSize temp2 ;
3685 PyObject * obj0 = 0 ;
3686 PyObject * obj1 = 0 ;
3687 char *kwnames[] = {
3688 (char *) "self",(char *) "sz", NULL
3689 };
3690
3691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3693 if (SWIG_arg_fail(1)) SWIG_fail;
3694 {
3695 arg2 = &temp2;
3696 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3697 }
3698 {
3699 PyThreadState* __tstate = wxPyBeginAllowThreads();
3700 (arg1)->IncTo((wxSize const &)*arg2);
3701
3702 wxPyEndAllowThreads(__tstate);
3703 if (PyErr_Occurred()) SWIG_fail;
3704 }
3705 Py_INCREF(Py_None); resultobj = Py_None;
3706 return resultobj;
3707 fail:
3708 return NULL;
3709 }
3710
3711
3712 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3713 PyObject *resultobj;
3714 wxSize *arg1 = (wxSize *) 0 ;
3715 wxSize *arg2 = 0 ;
3716 wxSize temp2 ;
3717 PyObject * obj0 = 0 ;
3718 PyObject * obj1 = 0 ;
3719 char *kwnames[] = {
3720 (char *) "self",(char *) "sz", NULL
3721 };
3722
3723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3725 if (SWIG_arg_fail(1)) SWIG_fail;
3726 {
3727 arg2 = &temp2;
3728 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3729 }
3730 {
3731 PyThreadState* __tstate = wxPyBeginAllowThreads();
3732 (arg1)->DecTo((wxSize const &)*arg2);
3733
3734 wxPyEndAllowThreads(__tstate);
3735 if (PyErr_Occurred()) SWIG_fail;
3736 }
3737 Py_INCREF(Py_None); resultobj = Py_None;
3738 return resultobj;
3739 fail:
3740 return NULL;
3741 }
3742
3743
3744 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3745 PyObject *resultobj;
3746 wxSize *arg1 = (wxSize *) 0 ;
3747 int arg2 ;
3748 int arg3 ;
3749 PyObject * obj0 = 0 ;
3750 PyObject * obj1 = 0 ;
3751 PyObject * obj2 = 0 ;
3752 char *kwnames[] = {
3753 (char *) "self",(char *) "w",(char *) "h", NULL
3754 };
3755
3756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3758 if (SWIG_arg_fail(1)) SWIG_fail;
3759 {
3760 arg2 = (int)(SWIG_As_int(obj1));
3761 if (SWIG_arg_fail(2)) SWIG_fail;
3762 }
3763 {
3764 arg3 = (int)(SWIG_As_int(obj2));
3765 if (SWIG_arg_fail(3)) SWIG_fail;
3766 }
3767 {
3768 PyThreadState* __tstate = wxPyBeginAllowThreads();
3769 (arg1)->Set(arg2,arg3);
3770
3771 wxPyEndAllowThreads(__tstate);
3772 if (PyErr_Occurred()) SWIG_fail;
3773 }
3774 Py_INCREF(Py_None); resultobj = Py_None;
3775 return resultobj;
3776 fail:
3777 return NULL;
3778 }
3779
3780
3781 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3782 PyObject *resultobj;
3783 wxSize *arg1 = (wxSize *) 0 ;
3784 int arg2 ;
3785 PyObject * obj0 = 0 ;
3786 PyObject * obj1 = 0 ;
3787 char *kwnames[] = {
3788 (char *) "self",(char *) "w", NULL
3789 };
3790
3791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3793 if (SWIG_arg_fail(1)) SWIG_fail;
3794 {
3795 arg2 = (int)(SWIG_As_int(obj1));
3796 if (SWIG_arg_fail(2)) SWIG_fail;
3797 }
3798 {
3799 PyThreadState* __tstate = wxPyBeginAllowThreads();
3800 (arg1)->SetWidth(arg2);
3801
3802 wxPyEndAllowThreads(__tstate);
3803 if (PyErr_Occurred()) SWIG_fail;
3804 }
3805 Py_INCREF(Py_None); resultobj = Py_None;
3806 return resultobj;
3807 fail:
3808 return NULL;
3809 }
3810
3811
3812 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3813 PyObject *resultobj;
3814 wxSize *arg1 = (wxSize *) 0 ;
3815 int arg2 ;
3816 PyObject * obj0 = 0 ;
3817 PyObject * obj1 = 0 ;
3818 char *kwnames[] = {
3819 (char *) "self",(char *) "h", NULL
3820 };
3821
3822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
3827 if (SWIG_arg_fail(2)) SWIG_fail;
3828 }
3829 {
3830 PyThreadState* __tstate = wxPyBeginAllowThreads();
3831 (arg1)->SetHeight(arg2);
3832
3833 wxPyEndAllowThreads(__tstate);
3834 if (PyErr_Occurred()) SWIG_fail;
3835 }
3836 Py_INCREF(Py_None); resultobj = Py_None;
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 wxSize *arg1 = (wxSize *) 0 ;
3846 int result;
3847 PyObject * obj0 = 0 ;
3848 char *kwnames[] = {
3849 (char *) "self", NULL
3850 };
3851
3852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3854 if (SWIG_arg_fail(1)) SWIG_fail;
3855 {
3856 PyThreadState* __tstate = wxPyBeginAllowThreads();
3857 result = (int)((wxSize const *)arg1)->GetWidth();
3858
3859 wxPyEndAllowThreads(__tstate);
3860 if (PyErr_Occurred()) SWIG_fail;
3861 }
3862 {
3863 resultobj = SWIG_From_int((int)(result));
3864 }
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxSize *arg1 = (wxSize *) 0 ;
3874 int result;
3875 PyObject * obj0 = 0 ;
3876 char *kwnames[] = {
3877 (char *) "self", NULL
3878 };
3879
3880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3882 if (SWIG_arg_fail(1)) SWIG_fail;
3883 {
3884 PyThreadState* __tstate = wxPyBeginAllowThreads();
3885 result = (int)((wxSize const *)arg1)->GetHeight();
3886
3887 wxPyEndAllowThreads(__tstate);
3888 if (PyErr_Occurred()) SWIG_fail;
3889 }
3890 {
3891 resultobj = SWIG_From_int((int)(result));
3892 }
3893 return resultobj;
3894 fail:
3895 return NULL;
3896 }
3897
3898
3899 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3900 PyObject *resultobj;
3901 wxSize *arg1 = (wxSize *) 0 ;
3902 bool result;
3903 PyObject * obj0 = 0 ;
3904 char *kwnames[] = {
3905 (char *) "self", NULL
3906 };
3907
3908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
3913 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3914
3915 wxPyEndAllowThreads(__tstate);
3916 if (PyErr_Occurred()) SWIG_fail;
3917 }
3918 {
3919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3920 }
3921 return resultobj;
3922 fail:
3923 return NULL;
3924 }
3925
3926
3927 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3928 PyObject *resultobj;
3929 wxSize *arg1 = (wxSize *) 0 ;
3930 wxSize *arg2 = 0 ;
3931 wxSize temp2 ;
3932 PyObject * obj0 = 0 ;
3933 PyObject * obj1 = 0 ;
3934 char *kwnames[] = {
3935 (char *) "self",(char *) "size", NULL
3936 };
3937
3938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
3943 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3944 }
3945 {
3946 PyThreadState* __tstate = wxPyBeginAllowThreads();
3947 (arg1)->SetDefaults((wxSize const &)*arg2);
3948
3949 wxPyEndAllowThreads(__tstate);
3950 if (PyErr_Occurred()) SWIG_fail;
3951 }
3952 Py_INCREF(Py_None); resultobj = Py_None;
3953 return resultobj;
3954 fail:
3955 return NULL;
3956 }
3957
3958
3959 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3960 PyObject *resultobj;
3961 wxSize *arg1 = (wxSize *) 0 ;
3962 PyObject *result;
3963 PyObject * obj0 = 0 ;
3964 char *kwnames[] = {
3965 (char *) "self", NULL
3966 };
3967
3968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3970 if (SWIG_arg_fail(1)) SWIG_fail;
3971 {
3972 PyThreadState* __tstate = wxPyBeginAllowThreads();
3973 result = (PyObject *)wxSize_Get(arg1);
3974
3975 wxPyEndAllowThreads(__tstate);
3976 if (PyErr_Occurred()) SWIG_fail;
3977 }
3978 resultobj = result;
3979 return resultobj;
3980 fail:
3981 return NULL;
3982 }
3983
3984
3985 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3986 PyObject *obj;
3987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3988 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3989 Py_INCREF(obj);
3990 return Py_BuildValue((char *)"");
3991 }
3992 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3993 PyObject *resultobj;
3994 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3995 double arg2 ;
3996 PyObject * obj0 = 0 ;
3997 PyObject * obj1 = 0 ;
3998 char *kwnames[] = {
3999 (char *) "self",(char *) "x", NULL
4000 };
4001
4002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4004 if (SWIG_arg_fail(1)) SWIG_fail;
4005 {
4006 arg2 = (double)(SWIG_As_double(obj1));
4007 if (SWIG_arg_fail(2)) SWIG_fail;
4008 }
4009 if (arg1) (arg1)->x = arg2;
4010
4011 Py_INCREF(Py_None); resultobj = Py_None;
4012 return resultobj;
4013 fail:
4014 return NULL;
4015 }
4016
4017
4018 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4019 PyObject *resultobj;
4020 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4021 double result;
4022 PyObject * obj0 = 0 ;
4023 char *kwnames[] = {
4024 (char *) "self", NULL
4025 };
4026
4027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4029 if (SWIG_arg_fail(1)) SWIG_fail;
4030 result = (double) ((arg1)->x);
4031
4032 {
4033 resultobj = SWIG_From_double((double)(result));
4034 }
4035 return resultobj;
4036 fail:
4037 return NULL;
4038 }
4039
4040
4041 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4042 PyObject *resultobj;
4043 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4044 double arg2 ;
4045 PyObject * obj0 = 0 ;
4046 PyObject * obj1 = 0 ;
4047 char *kwnames[] = {
4048 (char *) "self",(char *) "y", NULL
4049 };
4050
4051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4053 if (SWIG_arg_fail(1)) SWIG_fail;
4054 {
4055 arg2 = (double)(SWIG_As_double(obj1));
4056 if (SWIG_arg_fail(2)) SWIG_fail;
4057 }
4058 if (arg1) (arg1)->y = arg2;
4059
4060 Py_INCREF(Py_None); resultobj = Py_None;
4061 return resultobj;
4062 fail:
4063 return NULL;
4064 }
4065
4066
4067 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4068 PyObject *resultobj;
4069 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4070 double result;
4071 PyObject * obj0 = 0 ;
4072 char *kwnames[] = {
4073 (char *) "self", NULL
4074 };
4075
4076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4078 if (SWIG_arg_fail(1)) SWIG_fail;
4079 result = (double) ((arg1)->y);
4080
4081 {
4082 resultobj = SWIG_From_double((double)(result));
4083 }
4084 return resultobj;
4085 fail:
4086 return NULL;
4087 }
4088
4089
4090 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4091 PyObject *resultobj;
4092 double arg1 = (double) 0.0 ;
4093 double arg2 = (double) 0.0 ;
4094 wxRealPoint *result;
4095 PyObject * obj0 = 0 ;
4096 PyObject * obj1 = 0 ;
4097 char *kwnames[] = {
4098 (char *) "x",(char *) "y", NULL
4099 };
4100
4101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4102 if (obj0) {
4103 {
4104 arg1 = (double)(SWIG_As_double(obj0));
4105 if (SWIG_arg_fail(1)) SWIG_fail;
4106 }
4107 }
4108 if (obj1) {
4109 {
4110 arg2 = (double)(SWIG_As_double(obj1));
4111 if (SWIG_arg_fail(2)) SWIG_fail;
4112 }
4113 }
4114 {
4115 PyThreadState* __tstate = wxPyBeginAllowThreads();
4116 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4117
4118 wxPyEndAllowThreads(__tstate);
4119 if (PyErr_Occurred()) SWIG_fail;
4120 }
4121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4122 return resultobj;
4123 fail:
4124 return NULL;
4125 }
4126
4127
4128 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4129 PyObject *resultobj;
4130 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4131 PyObject * obj0 = 0 ;
4132 char *kwnames[] = {
4133 (char *) "self", NULL
4134 };
4135
4136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4138 if (SWIG_arg_fail(1)) SWIG_fail;
4139 {
4140 PyThreadState* __tstate = wxPyBeginAllowThreads();
4141 delete arg1;
4142
4143 wxPyEndAllowThreads(__tstate);
4144 if (PyErr_Occurred()) SWIG_fail;
4145 }
4146 Py_INCREF(Py_None); resultobj = Py_None;
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4154 PyObject *resultobj;
4155 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4156 wxRealPoint *arg2 = 0 ;
4157 bool result;
4158 wxRealPoint temp2 ;
4159 PyObject * obj0 = 0 ;
4160 PyObject * obj1 = 0 ;
4161 char *kwnames[] = {
4162 (char *) "self",(char *) "pt", NULL
4163 };
4164
4165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4167 if (SWIG_arg_fail(1)) SWIG_fail;
4168 {
4169 arg2 = &temp2;
4170 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4171 }
4172 {
4173 PyThreadState* __tstate = wxPyBeginAllowThreads();
4174 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4175
4176 wxPyEndAllowThreads(__tstate);
4177 if (PyErr_Occurred()) SWIG_fail;
4178 }
4179 {
4180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4181 }
4182 return resultobj;
4183 fail:
4184 return NULL;
4185 }
4186
4187
4188 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4189 PyObject *resultobj;
4190 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4191 wxRealPoint *arg2 = 0 ;
4192 bool result;
4193 wxRealPoint temp2 ;
4194 PyObject * obj0 = 0 ;
4195 PyObject * obj1 = 0 ;
4196 char *kwnames[] = {
4197 (char *) "self",(char *) "pt", NULL
4198 };
4199
4200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4202 if (SWIG_arg_fail(1)) SWIG_fail;
4203 {
4204 arg2 = &temp2;
4205 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4206 }
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4210
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4216 }
4217 return resultobj;
4218 fail:
4219 return NULL;
4220 }
4221
4222
4223 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4224 PyObject *resultobj;
4225 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4226 wxRealPoint *arg2 = 0 ;
4227 wxRealPoint result;
4228 wxRealPoint temp2 ;
4229 PyObject * obj0 = 0 ;
4230 PyObject * obj1 = 0 ;
4231 char *kwnames[] = {
4232 (char *) "self",(char *) "pt", NULL
4233 };
4234
4235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4237 if (SWIG_arg_fail(1)) SWIG_fail;
4238 {
4239 arg2 = &temp2;
4240 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4241 }
4242 {
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4245
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 {
4250 wxRealPoint * resultptr;
4251 resultptr = new wxRealPoint((wxRealPoint &)(result));
4252 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4253 }
4254 return resultobj;
4255 fail:
4256 return NULL;
4257 }
4258
4259
4260 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4261 PyObject *resultobj;
4262 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4263 wxRealPoint *arg2 = 0 ;
4264 wxRealPoint result;
4265 wxRealPoint temp2 ;
4266 PyObject * obj0 = 0 ;
4267 PyObject * obj1 = 0 ;
4268 char *kwnames[] = {
4269 (char *) "self",(char *) "pt", NULL
4270 };
4271
4272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4274 if (SWIG_arg_fail(1)) SWIG_fail;
4275 {
4276 arg2 = &temp2;
4277 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4278 }
4279 {
4280 PyThreadState* __tstate = wxPyBeginAllowThreads();
4281 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4282
4283 wxPyEndAllowThreads(__tstate);
4284 if (PyErr_Occurred()) SWIG_fail;
4285 }
4286 {
4287 wxRealPoint * resultptr;
4288 resultptr = new wxRealPoint((wxRealPoint &)(result));
4289 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4290 }
4291 return resultobj;
4292 fail:
4293 return NULL;
4294 }
4295
4296
4297 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4298 PyObject *resultobj;
4299 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4300 double arg2 ;
4301 double arg3 ;
4302 PyObject * obj0 = 0 ;
4303 PyObject * obj1 = 0 ;
4304 PyObject * obj2 = 0 ;
4305 char *kwnames[] = {
4306 (char *) "self",(char *) "x",(char *) "y", NULL
4307 };
4308
4309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4311 if (SWIG_arg_fail(1)) SWIG_fail;
4312 {
4313 arg2 = (double)(SWIG_As_double(obj1));
4314 if (SWIG_arg_fail(2)) SWIG_fail;
4315 }
4316 {
4317 arg3 = (double)(SWIG_As_double(obj2));
4318 if (SWIG_arg_fail(3)) SWIG_fail;
4319 }
4320 {
4321 PyThreadState* __tstate = wxPyBeginAllowThreads();
4322 wxRealPoint_Set(arg1,arg2,arg3);
4323
4324 wxPyEndAllowThreads(__tstate);
4325 if (PyErr_Occurred()) SWIG_fail;
4326 }
4327 Py_INCREF(Py_None); resultobj = Py_None;
4328 return resultobj;
4329 fail:
4330 return NULL;
4331 }
4332
4333
4334 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4335 PyObject *resultobj;
4336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4337 PyObject *result;
4338 PyObject * obj0 = 0 ;
4339 char *kwnames[] = {
4340 (char *) "self", NULL
4341 };
4342
4343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4345 if (SWIG_arg_fail(1)) SWIG_fail;
4346 {
4347 PyThreadState* __tstate = wxPyBeginAllowThreads();
4348 result = (PyObject *)wxRealPoint_Get(arg1);
4349
4350 wxPyEndAllowThreads(__tstate);
4351 if (PyErr_Occurred()) SWIG_fail;
4352 }
4353 resultobj = result;
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
4360 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4361 PyObject *obj;
4362 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4363 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4364 Py_INCREF(obj);
4365 return Py_BuildValue((char *)"");
4366 }
4367 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4368 PyObject *resultobj;
4369 wxPoint *arg1 = (wxPoint *) 0 ;
4370 int arg2 ;
4371 PyObject * obj0 = 0 ;
4372 PyObject * obj1 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "self",(char *) "x", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4379 if (SWIG_arg_fail(1)) SWIG_fail;
4380 {
4381 arg2 = (int)(SWIG_As_int(obj1));
4382 if (SWIG_arg_fail(2)) SWIG_fail;
4383 }
4384 if (arg1) (arg1)->x = arg2;
4385
4386 Py_INCREF(Py_None); resultobj = Py_None;
4387 return resultobj;
4388 fail:
4389 return NULL;
4390 }
4391
4392
4393 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4394 PyObject *resultobj;
4395 wxPoint *arg1 = (wxPoint *) 0 ;
4396 int result;
4397 PyObject * obj0 = 0 ;
4398 char *kwnames[] = {
4399 (char *) "self", NULL
4400 };
4401
4402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4404 if (SWIG_arg_fail(1)) SWIG_fail;
4405 result = (int) ((arg1)->x);
4406
4407 {
4408 resultobj = SWIG_From_int((int)(result));
4409 }
4410 return resultobj;
4411 fail:
4412 return NULL;
4413 }
4414
4415
4416 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4417 PyObject *resultobj;
4418 wxPoint *arg1 = (wxPoint *) 0 ;
4419 int arg2 ;
4420 PyObject * obj0 = 0 ;
4421 PyObject * obj1 = 0 ;
4422 char *kwnames[] = {
4423 (char *) "self",(char *) "y", NULL
4424 };
4425
4426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4428 if (SWIG_arg_fail(1)) SWIG_fail;
4429 {
4430 arg2 = (int)(SWIG_As_int(obj1));
4431 if (SWIG_arg_fail(2)) SWIG_fail;
4432 }
4433 if (arg1) (arg1)->y = arg2;
4434
4435 Py_INCREF(Py_None); resultobj = Py_None;
4436 return resultobj;
4437 fail:
4438 return NULL;
4439 }
4440
4441
4442 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4443 PyObject *resultobj;
4444 wxPoint *arg1 = (wxPoint *) 0 ;
4445 int result;
4446 PyObject * obj0 = 0 ;
4447 char *kwnames[] = {
4448 (char *) "self", NULL
4449 };
4450
4451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4453 if (SWIG_arg_fail(1)) SWIG_fail;
4454 result = (int) ((arg1)->y);
4455
4456 {
4457 resultobj = SWIG_From_int((int)(result));
4458 }
4459 return resultobj;
4460 fail:
4461 return NULL;
4462 }
4463
4464
4465 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4466 PyObject *resultobj;
4467 int arg1 = (int) 0 ;
4468 int arg2 = (int) 0 ;
4469 wxPoint *result;
4470 PyObject * obj0 = 0 ;
4471 PyObject * obj1 = 0 ;
4472 char *kwnames[] = {
4473 (char *) "x",(char *) "y", NULL
4474 };
4475
4476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4477 if (obj0) {
4478 {
4479 arg1 = (int)(SWIG_As_int(obj0));
4480 if (SWIG_arg_fail(1)) SWIG_fail;
4481 }
4482 }
4483 if (obj1) {
4484 {
4485 arg2 = (int)(SWIG_As_int(obj1));
4486 if (SWIG_arg_fail(2)) SWIG_fail;
4487 }
4488 }
4489 {
4490 PyThreadState* __tstate = wxPyBeginAllowThreads();
4491 result = (wxPoint *)new wxPoint(arg1,arg2);
4492
4493 wxPyEndAllowThreads(__tstate);
4494 if (PyErr_Occurred()) SWIG_fail;
4495 }
4496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4497 return resultobj;
4498 fail:
4499 return NULL;
4500 }
4501
4502
4503 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj;
4505 wxPoint *arg1 = (wxPoint *) 0 ;
4506 PyObject * obj0 = 0 ;
4507 char *kwnames[] = {
4508 (char *) "self", NULL
4509 };
4510
4511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4513 if (SWIG_arg_fail(1)) SWIG_fail;
4514 {
4515 PyThreadState* __tstate = wxPyBeginAllowThreads();
4516 delete arg1;
4517
4518 wxPyEndAllowThreads(__tstate);
4519 if (PyErr_Occurred()) SWIG_fail;
4520 }
4521 Py_INCREF(Py_None); resultobj = Py_None;
4522 return resultobj;
4523 fail:
4524 return NULL;
4525 }
4526
4527
4528 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4529 PyObject *resultobj;
4530 wxPoint *arg1 = (wxPoint *) 0 ;
4531 wxPoint *arg2 = 0 ;
4532 bool result;
4533 wxPoint temp2 ;
4534 PyObject * obj0 = 0 ;
4535 PyObject * obj1 = 0 ;
4536 char *kwnames[] = {
4537 (char *) "self",(char *) "pt", NULL
4538 };
4539
4540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4542 if (SWIG_arg_fail(1)) SWIG_fail;
4543 {
4544 arg2 = &temp2;
4545 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4546 }
4547 {
4548 PyThreadState* __tstate = wxPyBeginAllowThreads();
4549 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4550
4551 wxPyEndAllowThreads(__tstate);
4552 if (PyErr_Occurred()) SWIG_fail;
4553 }
4554 {
4555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4556 }
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4564 PyObject *resultobj;
4565 wxPoint *arg1 = (wxPoint *) 0 ;
4566 wxPoint *arg2 = 0 ;
4567 bool result;
4568 wxPoint temp2 ;
4569 PyObject * obj0 = 0 ;
4570 PyObject * obj1 = 0 ;
4571 char *kwnames[] = {
4572 (char *) "self",(char *) "pt", NULL
4573 };
4574
4575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4577 if (SWIG_arg_fail(1)) SWIG_fail;
4578 {
4579 arg2 = &temp2;
4580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4581 }
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4585
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 {
4590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4591 }
4592 return resultobj;
4593 fail:
4594 return NULL;
4595 }
4596
4597
4598 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4599 PyObject *resultobj;
4600 wxPoint *arg1 = (wxPoint *) 0 ;
4601 wxPoint *arg2 = 0 ;
4602 wxPoint result;
4603 wxPoint temp2 ;
4604 PyObject * obj0 = 0 ;
4605 PyObject * obj1 = 0 ;
4606 char *kwnames[] = {
4607 (char *) "self",(char *) "pt", NULL
4608 };
4609
4610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4612 if (SWIG_arg_fail(1)) SWIG_fail;
4613 {
4614 arg2 = &temp2;
4615 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 result = (arg1)->operator +((wxPoint const &)*arg2);
4620
4621 wxPyEndAllowThreads(__tstate);
4622 if (PyErr_Occurred()) SWIG_fail;
4623 }
4624 {
4625 wxPoint * resultptr;
4626 resultptr = new wxPoint((wxPoint &)(result));
4627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4628 }
4629 return resultobj;
4630 fail:
4631 return NULL;
4632 }
4633
4634
4635 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4636 PyObject *resultobj;
4637 wxPoint *arg1 = (wxPoint *) 0 ;
4638 wxPoint *arg2 = 0 ;
4639 wxPoint result;
4640 wxPoint temp2 ;
4641 PyObject * obj0 = 0 ;
4642 PyObject * obj1 = 0 ;
4643 char *kwnames[] = {
4644 (char *) "self",(char *) "pt", NULL
4645 };
4646
4647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4649 if (SWIG_arg_fail(1)) SWIG_fail;
4650 {
4651 arg2 = &temp2;
4652 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4653 }
4654 {
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 result = (arg1)->operator -((wxPoint const &)*arg2);
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 {
4662 wxPoint * resultptr;
4663 resultptr = new wxPoint((wxPoint &)(result));
4664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4665 }
4666 return resultobj;
4667 fail:
4668 return NULL;
4669 }
4670
4671
4672 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4673 PyObject *resultobj;
4674 wxPoint *arg1 = (wxPoint *) 0 ;
4675 wxPoint *arg2 = 0 ;
4676 wxPoint *result;
4677 wxPoint temp2 ;
4678 PyObject * obj0 = 0 ;
4679 PyObject * obj1 = 0 ;
4680 char *kwnames[] = {
4681 (char *) "self",(char *) "pt", NULL
4682 };
4683
4684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4686 if (SWIG_arg_fail(1)) SWIG_fail;
4687 {
4688 arg2 = &temp2;
4689 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4690 }
4691 {
4692 PyThreadState* __tstate = wxPyBeginAllowThreads();
4693 {
4694 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4695 result = (wxPoint *) &_result_ref;
4696 }
4697
4698 wxPyEndAllowThreads(__tstate);
4699 if (PyErr_Occurred()) SWIG_fail;
4700 }
4701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj;
4710 wxPoint *arg1 = (wxPoint *) 0 ;
4711 wxPoint *arg2 = 0 ;
4712 wxPoint *result;
4713 wxPoint temp2 ;
4714 PyObject * obj0 = 0 ;
4715 PyObject * obj1 = 0 ;
4716 char *kwnames[] = {
4717 (char *) "self",(char *) "pt", NULL
4718 };
4719
4720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4722 if (SWIG_arg_fail(1)) SWIG_fail;
4723 {
4724 arg2 = &temp2;
4725 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 {
4730 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4731 result = (wxPoint *) &_result_ref;
4732 }
4733
4734 wxPyEndAllowThreads(__tstate);
4735 if (PyErr_Occurred()) SWIG_fail;
4736 }
4737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4738 return resultobj;
4739 fail:
4740 return NULL;
4741 }
4742
4743
4744 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4745 PyObject *resultobj;
4746 wxPoint *arg1 = (wxPoint *) 0 ;
4747 long arg2 ;
4748 long arg3 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 PyObject * obj2 = 0 ;
4752 char *kwnames[] = {
4753 (char *) "self",(char *) "x",(char *) "y", NULL
4754 };
4755
4756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4758 if (SWIG_arg_fail(1)) SWIG_fail;
4759 {
4760 arg2 = (long)(SWIG_As_long(obj1));
4761 if (SWIG_arg_fail(2)) SWIG_fail;
4762 }
4763 {
4764 arg3 = (long)(SWIG_As_long(obj2));
4765 if (SWIG_arg_fail(3)) SWIG_fail;
4766 }
4767 {
4768 PyThreadState* __tstate = wxPyBeginAllowThreads();
4769 wxPoint_Set(arg1,arg2,arg3);
4770
4771 wxPyEndAllowThreads(__tstate);
4772 if (PyErr_Occurred()) SWIG_fail;
4773 }
4774 Py_INCREF(Py_None); resultobj = Py_None;
4775 return resultobj;
4776 fail:
4777 return NULL;
4778 }
4779
4780
4781 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4782 PyObject *resultobj;
4783 wxPoint *arg1 = (wxPoint *) 0 ;
4784 PyObject *result;
4785 PyObject * obj0 = 0 ;
4786 char *kwnames[] = {
4787 (char *) "self", NULL
4788 };
4789
4790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4792 if (SWIG_arg_fail(1)) SWIG_fail;
4793 {
4794 PyThreadState* __tstate = wxPyBeginAllowThreads();
4795 result = (PyObject *)wxPoint_Get(arg1);
4796
4797 wxPyEndAllowThreads(__tstate);
4798 if (PyErr_Occurred()) SWIG_fail;
4799 }
4800 resultobj = result;
4801 return resultobj;
4802 fail:
4803 return NULL;
4804 }
4805
4806
4807 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4808 PyObject *obj;
4809 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4810 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4811 Py_INCREF(obj);
4812 return Py_BuildValue((char *)"");
4813 }
4814 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4815 PyObject *resultobj;
4816 int arg1 = (int) 0 ;
4817 int arg2 = (int) 0 ;
4818 int arg3 = (int) 0 ;
4819 int arg4 = (int) 0 ;
4820 wxRect *result;
4821 PyObject * obj0 = 0 ;
4822 PyObject * obj1 = 0 ;
4823 PyObject * obj2 = 0 ;
4824 PyObject * obj3 = 0 ;
4825 char *kwnames[] = {
4826 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4827 };
4828
4829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4830 if (obj0) {
4831 {
4832 arg1 = (int)(SWIG_As_int(obj0));
4833 if (SWIG_arg_fail(1)) SWIG_fail;
4834 }
4835 }
4836 if (obj1) {
4837 {
4838 arg2 = (int)(SWIG_As_int(obj1));
4839 if (SWIG_arg_fail(2)) SWIG_fail;
4840 }
4841 }
4842 if (obj2) {
4843 {
4844 arg3 = (int)(SWIG_As_int(obj2));
4845 if (SWIG_arg_fail(3)) SWIG_fail;
4846 }
4847 }
4848 if (obj3) {
4849 {
4850 arg4 = (int)(SWIG_As_int(obj3));
4851 if (SWIG_arg_fail(4)) SWIG_fail;
4852 }
4853 }
4854 {
4855 PyThreadState* __tstate = wxPyBeginAllowThreads();
4856 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4857
4858 wxPyEndAllowThreads(__tstate);
4859 if (PyErr_Occurred()) SWIG_fail;
4860 }
4861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4862 return resultobj;
4863 fail:
4864 return NULL;
4865 }
4866
4867
4868 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4869 PyObject *resultobj;
4870 wxPoint *arg1 = 0 ;
4871 wxPoint *arg2 = 0 ;
4872 wxRect *result;
4873 wxPoint temp1 ;
4874 wxPoint temp2 ;
4875 PyObject * obj0 = 0 ;
4876 PyObject * obj1 = 0 ;
4877 char *kwnames[] = {
4878 (char *) "topLeft",(char *) "bottomRight", NULL
4879 };
4880
4881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4882 {
4883 arg1 = &temp1;
4884 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4885 }
4886 {
4887 arg2 = &temp2;
4888 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4889 }
4890 {
4891 PyThreadState* __tstate = wxPyBeginAllowThreads();
4892 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4893
4894 wxPyEndAllowThreads(__tstate);
4895 if (PyErr_Occurred()) SWIG_fail;
4896 }
4897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4898 return resultobj;
4899 fail:
4900 return NULL;
4901 }
4902
4903
4904 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4905 PyObject *resultobj;
4906 wxPoint *arg1 = 0 ;
4907 wxSize *arg2 = 0 ;
4908 wxRect *result;
4909 wxPoint temp1 ;
4910 wxSize temp2 ;
4911 PyObject * obj0 = 0 ;
4912 PyObject * obj1 = 0 ;
4913 char *kwnames[] = {
4914 (char *) "pos",(char *) "size", NULL
4915 };
4916
4917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4918 {
4919 arg1 = &temp1;
4920 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4921 }
4922 {
4923 arg2 = &temp2;
4924 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4925 }
4926 {
4927 PyThreadState* __tstate = wxPyBeginAllowThreads();
4928 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4929
4930 wxPyEndAllowThreads(__tstate);
4931 if (PyErr_Occurred()) SWIG_fail;
4932 }
4933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4941 PyObject *resultobj;
4942 wxSize *arg1 = 0 ;
4943 wxRect *result;
4944 wxSize temp1 ;
4945 PyObject * obj0 = 0 ;
4946 char *kwnames[] = {
4947 (char *) "size", NULL
4948 };
4949
4950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4951 {
4952 arg1 = &temp1;
4953 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4954 }
4955 {
4956 PyThreadState* __tstate = wxPyBeginAllowThreads();
4957 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4958
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj;
4971 wxRect *arg1 = (wxRect *) 0 ;
4972 PyObject * obj0 = 0 ;
4973 char *kwnames[] = {
4974 (char *) "self", NULL
4975 };
4976
4977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4979 if (SWIG_arg_fail(1)) SWIG_fail;
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 delete arg1;
4983
4984 wxPyEndAllowThreads(__tstate);
4985 if (PyErr_Occurred()) SWIG_fail;
4986 }
4987 Py_INCREF(Py_None); resultobj = Py_None;
4988 return resultobj;
4989 fail:
4990 return NULL;
4991 }
4992
4993
4994 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4995 PyObject *resultobj;
4996 wxRect *arg1 = (wxRect *) 0 ;
4997 int result;
4998 PyObject * obj0 = 0 ;
4999 char *kwnames[] = {
5000 (char *) "self", NULL
5001 };
5002
5003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5005 if (SWIG_arg_fail(1)) SWIG_fail;
5006 {
5007 PyThreadState* __tstate = wxPyBeginAllowThreads();
5008 result = (int)((wxRect const *)arg1)->GetX();
5009
5010 wxPyEndAllowThreads(__tstate);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 {
5014 resultobj = SWIG_From_int((int)(result));
5015 }
5016 return resultobj;
5017 fail:
5018 return NULL;
5019 }
5020
5021
5022 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5023 PyObject *resultobj;
5024 wxRect *arg1 = (wxRect *) 0 ;
5025 int arg2 ;
5026 PyObject * obj0 = 0 ;
5027 PyObject * obj1 = 0 ;
5028 char *kwnames[] = {
5029 (char *) "self",(char *) "x", NULL
5030 };
5031
5032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
5037 if (SWIG_arg_fail(2)) SWIG_fail;
5038 }
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 (arg1)->SetX(arg2);
5042
5043 wxPyEndAllowThreads(__tstate);
5044 if (PyErr_Occurred()) SWIG_fail;
5045 }
5046 Py_INCREF(Py_None); resultobj = Py_None;
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5054 PyObject *resultobj;
5055 wxRect *arg1 = (wxRect *) 0 ;
5056 int result;
5057 PyObject * obj0 = 0 ;
5058 char *kwnames[] = {
5059 (char *) "self", NULL
5060 };
5061
5062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5064 if (SWIG_arg_fail(1)) SWIG_fail;
5065 {
5066 PyThreadState* __tstate = wxPyBeginAllowThreads();
5067 result = (int)(arg1)->GetY();
5068
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 {
5073 resultobj = SWIG_From_int((int)(result));
5074 }
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5082 PyObject *resultobj;
5083 wxRect *arg1 = (wxRect *) 0 ;
5084 int arg2 ;
5085 PyObject * obj0 = 0 ;
5086 PyObject * obj1 = 0 ;
5087 char *kwnames[] = {
5088 (char *) "self",(char *) "y", NULL
5089 };
5090
5091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
5096 if (SWIG_arg_fail(2)) SWIG_fail;
5097 }
5098 {
5099 PyThreadState* __tstate = wxPyBeginAllowThreads();
5100 (arg1)->SetY(arg2);
5101
5102 wxPyEndAllowThreads(__tstate);
5103 if (PyErr_Occurred()) SWIG_fail;
5104 }
5105 Py_INCREF(Py_None); resultobj = Py_None;
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj;
5114 wxRect *arg1 = (wxRect *) 0 ;
5115 int result;
5116 PyObject * obj0 = 0 ;
5117 char *kwnames[] = {
5118 (char *) "self", NULL
5119 };
5120
5121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5123 if (SWIG_arg_fail(1)) SWIG_fail;
5124 {
5125 PyThreadState* __tstate = wxPyBeginAllowThreads();
5126 result = (int)((wxRect const *)arg1)->GetWidth();
5127
5128 wxPyEndAllowThreads(__tstate);
5129 if (PyErr_Occurred()) SWIG_fail;
5130 }
5131 {
5132 resultobj = SWIG_From_int((int)(result));
5133 }
5134 return resultobj;
5135 fail:
5136 return NULL;
5137 }
5138
5139
5140 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5141 PyObject *resultobj;
5142 wxRect *arg1 = (wxRect *) 0 ;
5143 int arg2 ;
5144 PyObject * obj0 = 0 ;
5145 PyObject * obj1 = 0 ;
5146 char *kwnames[] = {
5147 (char *) "self",(char *) "w", NULL
5148 };
5149
5150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
5155 if (SWIG_arg_fail(2)) SWIG_fail;
5156 }
5157 {
5158 PyThreadState* __tstate = wxPyBeginAllowThreads();
5159 (arg1)->SetWidth(arg2);
5160
5161 wxPyEndAllowThreads(__tstate);
5162 if (PyErr_Occurred()) SWIG_fail;
5163 }
5164 Py_INCREF(Py_None); resultobj = Py_None;
5165 return resultobj;
5166 fail:
5167 return NULL;
5168 }
5169
5170
5171 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5172 PyObject *resultobj;
5173 wxRect *arg1 = (wxRect *) 0 ;
5174 int result;
5175 PyObject * obj0 = 0 ;
5176 char *kwnames[] = {
5177 (char *) "self", NULL
5178 };
5179
5180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5182 if (SWIG_arg_fail(1)) SWIG_fail;
5183 {
5184 PyThreadState* __tstate = wxPyBeginAllowThreads();
5185 result = (int)((wxRect const *)arg1)->GetHeight();
5186
5187 wxPyEndAllowThreads(__tstate);
5188 if (PyErr_Occurred()) SWIG_fail;
5189 }
5190 {
5191 resultobj = SWIG_From_int((int)(result));
5192 }
5193 return resultobj;
5194 fail:
5195 return NULL;
5196 }
5197
5198
5199 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5200 PyObject *resultobj;
5201 wxRect *arg1 = (wxRect *) 0 ;
5202 int arg2 ;
5203 PyObject * obj0 = 0 ;
5204 PyObject * obj1 = 0 ;
5205 char *kwnames[] = {
5206 (char *) "self",(char *) "h", NULL
5207 };
5208
5209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
5214 if (SWIG_arg_fail(2)) SWIG_fail;
5215 }
5216 {
5217 PyThreadState* __tstate = wxPyBeginAllowThreads();
5218 (arg1)->SetHeight(arg2);
5219
5220 wxPyEndAllowThreads(__tstate);
5221 if (PyErr_Occurred()) SWIG_fail;
5222 }
5223 Py_INCREF(Py_None); resultobj = Py_None;
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5231 PyObject *resultobj;
5232 wxRect *arg1 = (wxRect *) 0 ;
5233 wxPoint result;
5234 PyObject * obj0 = 0 ;
5235 char *kwnames[] = {
5236 (char *) "self", NULL
5237 };
5238
5239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5241 if (SWIG_arg_fail(1)) SWIG_fail;
5242 {
5243 PyThreadState* __tstate = wxPyBeginAllowThreads();
5244 result = ((wxRect const *)arg1)->GetPosition();
5245
5246 wxPyEndAllowThreads(__tstate);
5247 if (PyErr_Occurred()) SWIG_fail;
5248 }
5249 {
5250 wxPoint * resultptr;
5251 resultptr = new wxPoint((wxPoint &)(result));
5252 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5253 }
5254 return resultobj;
5255 fail:
5256 return NULL;
5257 }
5258
5259
5260 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5261 PyObject *resultobj;
5262 wxRect *arg1 = (wxRect *) 0 ;
5263 wxPoint *arg2 = 0 ;
5264 wxPoint temp2 ;
5265 PyObject * obj0 = 0 ;
5266 PyObject * obj1 = 0 ;
5267 char *kwnames[] = {
5268 (char *) "self",(char *) "p", NULL
5269 };
5270
5271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5276 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5277 }
5278 {
5279 PyThreadState* __tstate = wxPyBeginAllowThreads();
5280 (arg1)->SetPosition((wxPoint const &)*arg2);
5281
5282 wxPyEndAllowThreads(__tstate);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 Py_INCREF(Py_None); resultobj = Py_None;
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj;
5294 wxRect *arg1 = (wxRect *) 0 ;
5295 wxSize result;
5296 PyObject * obj0 = 0 ;
5297 char *kwnames[] = {
5298 (char *) "self", NULL
5299 };
5300
5301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5303 if (SWIG_arg_fail(1)) SWIG_fail;
5304 {
5305 PyThreadState* __tstate = wxPyBeginAllowThreads();
5306 result = ((wxRect const *)arg1)->GetSize();
5307
5308 wxPyEndAllowThreads(__tstate);
5309 if (PyErr_Occurred()) SWIG_fail;
5310 }
5311 {
5312 wxSize * resultptr;
5313 resultptr = new wxSize((wxSize &)(result));
5314 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5315 }
5316 return resultobj;
5317 fail:
5318 return NULL;
5319 }
5320
5321
5322 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5323 PyObject *resultobj;
5324 wxRect *arg1 = (wxRect *) 0 ;
5325 wxSize *arg2 = 0 ;
5326 wxSize temp2 ;
5327 PyObject * obj0 = 0 ;
5328 PyObject * obj1 = 0 ;
5329 char *kwnames[] = {
5330 (char *) "self",(char *) "s", NULL
5331 };
5332
5333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5338 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5339 }
5340 {
5341 PyThreadState* __tstate = wxPyBeginAllowThreads();
5342 (arg1)->SetSize((wxSize const &)*arg2);
5343
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 Py_INCREF(Py_None); resultobj = Py_None;
5348 return resultobj;
5349 fail:
5350 return NULL;
5351 }
5352
5353
5354 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5355 PyObject *resultobj;
5356 wxRect *arg1 = (wxRect *) 0 ;
5357 bool result;
5358 PyObject * obj0 = 0 ;
5359 char *kwnames[] = {
5360 (char *) "self", NULL
5361 };
5362
5363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5365 if (SWIG_arg_fail(1)) SWIG_fail;
5366 {
5367 PyThreadState* __tstate = wxPyBeginAllowThreads();
5368 result = (bool)((wxRect const *)arg1)->IsEmpty();
5369
5370 wxPyEndAllowThreads(__tstate);
5371 if (PyErr_Occurred()) SWIG_fail;
5372 }
5373 {
5374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5375 }
5376 return resultobj;
5377 fail:
5378 return NULL;
5379 }
5380
5381
5382 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5383 PyObject *resultobj;
5384 wxRect *arg1 = (wxRect *) 0 ;
5385 wxPoint result;
5386 PyObject * obj0 = 0 ;
5387 char *kwnames[] = {
5388 (char *) "self", NULL
5389 };
5390
5391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5393 if (SWIG_arg_fail(1)) SWIG_fail;
5394 {
5395 PyThreadState* __tstate = wxPyBeginAllowThreads();
5396 result = ((wxRect const *)arg1)->GetTopLeft();
5397
5398 wxPyEndAllowThreads(__tstate);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 {
5402 wxPoint * resultptr;
5403 resultptr = new wxPoint((wxPoint &)(result));
5404 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5405 }
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5413 PyObject *resultobj;
5414 wxRect *arg1 = (wxRect *) 0 ;
5415 wxPoint *arg2 = 0 ;
5416 wxPoint temp2 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char *kwnames[] = {
5420 (char *) "self",(char *) "p", NULL
5421 };
5422
5423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5428 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5429 }
5430 {
5431 PyThreadState* __tstate = wxPyBeginAllowThreads();
5432 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5433
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 Py_INCREF(Py_None); resultobj = Py_None;
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj;
5446 wxRect *arg1 = (wxRect *) 0 ;
5447 wxPoint result;
5448 PyObject * obj0 = 0 ;
5449 char *kwnames[] = {
5450 (char *) "self", NULL
5451 };
5452
5453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5455 if (SWIG_arg_fail(1)) SWIG_fail;
5456 {
5457 PyThreadState* __tstate = wxPyBeginAllowThreads();
5458 result = ((wxRect const *)arg1)->GetBottomRight();
5459
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 {
5464 wxPoint * resultptr;
5465 resultptr = new wxPoint((wxPoint &)(result));
5466 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5467 }
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5475 PyObject *resultobj;
5476 wxRect *arg1 = (wxRect *) 0 ;
5477 wxPoint *arg2 = 0 ;
5478 wxPoint temp2 ;
5479 PyObject * obj0 = 0 ;
5480 PyObject * obj1 = 0 ;
5481 char *kwnames[] = {
5482 (char *) "self",(char *) "p", NULL
5483 };
5484
5485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5490 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5491 }
5492 {
5493 PyThreadState* __tstate = wxPyBeginAllowThreads();
5494 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5495
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 Py_INCREF(Py_None); resultobj = Py_None;
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxRect *arg1 = (wxRect *) 0 ;
5509 int result;
5510 PyObject * obj0 = 0 ;
5511 char *kwnames[] = {
5512 (char *) "self", NULL
5513 };
5514
5515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5517 if (SWIG_arg_fail(1)) SWIG_fail;
5518 {
5519 PyThreadState* __tstate = wxPyBeginAllowThreads();
5520 result = (int)((wxRect const *)arg1)->GetLeft();
5521
5522 wxPyEndAllowThreads(__tstate);
5523 if (PyErr_Occurred()) SWIG_fail;
5524 }
5525 {
5526 resultobj = SWIG_From_int((int)(result));
5527 }
5528 return resultobj;
5529 fail:
5530 return NULL;
5531 }
5532
5533
5534 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5535 PyObject *resultobj;
5536 wxRect *arg1 = (wxRect *) 0 ;
5537 int result;
5538 PyObject * obj0 = 0 ;
5539 char *kwnames[] = {
5540 (char *) "self", NULL
5541 };
5542
5543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5545 if (SWIG_arg_fail(1)) SWIG_fail;
5546 {
5547 PyThreadState* __tstate = wxPyBeginAllowThreads();
5548 result = (int)((wxRect const *)arg1)->GetTop();
5549
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 resultobj = SWIG_From_int((int)(result));
5555 }
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 wxRect *arg1 = (wxRect *) 0 ;
5565 int result;
5566 PyObject * obj0 = 0 ;
5567 char *kwnames[] = {
5568 (char *) "self", NULL
5569 };
5570
5571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5573 if (SWIG_arg_fail(1)) SWIG_fail;
5574 {
5575 PyThreadState* __tstate = wxPyBeginAllowThreads();
5576 result = (int)((wxRect const *)arg1)->GetBottom();
5577
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 {
5582 resultobj = SWIG_From_int((int)(result));
5583 }
5584 return resultobj;
5585 fail:
5586 return NULL;
5587 }
5588
5589
5590 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5591 PyObject *resultobj;
5592 wxRect *arg1 = (wxRect *) 0 ;
5593 int result;
5594 PyObject * obj0 = 0 ;
5595 char *kwnames[] = {
5596 (char *) "self", NULL
5597 };
5598
5599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5601 if (SWIG_arg_fail(1)) SWIG_fail;
5602 {
5603 PyThreadState* __tstate = wxPyBeginAllowThreads();
5604 result = (int)((wxRect const *)arg1)->GetRight();
5605
5606 wxPyEndAllowThreads(__tstate);
5607 if (PyErr_Occurred()) SWIG_fail;
5608 }
5609 {
5610 resultobj = SWIG_From_int((int)(result));
5611 }
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5619 PyObject *resultobj;
5620 wxRect *arg1 = (wxRect *) 0 ;
5621 int arg2 ;
5622 PyObject * obj0 = 0 ;
5623 PyObject * obj1 = 0 ;
5624 char *kwnames[] = {
5625 (char *) "self",(char *) "left", NULL
5626 };
5627
5628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5630 if (SWIG_arg_fail(1)) SWIG_fail;
5631 {
5632 arg2 = (int)(SWIG_As_int(obj1));
5633 if (SWIG_arg_fail(2)) SWIG_fail;
5634 }
5635 {
5636 PyThreadState* __tstate = wxPyBeginAllowThreads();
5637 (arg1)->SetLeft(arg2);
5638
5639 wxPyEndAllowThreads(__tstate);
5640 if (PyErr_Occurred()) SWIG_fail;
5641 }
5642 Py_INCREF(Py_None); resultobj = Py_None;
5643 return resultobj;
5644 fail:
5645 return NULL;
5646 }
5647
5648
5649 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj;
5651 wxRect *arg1 = (wxRect *) 0 ;
5652 int arg2 ;
5653 PyObject * obj0 = 0 ;
5654 PyObject * obj1 = 0 ;
5655 char *kwnames[] = {
5656 (char *) "self",(char *) "right", NULL
5657 };
5658
5659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5661 if (SWIG_arg_fail(1)) SWIG_fail;
5662 {
5663 arg2 = (int)(SWIG_As_int(obj1));
5664 if (SWIG_arg_fail(2)) SWIG_fail;
5665 }
5666 {
5667 PyThreadState* __tstate = wxPyBeginAllowThreads();
5668 (arg1)->SetRight(arg2);
5669
5670 wxPyEndAllowThreads(__tstate);
5671 if (PyErr_Occurred()) SWIG_fail;
5672 }
5673 Py_INCREF(Py_None); resultobj = Py_None;
5674 return resultobj;
5675 fail:
5676 return NULL;
5677 }
5678
5679
5680 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5681 PyObject *resultobj;
5682 wxRect *arg1 = (wxRect *) 0 ;
5683 int arg2 ;
5684 PyObject * obj0 = 0 ;
5685 PyObject * obj1 = 0 ;
5686 char *kwnames[] = {
5687 (char *) "self",(char *) "top", NULL
5688 };
5689
5690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5692 if (SWIG_arg_fail(1)) SWIG_fail;
5693 {
5694 arg2 = (int)(SWIG_As_int(obj1));
5695 if (SWIG_arg_fail(2)) SWIG_fail;
5696 }
5697 {
5698 PyThreadState* __tstate = wxPyBeginAllowThreads();
5699 (arg1)->SetTop(arg2);
5700
5701 wxPyEndAllowThreads(__tstate);
5702 if (PyErr_Occurred()) SWIG_fail;
5703 }
5704 Py_INCREF(Py_None); resultobj = Py_None;
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5712 PyObject *resultobj;
5713 wxRect *arg1 = (wxRect *) 0 ;
5714 int arg2 ;
5715 PyObject * obj0 = 0 ;
5716 PyObject * obj1 = 0 ;
5717 char *kwnames[] = {
5718 (char *) "self",(char *) "bottom", NULL
5719 };
5720
5721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5723 if (SWIG_arg_fail(1)) SWIG_fail;
5724 {
5725 arg2 = (int)(SWIG_As_int(obj1));
5726 if (SWIG_arg_fail(2)) SWIG_fail;
5727 }
5728 {
5729 PyThreadState* __tstate = wxPyBeginAllowThreads();
5730 (arg1)->SetBottom(arg2);
5731
5732 wxPyEndAllowThreads(__tstate);
5733 if (PyErr_Occurred()) SWIG_fail;
5734 }
5735 Py_INCREF(Py_None); resultobj = Py_None;
5736 return resultobj;
5737 fail:
5738 return NULL;
5739 }
5740
5741
5742 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5743 PyObject *resultobj;
5744 wxRect *arg1 = (wxRect *) 0 ;
5745 int arg2 ;
5746 int arg3 ;
5747 wxRect *result;
5748 PyObject * obj0 = 0 ;
5749 PyObject * obj1 = 0 ;
5750 PyObject * obj2 = 0 ;
5751 char *kwnames[] = {
5752 (char *) "self",(char *) "dx",(char *) "dy", NULL
5753 };
5754
5755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5757 if (SWIG_arg_fail(1)) SWIG_fail;
5758 {
5759 arg2 = (int)(SWIG_As_int(obj1));
5760 if (SWIG_arg_fail(2)) SWIG_fail;
5761 }
5762 {
5763 arg3 = (int)(SWIG_As_int(obj2));
5764 if (SWIG_arg_fail(3)) SWIG_fail;
5765 }
5766 {
5767 PyThreadState* __tstate = wxPyBeginAllowThreads();
5768 {
5769 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5770 result = (wxRect *) &_result_ref;
5771 }
5772
5773 wxPyEndAllowThreads(__tstate);
5774 if (PyErr_Occurred()) SWIG_fail;
5775 }
5776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5784 PyObject *resultobj;
5785 wxRect *arg1 = (wxRect *) 0 ;
5786 int arg2 ;
5787 int arg3 ;
5788 wxRect *result;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 char *kwnames[] = {
5793 (char *) "self",(char *) "dx",(char *) "dy", NULL
5794 };
5795
5796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5798 if (SWIG_arg_fail(1)) SWIG_fail;
5799 {
5800 arg2 = (int)(SWIG_As_int(obj1));
5801 if (SWIG_arg_fail(2)) SWIG_fail;
5802 }
5803 {
5804 arg3 = (int)(SWIG_As_int(obj2));
5805 if (SWIG_arg_fail(3)) SWIG_fail;
5806 }
5807 {
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 {
5810 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5811 result = (wxRect *) &_result_ref;
5812 }
5813
5814 wxPyEndAllowThreads(__tstate);
5815 if (PyErr_Occurred()) SWIG_fail;
5816 }
5817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5818 return resultobj;
5819 fail:
5820 return NULL;
5821 }
5822
5823
5824 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5825 PyObject *resultobj;
5826 wxRect *arg1 = (wxRect *) 0 ;
5827 int arg2 ;
5828 int arg3 ;
5829 PyObject * obj0 = 0 ;
5830 PyObject * obj1 = 0 ;
5831 PyObject * obj2 = 0 ;
5832 char *kwnames[] = {
5833 (char *) "self",(char *) "dx",(char *) "dy", NULL
5834 };
5835
5836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5838 if (SWIG_arg_fail(1)) SWIG_fail;
5839 {
5840 arg2 = (int)(SWIG_As_int(obj1));
5841 if (SWIG_arg_fail(2)) SWIG_fail;
5842 }
5843 {
5844 arg3 = (int)(SWIG_As_int(obj2));
5845 if (SWIG_arg_fail(3)) SWIG_fail;
5846 }
5847 {
5848 PyThreadState* __tstate = wxPyBeginAllowThreads();
5849 (arg1)->Offset(arg2,arg3);
5850
5851 wxPyEndAllowThreads(__tstate);
5852 if (PyErr_Occurred()) SWIG_fail;
5853 }
5854 Py_INCREF(Py_None); resultobj = Py_None;
5855 return resultobj;
5856 fail:
5857 return NULL;
5858 }
5859
5860
5861 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5862 PyObject *resultobj;
5863 wxRect *arg1 = (wxRect *) 0 ;
5864 wxPoint *arg2 = 0 ;
5865 wxPoint temp2 ;
5866 PyObject * obj0 = 0 ;
5867 PyObject * obj1 = 0 ;
5868 char *kwnames[] = {
5869 (char *) "self",(char *) "pt", NULL
5870 };
5871
5872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5874 if (SWIG_arg_fail(1)) SWIG_fail;
5875 {
5876 arg2 = &temp2;
5877 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5878 }
5879 {
5880 PyThreadState* __tstate = wxPyBeginAllowThreads();
5881 (arg1)->Offset((wxPoint const &)*arg2);
5882
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 Py_INCREF(Py_None); resultobj = Py_None;
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5894 PyObject *resultobj;
5895 wxRect *arg1 = (wxRect *) 0 ;
5896 wxRect *arg2 = 0 ;
5897 wxRect result;
5898 wxRect temp2 ;
5899 PyObject * obj0 = 0 ;
5900 PyObject * obj1 = 0 ;
5901 char *kwnames[] = {
5902 (char *) "self",(char *) "rect", NULL
5903 };
5904
5905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5907 if (SWIG_arg_fail(1)) SWIG_fail;
5908 {
5909 arg2 = &temp2;
5910 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5911 }
5912 {
5913 PyThreadState* __tstate = wxPyBeginAllowThreads();
5914 result = (arg1)->Intersect((wxRect const &)*arg2);
5915
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 {
5920 wxRect * resultptr;
5921 resultptr = new wxRect((wxRect &)(result));
5922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5923 }
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5931 PyObject *resultobj;
5932 wxRect *arg1 = (wxRect *) 0 ;
5933 wxRect *arg2 = 0 ;
5934 wxRect result;
5935 wxRect temp2 ;
5936 PyObject * obj0 = 0 ;
5937 PyObject * obj1 = 0 ;
5938 char *kwnames[] = {
5939 (char *) "self",(char *) "rect", NULL
5940 };
5941
5942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5944 if (SWIG_arg_fail(1)) SWIG_fail;
5945 {
5946 arg2 = &temp2;
5947 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5948 }
5949 {
5950 PyThreadState* __tstate = wxPyBeginAllowThreads();
5951 result = (arg1)->Union((wxRect const &)*arg2);
5952
5953 wxPyEndAllowThreads(__tstate);
5954 if (PyErr_Occurred()) SWIG_fail;
5955 }
5956 {
5957 wxRect * resultptr;
5958 resultptr = new wxRect((wxRect &)(result));
5959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5960 }
5961 return resultobj;
5962 fail:
5963 return NULL;
5964 }
5965
5966
5967 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5968 PyObject *resultobj;
5969 wxRect *arg1 = (wxRect *) 0 ;
5970 wxRect *arg2 = 0 ;
5971 wxRect result;
5972 wxRect temp2 ;
5973 PyObject * obj0 = 0 ;
5974 PyObject * obj1 = 0 ;
5975 char *kwnames[] = {
5976 (char *) "self",(char *) "rect", NULL
5977 };
5978
5979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5981 if (SWIG_arg_fail(1)) SWIG_fail;
5982 {
5983 arg2 = &temp2;
5984 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5985 }
5986 {
5987 PyThreadState* __tstate = wxPyBeginAllowThreads();
5988 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5989
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 {
5994 wxRect * resultptr;
5995 resultptr = new wxRect((wxRect &)(result));
5996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5997 }
5998 return resultobj;
5999 fail:
6000 return NULL;
6001 }
6002
6003
6004 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6005 PyObject *resultobj;
6006 wxRect *arg1 = (wxRect *) 0 ;
6007 wxRect *arg2 = 0 ;
6008 wxRect *result;
6009 wxRect temp2 ;
6010 PyObject * obj0 = 0 ;
6011 PyObject * obj1 = 0 ;
6012 char *kwnames[] = {
6013 (char *) "self",(char *) "rect", NULL
6014 };
6015
6016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6018 if (SWIG_arg_fail(1)) SWIG_fail;
6019 {
6020 arg2 = &temp2;
6021 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6022 }
6023 {
6024 PyThreadState* __tstate = wxPyBeginAllowThreads();
6025 {
6026 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6027 result = (wxRect *) &_result_ref;
6028 }
6029
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6034 return resultobj;
6035 fail:
6036 return NULL;
6037 }
6038
6039
6040 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6041 PyObject *resultobj;
6042 wxRect *arg1 = (wxRect *) 0 ;
6043 wxRect *arg2 = 0 ;
6044 bool result;
6045 wxRect temp2 ;
6046 PyObject * obj0 = 0 ;
6047 PyObject * obj1 = 0 ;
6048 char *kwnames[] = {
6049 (char *) "self",(char *) "rect", NULL
6050 };
6051
6052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6054 if (SWIG_arg_fail(1)) SWIG_fail;
6055 {
6056 arg2 = &temp2;
6057 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6058 }
6059 {
6060 PyThreadState* __tstate = wxPyBeginAllowThreads();
6061 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6062
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 {
6067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6068 }
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj;
6077 wxRect *arg1 = (wxRect *) 0 ;
6078 wxRect *arg2 = 0 ;
6079 bool result;
6080 wxRect temp2 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 char *kwnames[] = {
6084 (char *) "self",(char *) "rect", NULL
6085 };
6086
6087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6089 if (SWIG_arg_fail(1)) SWIG_fail;
6090 {
6091 arg2 = &temp2;
6092 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6093 }
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 {
6102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6103 }
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj;
6112 wxRect *arg1 = (wxRect *) 0 ;
6113 int arg2 ;
6114 int arg3 ;
6115 bool result;
6116 PyObject * obj0 = 0 ;
6117 PyObject * obj1 = 0 ;
6118 PyObject * obj2 = 0 ;
6119 char *kwnames[] = {
6120 (char *) "self",(char *) "x",(char *) "y", NULL
6121 };
6122
6123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6125 if (SWIG_arg_fail(1)) SWIG_fail;
6126 {
6127 arg2 = (int)(SWIG_As_int(obj1));
6128 if (SWIG_arg_fail(2)) SWIG_fail;
6129 }
6130 {
6131 arg3 = (int)(SWIG_As_int(obj2));
6132 if (SWIG_arg_fail(3)) SWIG_fail;
6133 }
6134 {
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6137
6138 wxPyEndAllowThreads(__tstate);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 {
6142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6143 }
6144 return resultobj;
6145 fail:
6146 return NULL;
6147 }
6148
6149
6150 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6151 PyObject *resultobj;
6152 wxRect *arg1 = (wxRect *) 0 ;
6153 wxPoint *arg2 = 0 ;
6154 bool result;
6155 wxPoint temp2 ;
6156 PyObject * obj0 = 0 ;
6157 PyObject * obj1 = 0 ;
6158 char *kwnames[] = {
6159 (char *) "self",(char *) "pt", NULL
6160 };
6161
6162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6164 if (SWIG_arg_fail(1)) SWIG_fail;
6165 {
6166 arg2 = &temp2;
6167 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6168 }
6169 {
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6172
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 {
6177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6178 }
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj;
6187 wxRect *arg1 = (wxRect *) 0 ;
6188 wxRect *arg2 = 0 ;
6189 bool result;
6190 wxRect temp2 ;
6191 PyObject * obj0 = 0 ;
6192 PyObject * obj1 = 0 ;
6193 char *kwnames[] = {
6194 (char *) "self",(char *) "rect", NULL
6195 };
6196
6197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6199 if (SWIG_arg_fail(1)) SWIG_fail;
6200 {
6201 arg2 = &temp2;
6202 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6203 }
6204 {
6205 PyThreadState* __tstate = wxPyBeginAllowThreads();
6206 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6207
6208 wxPyEndAllowThreads(__tstate);
6209 if (PyErr_Occurred()) SWIG_fail;
6210 }
6211 {
6212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6213 }
6214 return resultobj;
6215 fail:
6216 return NULL;
6217 }
6218
6219
6220 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6221 PyObject *resultobj;
6222 wxRect *arg1 = (wxRect *) 0 ;
6223 int arg2 ;
6224 PyObject * obj0 = 0 ;
6225 PyObject * obj1 = 0 ;
6226 char *kwnames[] = {
6227 (char *) "self",(char *) "x", NULL
6228 };
6229
6230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6232 if (SWIG_arg_fail(1)) SWIG_fail;
6233 {
6234 arg2 = (int)(SWIG_As_int(obj1));
6235 if (SWIG_arg_fail(2)) SWIG_fail;
6236 }
6237 if (arg1) (arg1)->x = arg2;
6238
6239 Py_INCREF(Py_None); resultobj = Py_None;
6240 return resultobj;
6241 fail:
6242 return NULL;
6243 }
6244
6245
6246 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6247 PyObject *resultobj;
6248 wxRect *arg1 = (wxRect *) 0 ;
6249 int result;
6250 PyObject * obj0 = 0 ;
6251 char *kwnames[] = {
6252 (char *) "self", NULL
6253 };
6254
6255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6257 if (SWIG_arg_fail(1)) SWIG_fail;
6258 result = (int) ((arg1)->x);
6259
6260 {
6261 resultobj = SWIG_From_int((int)(result));
6262 }
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj;
6271 wxRect *arg1 = (wxRect *) 0 ;
6272 int arg2 ;
6273 PyObject * obj0 = 0 ;
6274 PyObject * obj1 = 0 ;
6275 char *kwnames[] = {
6276 (char *) "self",(char *) "y", NULL
6277 };
6278
6279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6281 if (SWIG_arg_fail(1)) SWIG_fail;
6282 {
6283 arg2 = (int)(SWIG_As_int(obj1));
6284 if (SWIG_arg_fail(2)) SWIG_fail;
6285 }
6286 if (arg1) (arg1)->y = arg2;
6287
6288 Py_INCREF(Py_None); resultobj = Py_None;
6289 return resultobj;
6290 fail:
6291 return NULL;
6292 }
6293
6294
6295 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6296 PyObject *resultobj;
6297 wxRect *arg1 = (wxRect *) 0 ;
6298 int result;
6299 PyObject * obj0 = 0 ;
6300 char *kwnames[] = {
6301 (char *) "self", NULL
6302 };
6303
6304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6306 if (SWIG_arg_fail(1)) SWIG_fail;
6307 result = (int) ((arg1)->y);
6308
6309 {
6310 resultobj = SWIG_From_int((int)(result));
6311 }
6312 return resultobj;
6313 fail:
6314 return NULL;
6315 }
6316
6317
6318 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6319 PyObject *resultobj;
6320 wxRect *arg1 = (wxRect *) 0 ;
6321 int arg2 ;
6322 PyObject * obj0 = 0 ;
6323 PyObject * obj1 = 0 ;
6324 char *kwnames[] = {
6325 (char *) "self",(char *) "width", NULL
6326 };
6327
6328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6330 if (SWIG_arg_fail(1)) SWIG_fail;
6331 {
6332 arg2 = (int)(SWIG_As_int(obj1));
6333 if (SWIG_arg_fail(2)) SWIG_fail;
6334 }
6335 if (arg1) (arg1)->width = arg2;
6336
6337 Py_INCREF(Py_None); resultobj = Py_None;
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6345 PyObject *resultobj;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int result;
6348 PyObject * obj0 = 0 ;
6349 char *kwnames[] = {
6350 (char *) "self", NULL
6351 };
6352
6353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6355 if (SWIG_arg_fail(1)) SWIG_fail;
6356 result = (int) ((arg1)->width);
6357
6358 {
6359 resultobj = SWIG_From_int((int)(result));
6360 }
6361 return resultobj;
6362 fail:
6363 return NULL;
6364 }
6365
6366
6367 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6368 PyObject *resultobj;
6369 wxRect *arg1 = (wxRect *) 0 ;
6370 int arg2 ;
6371 PyObject * obj0 = 0 ;
6372 PyObject * obj1 = 0 ;
6373 char *kwnames[] = {
6374 (char *) "self",(char *) "height", NULL
6375 };
6376
6377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6379 if (SWIG_arg_fail(1)) SWIG_fail;
6380 {
6381 arg2 = (int)(SWIG_As_int(obj1));
6382 if (SWIG_arg_fail(2)) SWIG_fail;
6383 }
6384 if (arg1) (arg1)->height = arg2;
6385
6386 Py_INCREF(Py_None); resultobj = Py_None;
6387 return resultobj;
6388 fail:
6389 return NULL;
6390 }
6391
6392
6393 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6394 PyObject *resultobj;
6395 wxRect *arg1 = (wxRect *) 0 ;
6396 int result;
6397 PyObject * obj0 = 0 ;
6398 char *kwnames[] = {
6399 (char *) "self", NULL
6400 };
6401
6402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) 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 result = (int) ((arg1)->height);
6406
6407 {
6408 resultobj = SWIG_From_int((int)(result));
6409 }
6410 return resultobj;
6411 fail:
6412 return NULL;
6413 }
6414
6415
6416 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6417 PyObject *resultobj;
6418 wxRect *arg1 = (wxRect *) 0 ;
6419 int arg2 = (int) 0 ;
6420 int arg3 = (int) 0 ;
6421 int arg4 = (int) 0 ;
6422 int arg5 = (int) 0 ;
6423 PyObject * obj0 = 0 ;
6424 PyObject * obj1 = 0 ;
6425 PyObject * obj2 = 0 ;
6426 PyObject * obj3 = 0 ;
6427 PyObject * obj4 = 0 ;
6428 char *kwnames[] = {
6429 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6430 };
6431
6432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6434 if (SWIG_arg_fail(1)) SWIG_fail;
6435 if (obj1) {
6436 {
6437 arg2 = (int)(SWIG_As_int(obj1));
6438 if (SWIG_arg_fail(2)) SWIG_fail;
6439 }
6440 }
6441 if (obj2) {
6442 {
6443 arg3 = (int)(SWIG_As_int(obj2));
6444 if (SWIG_arg_fail(3)) SWIG_fail;
6445 }
6446 }
6447 if (obj3) {
6448 {
6449 arg4 = (int)(SWIG_As_int(obj3));
6450 if (SWIG_arg_fail(4)) SWIG_fail;
6451 }
6452 }
6453 if (obj4) {
6454 {
6455 arg5 = (int)(SWIG_As_int(obj4));
6456 if (SWIG_arg_fail(5)) SWIG_fail;
6457 }
6458 }
6459 {
6460 PyThreadState* __tstate = wxPyBeginAllowThreads();
6461 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6462
6463 wxPyEndAllowThreads(__tstate);
6464 if (PyErr_Occurred()) SWIG_fail;
6465 }
6466 Py_INCREF(Py_None); resultobj = Py_None;
6467 return resultobj;
6468 fail:
6469 return NULL;
6470 }
6471
6472
6473 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6474 PyObject *resultobj;
6475 wxRect *arg1 = (wxRect *) 0 ;
6476 PyObject *result;
6477 PyObject * obj0 = 0 ;
6478 char *kwnames[] = {
6479 (char *) "self", NULL
6480 };
6481
6482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6484 if (SWIG_arg_fail(1)) SWIG_fail;
6485 {
6486 PyThreadState* __tstate = wxPyBeginAllowThreads();
6487 result = (PyObject *)wxRect_Get(arg1);
6488
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = result;
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6500 PyObject *obj;
6501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6502 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6503 Py_INCREF(obj);
6504 return Py_BuildValue((char *)"");
6505 }
6506 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6507 PyObject *resultobj;
6508 wxRect *arg1 = (wxRect *) 0 ;
6509 wxRect *arg2 = (wxRect *) 0 ;
6510 PyObject *result;
6511 PyObject * obj0 = 0 ;
6512 PyObject * obj1 = 0 ;
6513 char *kwnames[] = {
6514 (char *) "r1",(char *) "r2", NULL
6515 };
6516
6517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6519 if (SWIG_arg_fail(1)) SWIG_fail;
6520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6521 if (SWIG_arg_fail(2)) SWIG_fail;
6522 {
6523 if (!wxPyCheckForApp()) SWIG_fail;
6524 PyThreadState* __tstate = wxPyBeginAllowThreads();
6525 result = (PyObject *)wxIntersectRect(arg1,arg2);
6526
6527 wxPyEndAllowThreads(__tstate);
6528 if (PyErr_Occurred()) SWIG_fail;
6529 }
6530 resultobj = result;
6531 return resultobj;
6532 fail:
6533 return NULL;
6534 }
6535
6536
6537 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj;
6539 double arg1 = (double) 0.0 ;
6540 double arg2 = (double) 0.0 ;
6541 wxPoint2D *result;
6542 PyObject * obj0 = 0 ;
6543 PyObject * obj1 = 0 ;
6544 char *kwnames[] = {
6545 (char *) "x",(char *) "y", NULL
6546 };
6547
6548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6549 if (obj0) {
6550 {
6551 arg1 = (double)(SWIG_As_double(obj0));
6552 if (SWIG_arg_fail(1)) SWIG_fail;
6553 }
6554 }
6555 if (obj1) {
6556 {
6557 arg2 = (double)(SWIG_As_double(obj1));
6558 if (SWIG_arg_fail(2)) SWIG_fail;
6559 }
6560 }
6561 {
6562 PyThreadState* __tstate = wxPyBeginAllowThreads();
6563 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6564
6565 wxPyEndAllowThreads(__tstate);
6566 if (PyErr_Occurred()) SWIG_fail;
6567 }
6568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6576 PyObject *resultobj;
6577 wxPoint2D *arg1 = 0 ;
6578 wxPoint2D *result;
6579 wxPoint2D temp1 ;
6580 PyObject * obj0 = 0 ;
6581 char *kwnames[] = {
6582 (char *) "pt", NULL
6583 };
6584
6585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6586 {
6587 arg1 = &temp1;
6588 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6589 }
6590 {
6591 PyThreadState* __tstate = wxPyBeginAllowThreads();
6592 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6593
6594 wxPyEndAllowThreads(__tstate);
6595 if (PyErr_Occurred()) SWIG_fail;
6596 }
6597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6598 return resultobj;
6599 fail:
6600 return NULL;
6601 }
6602
6603
6604 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6605 PyObject *resultobj;
6606 wxPoint *arg1 = 0 ;
6607 wxPoint2D *result;
6608 wxPoint temp1 ;
6609 PyObject * obj0 = 0 ;
6610 char *kwnames[] = {
6611 (char *) "pt", NULL
6612 };
6613
6614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6615 {
6616 arg1 = &temp1;
6617 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6618 }
6619 {
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6622
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj;
6635 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6636 int *arg2 = (int *) 0 ;
6637 int *arg3 = (int *) 0 ;
6638 int temp2 ;
6639 int res2 = 0 ;
6640 int temp3 ;
6641 int res3 = 0 ;
6642 PyObject * obj0 = 0 ;
6643 char *kwnames[] = {
6644 (char *) "self", NULL
6645 };
6646
6647 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6648 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6651 if (SWIG_arg_fail(1)) SWIG_fail;
6652 {
6653 PyThreadState* __tstate = wxPyBeginAllowThreads();
6654 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6655
6656 wxPyEndAllowThreads(__tstate);
6657 if (PyErr_Occurred()) SWIG_fail;
6658 }
6659 Py_INCREF(Py_None); resultobj = Py_None;
6660 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6661 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6662 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6663 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6671 PyObject *resultobj;
6672 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6673 int *arg2 = (int *) 0 ;
6674 int *arg3 = (int *) 0 ;
6675 int temp2 ;
6676 int res2 = 0 ;
6677 int temp3 ;
6678 int res3 = 0 ;
6679 PyObject * obj0 = 0 ;
6680 char *kwnames[] = {
6681 (char *) "self", NULL
6682 };
6683
6684 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6685 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",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 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 Py_INCREF(Py_None); resultobj = Py_None;
6697 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6698 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6699 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6700 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj;
6709 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6710 double result;
6711 PyObject * obj0 = 0 ;
6712 char *kwnames[] = {
6713 (char *) "self", NULL
6714 };
6715
6716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6718 if (SWIG_arg_fail(1)) SWIG_fail;
6719 {
6720 PyThreadState* __tstate = wxPyBeginAllowThreads();
6721 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6722
6723 wxPyEndAllowThreads(__tstate);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 {
6727 resultobj = SWIG_From_double((double)(result));
6728 }
6729 return resultobj;
6730 fail:
6731 return NULL;
6732 }
6733
6734
6735 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6736 PyObject *resultobj;
6737 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6738 double result;
6739 PyObject * obj0 = 0 ;
6740 char *kwnames[] = {
6741 (char *) "self", NULL
6742 };
6743
6744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6746 if (SWIG_arg_fail(1)) SWIG_fail;
6747 {
6748 PyThreadState* __tstate = wxPyBeginAllowThreads();
6749 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6750
6751 wxPyEndAllowThreads(__tstate);
6752 if (PyErr_Occurred()) SWIG_fail;
6753 }
6754 {
6755 resultobj = SWIG_From_double((double)(result));
6756 }
6757 return resultobj;
6758 fail:
6759 return NULL;
6760 }
6761
6762
6763 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6764 PyObject *resultobj;
6765 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6766 double arg2 ;
6767 PyObject * obj0 = 0 ;
6768 PyObject * obj1 = 0 ;
6769 char *kwnames[] = {
6770 (char *) "self",(char *) "length", NULL
6771 };
6772
6773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6775 if (SWIG_arg_fail(1)) SWIG_fail;
6776 {
6777 arg2 = (double)(SWIG_As_double(obj1));
6778 if (SWIG_arg_fail(2)) SWIG_fail;
6779 }
6780 {
6781 PyThreadState* __tstate = wxPyBeginAllowThreads();
6782 (arg1)->SetVectorLength(arg2);
6783
6784 wxPyEndAllowThreads(__tstate);
6785 if (PyErr_Occurred()) SWIG_fail;
6786 }
6787 Py_INCREF(Py_None); resultobj = Py_None;
6788 return resultobj;
6789 fail:
6790 return NULL;
6791 }
6792
6793
6794 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6795 PyObject *resultobj;
6796 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6797 double arg2 ;
6798 PyObject * obj0 = 0 ;
6799 PyObject * obj1 = 0 ;
6800 char *kwnames[] = {
6801 (char *) "self",(char *) "degrees", NULL
6802 };
6803
6804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6806 if (SWIG_arg_fail(1)) SWIG_fail;
6807 {
6808 arg2 = (double)(SWIG_As_double(obj1));
6809 if (SWIG_arg_fail(2)) SWIG_fail;
6810 }
6811 {
6812 PyThreadState* __tstate = wxPyBeginAllowThreads();
6813 (arg1)->SetVectorAngle(arg2);
6814
6815 wxPyEndAllowThreads(__tstate);
6816 if (PyErr_Occurred()) SWIG_fail;
6817 }
6818 Py_INCREF(Py_None); resultobj = Py_None;
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6826 PyObject *resultobj;
6827 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6828 wxPoint2D *arg2 = 0 ;
6829 double result;
6830 wxPoint2D temp2 ;
6831 PyObject * obj0 = 0 ;
6832 PyObject * obj1 = 0 ;
6833 char *kwnames[] = {
6834 (char *) "self",(char *) "pt", NULL
6835 };
6836
6837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6839 if (SWIG_arg_fail(1)) SWIG_fail;
6840 {
6841 arg2 = &temp2;
6842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6843 }
6844 {
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6847
6848 wxPyEndAllowThreads(__tstate);
6849 if (PyErr_Occurred()) SWIG_fail;
6850 }
6851 {
6852 resultobj = SWIG_From_double((double)(result));
6853 }
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6861 PyObject *resultobj;
6862 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6863 wxPoint2D *arg2 = 0 ;
6864 double result;
6865 wxPoint2D temp2 ;
6866 PyObject * obj0 = 0 ;
6867 PyObject * obj1 = 0 ;
6868 char *kwnames[] = {
6869 (char *) "self",(char *) "pt", NULL
6870 };
6871
6872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6874 if (SWIG_arg_fail(1)) SWIG_fail;
6875 {
6876 arg2 = &temp2;
6877 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6878 }
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6882
6883 wxPyEndAllowThreads(__tstate);
6884 if (PyErr_Occurred()) SWIG_fail;
6885 }
6886 {
6887 resultobj = SWIG_From_double((double)(result));
6888 }
6889 return resultobj;
6890 fail:
6891 return NULL;
6892 }
6893
6894
6895 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6896 PyObject *resultobj;
6897 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6898 wxPoint2D *arg2 = 0 ;
6899 double result;
6900 wxPoint2D temp2 ;
6901 PyObject * obj0 = 0 ;
6902 PyObject * obj1 = 0 ;
6903 char *kwnames[] = {
6904 (char *) "self",(char *) "vec", NULL
6905 };
6906
6907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6909 if (SWIG_arg_fail(1)) SWIG_fail;
6910 {
6911 arg2 = &temp2;
6912 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6913 }
6914 {
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6917
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 {
6922 resultobj = SWIG_From_double((double)(result));
6923 }
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj;
6932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6933 wxPoint2D *arg2 = 0 ;
6934 double result;
6935 wxPoint2D temp2 ;
6936 PyObject * obj0 = 0 ;
6937 PyObject * obj1 = 0 ;
6938 char *kwnames[] = {
6939 (char *) "self",(char *) "vec", NULL
6940 };
6941
6942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6944 if (SWIG_arg_fail(1)) SWIG_fail;
6945 {
6946 arg2 = &temp2;
6947 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6948 }
6949 {
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6952
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 {
6957 resultobj = SWIG_From_double((double)(result));
6958 }
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6966 PyObject *resultobj;
6967 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6968 wxPoint2D result;
6969 PyObject * obj0 = 0 ;
6970 char *kwnames[] = {
6971 (char *) "self", NULL
6972 };
6973
6974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6976 if (SWIG_arg_fail(1)) SWIG_fail;
6977 {
6978 PyThreadState* __tstate = wxPyBeginAllowThreads();
6979 result = (arg1)->operator -();
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 {
6985 wxPoint2D * resultptr;
6986 resultptr = new wxPoint2D((wxPoint2D &)(result));
6987 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6988 }
6989 return resultobj;
6990 fail:
6991 return NULL;
6992 }
6993
6994
6995 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6996 PyObject *resultobj;
6997 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6998 wxPoint2D *arg2 = 0 ;
6999 wxPoint2D *result;
7000 wxPoint2D temp2 ;
7001 PyObject * obj0 = 0 ;
7002 PyObject * obj1 = 0 ;
7003 char *kwnames[] = {
7004 (char *) "self",(char *) "pt", NULL
7005 };
7006
7007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7009 if (SWIG_arg_fail(1)) SWIG_fail;
7010 {
7011 arg2 = &temp2;
7012 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7013 }
7014 {
7015 PyThreadState* __tstate = wxPyBeginAllowThreads();
7016 {
7017 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7018 result = (wxPoint2D *) &_result_ref;
7019 }
7020
7021 wxPyEndAllowThreads(__tstate);
7022 if (PyErr_Occurred()) SWIG_fail;
7023 }
7024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7025 return resultobj;
7026 fail:
7027 return NULL;
7028 }
7029
7030
7031 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7032 PyObject *resultobj;
7033 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7034 wxPoint2D *arg2 = 0 ;
7035 wxPoint2D *result;
7036 wxPoint2D temp2 ;
7037 PyObject * obj0 = 0 ;
7038 PyObject * obj1 = 0 ;
7039 char *kwnames[] = {
7040 (char *) "self",(char *) "pt", NULL
7041 };
7042
7043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7045 if (SWIG_arg_fail(1)) SWIG_fail;
7046 {
7047 arg2 = &temp2;
7048 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7049 }
7050 {
7051 PyThreadState* __tstate = wxPyBeginAllowThreads();
7052 {
7053 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7054 result = (wxPoint2D *) &_result_ref;
7055 }
7056
7057 wxPyEndAllowThreads(__tstate);
7058 if (PyErr_Occurred()) SWIG_fail;
7059 }
7060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7061 return resultobj;
7062 fail:
7063 return NULL;
7064 }
7065
7066
7067 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7068 PyObject *resultobj;
7069 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7070 wxPoint2D *arg2 = 0 ;
7071 wxPoint2D *result;
7072 wxPoint2D temp2 ;
7073 PyObject * obj0 = 0 ;
7074 PyObject * obj1 = 0 ;
7075 char *kwnames[] = {
7076 (char *) "self",(char *) "pt", NULL
7077 };
7078
7079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7081 if (SWIG_arg_fail(1)) SWIG_fail;
7082 {
7083 arg2 = &temp2;
7084 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7085 }
7086 {
7087 PyThreadState* __tstate = wxPyBeginAllowThreads();
7088 {
7089 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7090 result = (wxPoint2D *) &_result_ref;
7091 }
7092
7093 wxPyEndAllowThreads(__tstate);
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7097 return resultobj;
7098 fail:
7099 return NULL;
7100 }
7101
7102
7103 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7104 PyObject *resultobj;
7105 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7106 wxPoint2D *arg2 = 0 ;
7107 wxPoint2D *result;
7108 wxPoint2D temp2 ;
7109 PyObject * obj0 = 0 ;
7110 PyObject * obj1 = 0 ;
7111 char *kwnames[] = {
7112 (char *) "self",(char *) "pt", NULL
7113 };
7114
7115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7117 if (SWIG_arg_fail(1)) SWIG_fail;
7118 {
7119 arg2 = &temp2;
7120 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7121 }
7122 {
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 {
7125 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7126 result = (wxPoint2D *) &_result_ref;
7127 }
7128
7129 wxPyEndAllowThreads(__tstate);
7130 if (PyErr_Occurred()) SWIG_fail;
7131 }
7132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7133 return resultobj;
7134 fail:
7135 return NULL;
7136 }
7137
7138
7139 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7140 PyObject *resultobj;
7141 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7142 wxPoint2D *arg2 = 0 ;
7143 bool result;
7144 wxPoint2D temp2 ;
7145 PyObject * obj0 = 0 ;
7146 PyObject * obj1 = 0 ;
7147 char *kwnames[] = {
7148 (char *) "self",(char *) "pt", NULL
7149 };
7150
7151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7153 if (SWIG_arg_fail(1)) SWIG_fail;
7154 {
7155 arg2 = &temp2;
7156 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7157 }
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7161
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 {
7166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7167 }
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj;
7176 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7177 wxPoint2D *arg2 = 0 ;
7178 bool result;
7179 wxPoint2D temp2 ;
7180 PyObject * obj0 = 0 ;
7181 PyObject * obj1 = 0 ;
7182 char *kwnames[] = {
7183 (char *) "self",(char *) "pt", NULL
7184 };
7185
7186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7188 if (SWIG_arg_fail(1)) SWIG_fail;
7189 {
7190 arg2 = &temp2;
7191 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7192 }
7193 {
7194 PyThreadState* __tstate = wxPyBeginAllowThreads();
7195 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7196
7197 wxPyEndAllowThreads(__tstate);
7198 if (PyErr_Occurred()) SWIG_fail;
7199 }
7200 {
7201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7202 }
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj;
7211 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7212 double arg2 ;
7213 PyObject * obj0 = 0 ;
7214 PyObject * obj1 = 0 ;
7215 char *kwnames[] = {
7216 (char *) "self",(char *) "m_x", NULL
7217 };
7218
7219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7221 if (SWIG_arg_fail(1)) SWIG_fail;
7222 {
7223 arg2 = (double)(SWIG_As_double(obj1));
7224 if (SWIG_arg_fail(2)) SWIG_fail;
7225 }
7226 if (arg1) (arg1)->m_x = arg2;
7227
7228 Py_INCREF(Py_None); resultobj = Py_None;
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj;
7237 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7238 double result;
7239 PyObject * obj0 = 0 ;
7240 char *kwnames[] = {
7241 (char *) "self", NULL
7242 };
7243
7244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7246 if (SWIG_arg_fail(1)) SWIG_fail;
7247 result = (double) ((arg1)->m_x);
7248
7249 {
7250 resultobj = SWIG_From_double((double)(result));
7251 }
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj;
7260 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7261 double arg2 ;
7262 PyObject * obj0 = 0 ;
7263 PyObject * obj1 = 0 ;
7264 char *kwnames[] = {
7265 (char *) "self",(char *) "m_y", NULL
7266 };
7267
7268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7270 if (SWIG_arg_fail(1)) SWIG_fail;
7271 {
7272 arg2 = (double)(SWIG_As_double(obj1));
7273 if (SWIG_arg_fail(2)) SWIG_fail;
7274 }
7275 if (arg1) (arg1)->m_y = arg2;
7276
7277 Py_INCREF(Py_None); resultobj = Py_None;
7278 return resultobj;
7279 fail:
7280 return NULL;
7281 }
7282
7283
7284 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7285 PyObject *resultobj;
7286 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7287 double result;
7288 PyObject * obj0 = 0 ;
7289 char *kwnames[] = {
7290 (char *) "self", NULL
7291 };
7292
7293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7295 if (SWIG_arg_fail(1)) SWIG_fail;
7296 result = (double) ((arg1)->m_y);
7297
7298 {
7299 resultobj = SWIG_From_double((double)(result));
7300 }
7301 return resultobj;
7302 fail:
7303 return NULL;
7304 }
7305
7306
7307 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj;
7309 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7310 double arg2 = (double) 0 ;
7311 double arg3 = (double) 0 ;
7312 PyObject * obj0 = 0 ;
7313 PyObject * obj1 = 0 ;
7314 PyObject * obj2 = 0 ;
7315 char *kwnames[] = {
7316 (char *) "self",(char *) "x",(char *) "y", NULL
7317 };
7318
7319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7321 if (SWIG_arg_fail(1)) SWIG_fail;
7322 if (obj1) {
7323 {
7324 arg2 = (double)(SWIG_As_double(obj1));
7325 if (SWIG_arg_fail(2)) SWIG_fail;
7326 }
7327 }
7328 if (obj2) {
7329 {
7330 arg3 = (double)(SWIG_As_double(obj2));
7331 if (SWIG_arg_fail(3)) SWIG_fail;
7332 }
7333 }
7334 {
7335 PyThreadState* __tstate = wxPyBeginAllowThreads();
7336 wxPoint2D_Set(arg1,arg2,arg3);
7337
7338 wxPyEndAllowThreads(__tstate);
7339 if (PyErr_Occurred()) SWIG_fail;
7340 }
7341 Py_INCREF(Py_None); resultobj = Py_None;
7342 return resultobj;
7343 fail:
7344 return NULL;
7345 }
7346
7347
7348 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7349 PyObject *resultobj;
7350 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7351 PyObject *result;
7352 PyObject * obj0 = 0 ;
7353 char *kwnames[] = {
7354 (char *) "self", NULL
7355 };
7356
7357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7359 if (SWIG_arg_fail(1)) SWIG_fail;
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 result = (PyObject *)wxPoint2D_Get(arg1);
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 resultobj = result;
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7375 PyObject *obj;
7376 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7377 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7378 Py_INCREF(obj);
7379 return Py_BuildValue((char *)"");
7380 }
7381 static int _wrap_DefaultPosition_set(PyObject *) {
7382 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7383 return 1;
7384 }
7385
7386
7387 static PyObject *_wrap_DefaultPosition_get(void) {
7388 PyObject *pyobj;
7389
7390 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7391 return pyobj;
7392 }
7393
7394
7395 static int _wrap_DefaultSize_set(PyObject *) {
7396 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7397 return 1;
7398 }
7399
7400
7401 static PyObject *_wrap_DefaultSize_get(void) {
7402 PyObject *pyobj;
7403
7404 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7405 return pyobj;
7406 }
7407
7408
7409 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7410 PyObject *resultobj;
7411 PyObject *arg1 = (PyObject *) 0 ;
7412 wxPyInputStream *result;
7413 PyObject * obj0 = 0 ;
7414 char *kwnames[] = {
7415 (char *) "p", NULL
7416 };
7417
7418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7419 arg1 = obj0;
7420 {
7421 PyThreadState* __tstate = wxPyBeginAllowThreads();
7422 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7423
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7435 PyObject *resultobj;
7436 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7437 PyObject * obj0 = 0 ;
7438 char *kwnames[] = {
7439 (char *) "self", NULL
7440 };
7441
7442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7444 if (SWIG_arg_fail(1)) SWIG_fail;
7445 {
7446 PyThreadState* __tstate = wxPyBeginAllowThreads();
7447 delete arg1;
7448
7449 wxPyEndAllowThreads(__tstate);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 Py_INCREF(Py_None); resultobj = Py_None;
7453 return resultobj;
7454 fail:
7455 return NULL;
7456 }
7457
7458
7459 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7460 PyObject *resultobj;
7461 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7462 PyObject * obj0 = 0 ;
7463 char *kwnames[] = {
7464 (char *) "self", NULL
7465 };
7466
7467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7469 if (SWIG_arg_fail(1)) SWIG_fail;
7470 {
7471 PyThreadState* __tstate = wxPyBeginAllowThreads();
7472 (arg1)->close();
7473
7474 wxPyEndAllowThreads(__tstate);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 Py_INCREF(Py_None); resultobj = Py_None;
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7485 PyObject *resultobj;
7486 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7487 PyObject * obj0 = 0 ;
7488 char *kwnames[] = {
7489 (char *) "self", NULL
7490 };
7491
7492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7494 if (SWIG_arg_fail(1)) SWIG_fail;
7495 {
7496 PyThreadState* __tstate = wxPyBeginAllowThreads();
7497 (arg1)->flush();
7498
7499 wxPyEndAllowThreads(__tstate);
7500 if (PyErr_Occurred()) SWIG_fail;
7501 }
7502 Py_INCREF(Py_None); resultobj = Py_None;
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj;
7511 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7512 bool result;
7513 PyObject * obj0 = 0 ;
7514 char *kwnames[] = {
7515 (char *) "self", NULL
7516 };
7517
7518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) 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 {
7522 PyThreadState* __tstate = wxPyBeginAllowThreads();
7523 result = (bool)(arg1)->eof();
7524
7525 wxPyEndAllowThreads(__tstate);
7526 if (PyErr_Occurred()) SWIG_fail;
7527 }
7528 {
7529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7530 }
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj;
7539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7540 int arg2 = (int) -1 ;
7541 PyObject *result;
7542 PyObject * obj0 = 0 ;
7543 PyObject * obj1 = 0 ;
7544 char *kwnames[] = {
7545 (char *) "self",(char *) "size", NULL
7546 };
7547
7548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7550 if (SWIG_arg_fail(1)) SWIG_fail;
7551 if (obj1) {
7552 {
7553 arg2 = (int)(SWIG_As_int(obj1));
7554 if (SWIG_arg_fail(2)) SWIG_fail;
7555 }
7556 }
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 result = (PyObject *)(arg1)->read(arg2);
7560
7561 wxPyEndAllowThreads(__tstate);
7562 if (PyErr_Occurred()) SWIG_fail;
7563 }
7564 resultobj = result;
7565 return resultobj;
7566 fail:
7567 return NULL;
7568 }
7569
7570
7571 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7572 PyObject *resultobj;
7573 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7574 int arg2 = (int) -1 ;
7575 PyObject *result;
7576 PyObject * obj0 = 0 ;
7577 PyObject * obj1 = 0 ;
7578 char *kwnames[] = {
7579 (char *) "self",(char *) "size", NULL
7580 };
7581
7582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7584 if (SWIG_arg_fail(1)) SWIG_fail;
7585 if (obj1) {
7586 {
7587 arg2 = (int)(SWIG_As_int(obj1));
7588 if (SWIG_arg_fail(2)) SWIG_fail;
7589 }
7590 }
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (PyObject *)(arg1)->readline(arg2);
7594
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 resultobj = result;
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7606 PyObject *resultobj;
7607 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7608 int arg2 = (int) -1 ;
7609 PyObject *result;
7610 PyObject * obj0 = 0 ;
7611 PyObject * obj1 = 0 ;
7612 char *kwnames[] = {
7613 (char *) "self",(char *) "sizehint", NULL
7614 };
7615
7616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7618 if (SWIG_arg_fail(1)) SWIG_fail;
7619 if (obj1) {
7620 {
7621 arg2 = (int)(SWIG_As_int(obj1));
7622 if (SWIG_arg_fail(2)) SWIG_fail;
7623 }
7624 }
7625 {
7626 PyThreadState* __tstate = wxPyBeginAllowThreads();
7627 result = (PyObject *)(arg1)->readlines(arg2);
7628
7629 wxPyEndAllowThreads(__tstate);
7630 if (PyErr_Occurred()) SWIG_fail;
7631 }
7632 resultobj = result;
7633 return resultobj;
7634 fail:
7635 return NULL;
7636 }
7637
7638
7639 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7640 PyObject *resultobj;
7641 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7642 int arg2 ;
7643 int arg3 = (int) 0 ;
7644 PyObject * obj0 = 0 ;
7645 PyObject * obj1 = 0 ;
7646 PyObject * obj2 = 0 ;
7647 char *kwnames[] = {
7648 (char *) "self",(char *) "offset",(char *) "whence", NULL
7649 };
7650
7651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7653 if (SWIG_arg_fail(1)) SWIG_fail;
7654 {
7655 arg2 = (int)(SWIG_As_int(obj1));
7656 if (SWIG_arg_fail(2)) SWIG_fail;
7657 }
7658 if (obj2) {
7659 {
7660 arg3 = (int)(SWIG_As_int(obj2));
7661 if (SWIG_arg_fail(3)) SWIG_fail;
7662 }
7663 }
7664 {
7665 PyThreadState* __tstate = wxPyBeginAllowThreads();
7666 (arg1)->seek(arg2,arg3);
7667
7668 wxPyEndAllowThreads(__tstate);
7669 if (PyErr_Occurred()) SWIG_fail;
7670 }
7671 Py_INCREF(Py_None); resultobj = Py_None;
7672 return resultobj;
7673 fail:
7674 return NULL;
7675 }
7676
7677
7678 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7679 PyObject *resultobj;
7680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7681 int result;
7682 PyObject * obj0 = 0 ;
7683 char *kwnames[] = {
7684 (char *) "self", NULL
7685 };
7686
7687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7689 if (SWIG_arg_fail(1)) SWIG_fail;
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = (int)(arg1)->tell();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = SWIG_From_int((int)(result));
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj;
7708 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7709 char result;
7710 PyObject * obj0 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7717 if (SWIG_arg_fail(1)) SWIG_fail;
7718 {
7719 PyThreadState* __tstate = wxPyBeginAllowThreads();
7720 result = (char)(arg1)->Peek();
7721
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = SWIG_From_char((char)(result));
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7737 char result;
7738 PyObject * obj0 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (char)(arg1)->GetC();
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 {
7754 resultobj = SWIG_From_char((char)(result));
7755 }
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7763 PyObject *resultobj;
7764 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7765 size_t result;
7766 PyObject * obj0 = 0 ;
7767 char *kwnames[] = {
7768 (char *) "self", NULL
7769 };
7770
7771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7773 if (SWIG_arg_fail(1)) SWIG_fail;
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (size_t)(arg1)->LastRead();
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 {
7782 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7783 }
7784 return resultobj;
7785 fail:
7786 return NULL;
7787 }
7788
7789
7790 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7791 PyObject *resultobj;
7792 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7793 bool result;
7794 PyObject * obj0 = 0 ;
7795 char *kwnames[] = {
7796 (char *) "self", NULL
7797 };
7798
7799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7801 if (SWIG_arg_fail(1)) SWIG_fail;
7802 {
7803 PyThreadState* __tstate = wxPyBeginAllowThreads();
7804 result = (bool)(arg1)->CanRead();
7805
7806 wxPyEndAllowThreads(__tstate);
7807 if (PyErr_Occurred()) SWIG_fail;
7808 }
7809 {
7810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7811 }
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7819 PyObject *resultobj;
7820 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7821 bool result;
7822 PyObject * obj0 = 0 ;
7823 char *kwnames[] = {
7824 (char *) "self", NULL
7825 };
7826
7827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
7832 result = (bool)(arg1)->Eof();
7833
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 {
7838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7839 }
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj;
7848 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7849 char arg2 ;
7850 bool result;
7851 PyObject * obj0 = 0 ;
7852 PyObject * obj1 = 0 ;
7853 char *kwnames[] = {
7854 (char *) "self",(char *) "c", NULL
7855 };
7856
7857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7859 if (SWIG_arg_fail(1)) SWIG_fail;
7860 {
7861 arg2 = (char)(SWIG_As_char(obj1));
7862 if (SWIG_arg_fail(2)) SWIG_fail;
7863 }
7864 {
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 result = (bool)(arg1)->Ungetch(arg2);
7867
7868 wxPyEndAllowThreads(__tstate);
7869 if (PyErr_Occurred()) SWIG_fail;
7870 }
7871 {
7872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7873 }
7874 return resultobj;
7875 fail:
7876 return NULL;
7877 }
7878
7879
7880 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7881 PyObject *resultobj;
7882 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7883 long arg2 ;
7884 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7885 long result;
7886 PyObject * obj0 = 0 ;
7887 PyObject * obj1 = 0 ;
7888 PyObject * obj2 = 0 ;
7889 char *kwnames[] = {
7890 (char *) "self",(char *) "pos",(char *) "mode", NULL
7891 };
7892
7893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7895 if (SWIG_arg_fail(1)) SWIG_fail;
7896 {
7897 arg2 = (long)(SWIG_As_long(obj1));
7898 if (SWIG_arg_fail(2)) SWIG_fail;
7899 }
7900 if (obj2) {
7901 {
7902 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7903 if (SWIG_arg_fail(3)) SWIG_fail;
7904 }
7905 }
7906 {
7907 PyThreadState* __tstate = wxPyBeginAllowThreads();
7908 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7909
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 {
7914 resultobj = SWIG_From_long((long)(result));
7915 }
7916 return resultobj;
7917 fail:
7918 return NULL;
7919 }
7920
7921
7922 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj;
7924 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7925 long result;
7926 PyObject * obj0 = 0 ;
7927 char *kwnames[] = {
7928 (char *) "self", NULL
7929 };
7930
7931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7933 if (SWIG_arg_fail(1)) SWIG_fail;
7934 {
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (long)(arg1)->TellI();
7937
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 {
7942 resultobj = SWIG_From_long((long)(result));
7943 }
7944 return resultobj;
7945 fail:
7946 return NULL;
7947 }
7948
7949
7950 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7951 PyObject *obj;
7952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7953 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7954 Py_INCREF(obj);
7955 return Py_BuildValue((char *)"");
7956 }
7957 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7958 PyObject *resultobj;
7959 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7960 PyObject *arg2 = (PyObject *) 0 ;
7961 PyObject * obj0 = 0 ;
7962 PyObject * obj1 = 0 ;
7963 char *kwnames[] = {
7964 (char *) "self",(char *) "obj", NULL
7965 };
7966
7967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7969 if (SWIG_arg_fail(1)) SWIG_fail;
7970 arg2 = obj1;
7971 {
7972 PyThreadState* __tstate = wxPyBeginAllowThreads();
7973 wxOutputStream_write(arg1,arg2);
7974
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 Py_INCREF(Py_None); resultobj = Py_None;
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7986 PyObject *obj;
7987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7988 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7989 Py_INCREF(obj);
7990 return Py_BuildValue((char *)"");
7991 }
7992 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7993 PyObject *resultobj;
7994 wxInputStream *arg1 = (wxInputStream *) 0 ;
7995 wxString *arg2 = 0 ;
7996 wxString *arg3 = 0 ;
7997 wxString *arg4 = 0 ;
7998 wxDateTime arg5 ;
7999 wxFSFile *result;
8000 wxPyInputStream *temp1 ;
8001 bool temp2 = false ;
8002 bool temp3 = false ;
8003 bool temp4 = false ;
8004 PyObject * obj0 = 0 ;
8005 PyObject * obj1 = 0 ;
8006 PyObject * obj2 = 0 ;
8007 PyObject * obj3 = 0 ;
8008 PyObject * obj4 = 0 ;
8009 char *kwnames[] = {
8010 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8011 };
8012
8013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8014 {
8015 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8016 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8017 } else {
8018 PyErr_Clear(); // clear the failure of the wxPyConvert above
8019 arg1 = wxPyCBInputStream_create(obj0, true);
8020 if (arg1 == NULL) {
8021 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8022 SWIG_fail;
8023 }
8024 }
8025 }
8026 {
8027 arg2 = wxString_in_helper(obj1);
8028 if (arg2 == NULL) SWIG_fail;
8029 temp2 = true;
8030 }
8031 {
8032 arg3 = wxString_in_helper(obj2);
8033 if (arg3 == NULL) SWIG_fail;
8034 temp3 = true;
8035 }
8036 {
8037 arg4 = wxString_in_helper(obj3);
8038 if (arg4 == NULL) SWIG_fail;
8039 temp4 = true;
8040 }
8041 {
8042 wxDateTime * argp;
8043 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8044 if (SWIG_arg_fail(5)) SWIG_fail;
8045 if (argp == NULL) {
8046 SWIG_null_ref("wxDateTime");
8047 }
8048 if (SWIG_arg_fail(5)) SWIG_fail;
8049 arg5 = *argp;
8050 }
8051 {
8052 PyThreadState* __tstate = wxPyBeginAllowThreads();
8053 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8054
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 {
8059 resultobj = wxPyMake_wxObject(result, 1);
8060 }
8061 {
8062 if (temp2)
8063 delete arg2;
8064 }
8065 {
8066 if (temp3)
8067 delete arg3;
8068 }
8069 {
8070 if (temp4)
8071 delete arg4;
8072 }
8073 return resultobj;
8074 fail:
8075 {
8076 if (temp2)
8077 delete arg2;
8078 }
8079 {
8080 if (temp3)
8081 delete arg3;
8082 }
8083 {
8084 if (temp4)
8085 delete arg4;
8086 }
8087 return NULL;
8088 }
8089
8090
8091 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8092 PyObject *resultobj;
8093 wxFSFile *arg1 = (wxFSFile *) 0 ;
8094 PyObject * obj0 = 0 ;
8095 char *kwnames[] = {
8096 (char *) "self", NULL
8097 };
8098
8099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8101 if (SWIG_arg_fail(1)) SWIG_fail;
8102 {
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 delete arg1;
8105
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 Py_INCREF(Py_None); resultobj = Py_None;
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj;
8118 wxFSFile *arg1 = (wxFSFile *) 0 ;
8119 wxInputStream *result;
8120 PyObject * obj0 = 0 ;
8121 char *kwnames[] = {
8122 (char *) "self", NULL
8123 };
8124
8125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8127 if (SWIG_arg_fail(1)) SWIG_fail;
8128 {
8129 PyThreadState* __tstate = wxPyBeginAllowThreads();
8130 result = (wxInputStream *)(arg1)->GetStream();
8131
8132 wxPyEndAllowThreads(__tstate);
8133 if (PyErr_Occurred()) SWIG_fail;
8134 }
8135 {
8136 wxPyInputStream * _ptr = NULL;
8137
8138 if (result) {
8139 _ptr = new wxPyInputStream(result);
8140 }
8141 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8142 }
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8150 PyObject *resultobj;
8151 wxFSFile *arg1 = (wxFSFile *) 0 ;
8152 wxString *result;
8153 PyObject * obj0 = 0 ;
8154 char *kwnames[] = {
8155 (char *) "self", NULL
8156 };
8157
8158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8160 if (SWIG_arg_fail(1)) SWIG_fail;
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 {
8164 wxString const &_result_ref = (arg1)->GetMimeType();
8165 result = (wxString *) &_result_ref;
8166 }
8167
8168 wxPyEndAllowThreads(__tstate);
8169 if (PyErr_Occurred()) SWIG_fail;
8170 }
8171 {
8172 #if wxUSE_UNICODE
8173 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8174 #else
8175 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8176 #endif
8177 }
8178 return resultobj;
8179 fail:
8180 return NULL;
8181 }
8182
8183
8184 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8185 PyObject *resultobj;
8186 wxFSFile *arg1 = (wxFSFile *) 0 ;
8187 wxString *result;
8188 PyObject * obj0 = 0 ;
8189 char *kwnames[] = {
8190 (char *) "self", NULL
8191 };
8192
8193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8195 if (SWIG_arg_fail(1)) SWIG_fail;
8196 {
8197 PyThreadState* __tstate = wxPyBeginAllowThreads();
8198 {
8199 wxString const &_result_ref = (arg1)->GetLocation();
8200 result = (wxString *) &_result_ref;
8201 }
8202
8203 wxPyEndAllowThreads(__tstate);
8204 if (PyErr_Occurred()) SWIG_fail;
8205 }
8206 {
8207 #if wxUSE_UNICODE
8208 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8209 #else
8210 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8211 #endif
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj;
8221 wxFSFile *arg1 = (wxFSFile *) 0 ;
8222 wxString *result;
8223 PyObject * obj0 = 0 ;
8224 char *kwnames[] = {
8225 (char *) "self", NULL
8226 };
8227
8228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8230 if (SWIG_arg_fail(1)) SWIG_fail;
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 {
8234 wxString const &_result_ref = (arg1)->GetAnchor();
8235 result = (wxString *) &_result_ref;
8236 }
8237
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 {
8242 #if wxUSE_UNICODE
8243 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8244 #else
8245 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8246 #endif
8247 }
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj;
8256 wxFSFile *arg1 = (wxFSFile *) 0 ;
8257 wxDateTime result;
8258 PyObject * obj0 = 0 ;
8259 char *kwnames[] = {
8260 (char *) "self", NULL
8261 };
8262
8263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8265 if (SWIG_arg_fail(1)) SWIG_fail;
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (arg1)->GetModificationTime();
8269
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 {
8274 wxDateTime * resultptr;
8275 resultptr = new wxDateTime((wxDateTime &)(result));
8276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8277 }
8278 return resultobj;
8279 fail:
8280 return NULL;
8281 }
8282
8283
8284 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8285 PyObject *obj;
8286 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8287 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8288 Py_INCREF(obj);
8289 return Py_BuildValue((char *)"");
8290 }
8291 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8292 PyObject *obj;
8293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8294 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8295 Py_INCREF(obj);
8296 return Py_BuildValue((char *)"");
8297 }
8298 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8299 PyObject *resultobj;
8300 wxPyFileSystemHandler *result;
8301 char *kwnames[] = {
8302 NULL
8303 };
8304
8305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8309
8310 wxPyEndAllowThreads(__tstate);
8311 if (PyErr_Occurred()) SWIG_fail;
8312 }
8313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8314 return resultobj;
8315 fail:
8316 return NULL;
8317 }
8318
8319
8320 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8321 PyObject *resultobj;
8322 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8323 PyObject *arg2 = (PyObject *) 0 ;
8324 PyObject *arg3 = (PyObject *) 0 ;
8325 PyObject * obj0 = 0 ;
8326 PyObject * obj1 = 0 ;
8327 PyObject * obj2 = 0 ;
8328 char *kwnames[] = {
8329 (char *) "self",(char *) "self",(char *) "_class", NULL
8330 };
8331
8332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8334 if (SWIG_arg_fail(1)) SWIG_fail;
8335 arg2 = obj1;
8336 arg3 = obj2;
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 (arg1)->_setCallbackInfo(arg2,arg3);
8340
8341 wxPyEndAllowThreads(__tstate);
8342 if (PyErr_Occurred()) SWIG_fail;
8343 }
8344 Py_INCREF(Py_None); resultobj = Py_None;
8345 return resultobj;
8346 fail:
8347 return NULL;
8348 }
8349
8350
8351 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8352 PyObject *resultobj;
8353 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8354 wxString *arg2 = 0 ;
8355 bool result;
8356 bool temp2 = false ;
8357 PyObject * obj0 = 0 ;
8358 PyObject * obj1 = 0 ;
8359 char *kwnames[] = {
8360 (char *) "self",(char *) "location", NULL
8361 };
8362
8363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8365 if (SWIG_arg_fail(1)) SWIG_fail;
8366 {
8367 arg2 = wxString_in_helper(obj1);
8368 if (arg2 == NULL) SWIG_fail;
8369 temp2 = true;
8370 }
8371 {
8372 PyThreadState* __tstate = wxPyBeginAllowThreads();
8373 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8374
8375 wxPyEndAllowThreads(__tstate);
8376 if (PyErr_Occurred()) SWIG_fail;
8377 }
8378 {
8379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8380 }
8381 {
8382 if (temp2)
8383 delete arg2;
8384 }
8385 return resultobj;
8386 fail:
8387 {
8388 if (temp2)
8389 delete arg2;
8390 }
8391 return NULL;
8392 }
8393
8394
8395 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8396 PyObject *resultobj;
8397 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8398 wxFileSystem *arg2 = 0 ;
8399 wxString *arg3 = 0 ;
8400 wxFSFile *result;
8401 bool temp3 = false ;
8402 PyObject * obj0 = 0 ;
8403 PyObject * obj1 = 0 ;
8404 PyObject * obj2 = 0 ;
8405 char *kwnames[] = {
8406 (char *) "self",(char *) "fs",(char *) "location", NULL
8407 };
8408
8409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8411 if (SWIG_arg_fail(1)) SWIG_fail;
8412 {
8413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8414 if (SWIG_arg_fail(2)) SWIG_fail;
8415 if (arg2 == NULL) {
8416 SWIG_null_ref("wxFileSystem");
8417 }
8418 if (SWIG_arg_fail(2)) SWIG_fail;
8419 }
8420 {
8421 arg3 = wxString_in_helper(obj2);
8422 if (arg3 == NULL) SWIG_fail;
8423 temp3 = true;
8424 }
8425 {
8426 PyThreadState* __tstate = wxPyBeginAllowThreads();
8427 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8428
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 {
8433 resultobj = wxPyMake_wxObject(result, 1);
8434 }
8435 {
8436 if (temp3)
8437 delete arg3;
8438 }
8439 return resultobj;
8440 fail:
8441 {
8442 if (temp3)
8443 delete arg3;
8444 }
8445 return NULL;
8446 }
8447
8448
8449 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8450 PyObject *resultobj;
8451 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8452 wxString *arg2 = 0 ;
8453 int arg3 = (int) 0 ;
8454 wxString result;
8455 bool temp2 = false ;
8456 PyObject * obj0 = 0 ;
8457 PyObject * obj1 = 0 ;
8458 PyObject * obj2 = 0 ;
8459 char *kwnames[] = {
8460 (char *) "self",(char *) "spec",(char *) "flags", NULL
8461 };
8462
8463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8465 if (SWIG_arg_fail(1)) SWIG_fail;
8466 {
8467 arg2 = wxString_in_helper(obj1);
8468 if (arg2 == NULL) SWIG_fail;
8469 temp2 = true;
8470 }
8471 if (obj2) {
8472 {
8473 arg3 = (int)(SWIG_As_int(obj2));
8474 if (SWIG_arg_fail(3)) SWIG_fail;
8475 }
8476 }
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8480
8481 wxPyEndAllowThreads(__tstate);
8482 if (PyErr_Occurred()) SWIG_fail;
8483 }
8484 {
8485 #if wxUSE_UNICODE
8486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8487 #else
8488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8489 #endif
8490 }
8491 {
8492 if (temp2)
8493 delete arg2;
8494 }
8495 return resultobj;
8496 fail:
8497 {
8498 if (temp2)
8499 delete arg2;
8500 }
8501 return NULL;
8502 }
8503
8504
8505 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8506 PyObject *resultobj;
8507 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8508 wxString result;
8509 PyObject * obj0 = 0 ;
8510 char *kwnames[] = {
8511 (char *) "self", NULL
8512 };
8513
8514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8516 if (SWIG_arg_fail(1)) SWIG_fail;
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (arg1)->FindNext();
8520
8521 wxPyEndAllowThreads(__tstate);
8522 if (PyErr_Occurred()) SWIG_fail;
8523 }
8524 {
8525 #if wxUSE_UNICODE
8526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8527 #else
8528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8529 #endif
8530 }
8531 return resultobj;
8532 fail:
8533 return NULL;
8534 }
8535
8536
8537 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8538 PyObject *resultobj;
8539 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8540 wxString *arg2 = 0 ;
8541 wxString result;
8542 bool temp2 = false ;
8543 PyObject * obj0 = 0 ;
8544 PyObject * obj1 = 0 ;
8545 char *kwnames[] = {
8546 (char *) "self",(char *) "location", NULL
8547 };
8548
8549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8551 if (SWIG_arg_fail(1)) SWIG_fail;
8552 {
8553 arg2 = wxString_in_helper(obj1);
8554 if (arg2 == NULL) SWIG_fail;
8555 temp2 = true;
8556 }
8557 {
8558 PyThreadState* __tstate = wxPyBeginAllowThreads();
8559 result = (arg1)->GetProtocol((wxString const &)*arg2);
8560
8561 wxPyEndAllowThreads(__tstate);
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 {
8565 #if wxUSE_UNICODE
8566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8567 #else
8568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8569 #endif
8570 }
8571 {
8572 if (temp2)
8573 delete arg2;
8574 }
8575 return resultobj;
8576 fail:
8577 {
8578 if (temp2)
8579 delete arg2;
8580 }
8581 return NULL;
8582 }
8583
8584
8585 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8586 PyObject *resultobj;
8587 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8588 wxString *arg2 = 0 ;
8589 wxString result;
8590 bool temp2 = false ;
8591 PyObject * obj0 = 0 ;
8592 PyObject * obj1 = 0 ;
8593 char *kwnames[] = {
8594 (char *) "self",(char *) "location", NULL
8595 };
8596
8597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8599 if (SWIG_arg_fail(1)) SWIG_fail;
8600 {
8601 arg2 = wxString_in_helper(obj1);
8602 if (arg2 == NULL) SWIG_fail;
8603 temp2 = true;
8604 }
8605 {
8606 PyThreadState* __tstate = wxPyBeginAllowThreads();
8607 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8608
8609 wxPyEndAllowThreads(__tstate);
8610 if (PyErr_Occurred()) SWIG_fail;
8611 }
8612 {
8613 #if wxUSE_UNICODE
8614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8615 #else
8616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8617 #endif
8618 }
8619 {
8620 if (temp2)
8621 delete arg2;
8622 }
8623 return resultobj;
8624 fail:
8625 {
8626 if (temp2)
8627 delete arg2;
8628 }
8629 return NULL;
8630 }
8631
8632
8633 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8634 PyObject *resultobj;
8635 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8636 wxString *arg2 = 0 ;
8637 wxString result;
8638 bool temp2 = false ;
8639 PyObject * obj0 = 0 ;
8640 PyObject * obj1 = 0 ;
8641 char *kwnames[] = {
8642 (char *) "self",(char *) "location", NULL
8643 };
8644
8645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8647 if (SWIG_arg_fail(1)) SWIG_fail;
8648 {
8649 arg2 = wxString_in_helper(obj1);
8650 if (arg2 == NULL) SWIG_fail;
8651 temp2 = true;
8652 }
8653 {
8654 PyThreadState* __tstate = wxPyBeginAllowThreads();
8655 result = (arg1)->GetAnchor((wxString const &)*arg2);
8656
8657 wxPyEndAllowThreads(__tstate);
8658 if (PyErr_Occurred()) SWIG_fail;
8659 }
8660 {
8661 #if wxUSE_UNICODE
8662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8663 #else
8664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8665 #endif
8666 }
8667 {
8668 if (temp2)
8669 delete arg2;
8670 }
8671 return resultobj;
8672 fail:
8673 {
8674 if (temp2)
8675 delete arg2;
8676 }
8677 return NULL;
8678 }
8679
8680
8681 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8682 PyObject *resultobj;
8683 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8684 wxString *arg2 = 0 ;
8685 wxString result;
8686 bool temp2 = false ;
8687 PyObject * obj0 = 0 ;
8688 PyObject * obj1 = 0 ;
8689 char *kwnames[] = {
8690 (char *) "self",(char *) "location", NULL
8691 };
8692
8693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8695 if (SWIG_arg_fail(1)) SWIG_fail;
8696 {
8697 arg2 = wxString_in_helper(obj1);
8698 if (arg2 == NULL) SWIG_fail;
8699 temp2 = true;
8700 }
8701 {
8702 PyThreadState* __tstate = wxPyBeginAllowThreads();
8703 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8704
8705 wxPyEndAllowThreads(__tstate);
8706 if (PyErr_Occurred()) SWIG_fail;
8707 }
8708 {
8709 #if wxUSE_UNICODE
8710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8711 #else
8712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8713 #endif
8714 }
8715 {
8716 if (temp2)
8717 delete arg2;
8718 }
8719 return resultobj;
8720 fail:
8721 {
8722 if (temp2)
8723 delete arg2;
8724 }
8725 return NULL;
8726 }
8727
8728
8729 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8730 PyObject *resultobj;
8731 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8732 wxString *arg2 = 0 ;
8733 wxString result;
8734 bool temp2 = false ;
8735 PyObject * obj0 = 0 ;
8736 PyObject * obj1 = 0 ;
8737 char *kwnames[] = {
8738 (char *) "self",(char *) "location", NULL
8739 };
8740
8741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8743 if (SWIG_arg_fail(1)) SWIG_fail;
8744 {
8745 arg2 = wxString_in_helper(obj1);
8746 if (arg2 == NULL) SWIG_fail;
8747 temp2 = true;
8748 }
8749 {
8750 PyThreadState* __tstate = wxPyBeginAllowThreads();
8751 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8752
8753 wxPyEndAllowThreads(__tstate);
8754 if (PyErr_Occurred()) SWIG_fail;
8755 }
8756 {
8757 #if wxUSE_UNICODE
8758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8759 #else
8760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8761 #endif
8762 }
8763 {
8764 if (temp2)
8765 delete arg2;
8766 }
8767 return resultobj;
8768 fail:
8769 {
8770 if (temp2)
8771 delete arg2;
8772 }
8773 return NULL;
8774 }
8775
8776
8777 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8778 PyObject *obj;
8779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8780 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8781 Py_INCREF(obj);
8782 return Py_BuildValue((char *)"");
8783 }
8784 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8785 PyObject *resultobj;
8786 wxFileSystem *result;
8787 char *kwnames[] = {
8788 NULL
8789 };
8790
8791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8792 {
8793 PyThreadState* __tstate = wxPyBeginAllowThreads();
8794 result = (wxFileSystem *)new wxFileSystem();
8795
8796 wxPyEndAllowThreads(__tstate);
8797 if (PyErr_Occurred()) SWIG_fail;
8798 }
8799 {
8800 resultobj = wxPyMake_wxObject(result, 1);
8801 }
8802 return resultobj;
8803 fail:
8804 return NULL;
8805 }
8806
8807
8808 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8809 PyObject *resultobj;
8810 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8811 PyObject * obj0 = 0 ;
8812 char *kwnames[] = {
8813 (char *) "self", NULL
8814 };
8815
8816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
8821 delete arg1;
8822
8823 wxPyEndAllowThreads(__tstate);
8824 if (PyErr_Occurred()) SWIG_fail;
8825 }
8826 Py_INCREF(Py_None); resultobj = Py_None;
8827 return resultobj;
8828 fail:
8829 return NULL;
8830 }
8831
8832
8833 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8834 PyObject *resultobj;
8835 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8836 wxString *arg2 = 0 ;
8837 bool arg3 = (bool) false ;
8838 bool temp2 = false ;
8839 PyObject * obj0 = 0 ;
8840 PyObject * obj1 = 0 ;
8841 PyObject * obj2 = 0 ;
8842 char *kwnames[] = {
8843 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8844 };
8845
8846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8848 if (SWIG_arg_fail(1)) SWIG_fail;
8849 {
8850 arg2 = wxString_in_helper(obj1);
8851 if (arg2 == NULL) SWIG_fail;
8852 temp2 = true;
8853 }
8854 if (obj2) {
8855 {
8856 arg3 = (bool)(SWIG_As_bool(obj2));
8857 if (SWIG_arg_fail(3)) SWIG_fail;
8858 }
8859 }
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8863
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 Py_INCREF(Py_None); resultobj = Py_None;
8868 {
8869 if (temp2)
8870 delete arg2;
8871 }
8872 return resultobj;
8873 fail:
8874 {
8875 if (temp2)
8876 delete arg2;
8877 }
8878 return NULL;
8879 }
8880
8881
8882 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8883 PyObject *resultobj;
8884 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8885 wxString result;
8886 PyObject * obj0 = 0 ;
8887 char *kwnames[] = {
8888 (char *) "self", NULL
8889 };
8890
8891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8893 if (SWIG_arg_fail(1)) SWIG_fail;
8894 {
8895 PyThreadState* __tstate = wxPyBeginAllowThreads();
8896 result = (arg1)->GetPath();
8897
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 {
8902 #if wxUSE_UNICODE
8903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8904 #else
8905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8906 #endif
8907 }
8908 return resultobj;
8909 fail:
8910 return NULL;
8911 }
8912
8913
8914 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj;
8916 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8917 wxString *arg2 = 0 ;
8918 wxFSFile *result;
8919 bool temp2 = false ;
8920 PyObject * obj0 = 0 ;
8921 PyObject * obj1 = 0 ;
8922 char *kwnames[] = {
8923 (char *) "self",(char *) "location", NULL
8924 };
8925
8926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8928 if (SWIG_arg_fail(1)) SWIG_fail;
8929 {
8930 arg2 = wxString_in_helper(obj1);
8931 if (arg2 == NULL) SWIG_fail;
8932 temp2 = true;
8933 }
8934 {
8935 PyThreadState* __tstate = wxPyBeginAllowThreads();
8936 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8937
8938 wxPyEndAllowThreads(__tstate);
8939 if (PyErr_Occurred()) SWIG_fail;
8940 }
8941 {
8942 resultobj = wxPyMake_wxObject(result, 1);
8943 }
8944 {
8945 if (temp2)
8946 delete arg2;
8947 }
8948 return resultobj;
8949 fail:
8950 {
8951 if (temp2)
8952 delete arg2;
8953 }
8954 return NULL;
8955 }
8956
8957
8958 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8959 PyObject *resultobj;
8960 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8961 wxString *arg2 = 0 ;
8962 int arg3 = (int) 0 ;
8963 wxString result;
8964 bool temp2 = false ;
8965 PyObject * obj0 = 0 ;
8966 PyObject * obj1 = 0 ;
8967 PyObject * obj2 = 0 ;
8968 char *kwnames[] = {
8969 (char *) "self",(char *) "spec",(char *) "flags", NULL
8970 };
8971
8972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8974 if (SWIG_arg_fail(1)) SWIG_fail;
8975 {
8976 arg2 = wxString_in_helper(obj1);
8977 if (arg2 == NULL) SWIG_fail;
8978 temp2 = true;
8979 }
8980 if (obj2) {
8981 {
8982 arg3 = (int)(SWIG_As_int(obj2));
8983 if (SWIG_arg_fail(3)) SWIG_fail;
8984 }
8985 }
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 {
8994 #if wxUSE_UNICODE
8995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8996 #else
8997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8998 #endif
8999 }
9000 {
9001 if (temp2)
9002 delete arg2;
9003 }
9004 return resultobj;
9005 fail:
9006 {
9007 if (temp2)
9008 delete arg2;
9009 }
9010 return NULL;
9011 }
9012
9013
9014 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9015 PyObject *resultobj;
9016 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9017 wxString result;
9018 PyObject * obj0 = 0 ;
9019 char *kwnames[] = {
9020 (char *) "self", NULL
9021 };
9022
9023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9025 if (SWIG_arg_fail(1)) SWIG_fail;
9026 {
9027 PyThreadState* __tstate = wxPyBeginAllowThreads();
9028 result = (arg1)->FindNext();
9029
9030 wxPyEndAllowThreads(__tstate);
9031 if (PyErr_Occurred()) SWIG_fail;
9032 }
9033 {
9034 #if wxUSE_UNICODE
9035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9036 #else
9037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9038 #endif
9039 }
9040 return resultobj;
9041 fail:
9042 return NULL;
9043 }
9044
9045
9046 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj;
9048 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9049 PyObject * obj0 = 0 ;
9050 char *kwnames[] = {
9051 (char *) "handler", NULL
9052 };
9053
9054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9056 if (SWIG_arg_fail(1)) SWIG_fail;
9057 {
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 wxFileSystem::AddHandler(arg1);
9060
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 Py_INCREF(Py_None); resultobj = Py_None;
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9072 PyObject *resultobj;
9073 char *kwnames[] = {
9074 NULL
9075 };
9076
9077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9078 {
9079 PyThreadState* __tstate = wxPyBeginAllowThreads();
9080 wxFileSystem::CleanUpHandlers();
9081
9082 wxPyEndAllowThreads(__tstate);
9083 if (PyErr_Occurred()) SWIG_fail;
9084 }
9085 Py_INCREF(Py_None); resultobj = Py_None;
9086 return resultobj;
9087 fail:
9088 return NULL;
9089 }
9090
9091
9092 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9093 PyObject *resultobj;
9094 wxString *arg1 = 0 ;
9095 wxString result;
9096 bool temp1 = false ;
9097 PyObject * obj0 = 0 ;
9098 char *kwnames[] = {
9099 (char *) "filename", NULL
9100 };
9101
9102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9103 {
9104 arg1 = wxString_in_helper(obj0);
9105 if (arg1 == NULL) SWIG_fail;
9106 temp1 = true;
9107 }
9108 {
9109 PyThreadState* __tstate = wxPyBeginAllowThreads();
9110 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9111
9112 wxPyEndAllowThreads(__tstate);
9113 if (PyErr_Occurred()) SWIG_fail;
9114 }
9115 {
9116 #if wxUSE_UNICODE
9117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9118 #else
9119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9120 #endif
9121 }
9122 {
9123 if (temp1)
9124 delete arg1;
9125 }
9126 return resultobj;
9127 fail:
9128 {
9129 if (temp1)
9130 delete arg1;
9131 }
9132 return NULL;
9133 }
9134
9135
9136 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9137 PyObject *resultobj;
9138 wxString *arg1 = 0 ;
9139 wxString result;
9140 bool temp1 = false ;
9141 PyObject * obj0 = 0 ;
9142 char *kwnames[] = {
9143 (char *) "url", NULL
9144 };
9145
9146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9147 {
9148 arg1 = wxString_in_helper(obj0);
9149 if (arg1 == NULL) SWIG_fail;
9150 temp1 = true;
9151 }
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 result = FileSystem_URLToFileName((wxString const &)*arg1);
9155
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 {
9160 #if wxUSE_UNICODE
9161 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9162 #else
9163 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9164 #endif
9165 }
9166 {
9167 if (temp1)
9168 delete arg1;
9169 }
9170 return resultobj;
9171 fail:
9172 {
9173 if (temp1)
9174 delete arg1;
9175 }
9176 return NULL;
9177 }
9178
9179
9180 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9181 PyObject *obj;
9182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9183 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9184 Py_INCREF(obj);
9185 return Py_BuildValue((char *)"");
9186 }
9187 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9188 PyObject *resultobj;
9189 wxInternetFSHandler *result;
9190 char *kwnames[] = {
9191 NULL
9192 };
9193
9194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9195 {
9196 PyThreadState* __tstate = wxPyBeginAllowThreads();
9197 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9198
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9203 return resultobj;
9204 fail:
9205 return NULL;
9206 }
9207
9208
9209 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9210 PyObject *resultobj;
9211 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9212 wxString *arg2 = 0 ;
9213 bool result;
9214 bool temp2 = false ;
9215 PyObject * obj0 = 0 ;
9216 PyObject * obj1 = 0 ;
9217 char *kwnames[] = {
9218 (char *) "self",(char *) "location", NULL
9219 };
9220
9221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9223 if (SWIG_arg_fail(1)) SWIG_fail;
9224 {
9225 arg2 = wxString_in_helper(obj1);
9226 if (arg2 == NULL) SWIG_fail;
9227 temp2 = true;
9228 }
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9232
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 {
9237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9238 }
9239 {
9240 if (temp2)
9241 delete arg2;
9242 }
9243 return resultobj;
9244 fail:
9245 {
9246 if (temp2)
9247 delete arg2;
9248 }
9249 return NULL;
9250 }
9251
9252
9253 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9254 PyObject *resultobj;
9255 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9256 wxFileSystem *arg2 = 0 ;
9257 wxString *arg3 = 0 ;
9258 wxFSFile *result;
9259 bool temp3 = false ;
9260 PyObject * obj0 = 0 ;
9261 PyObject * obj1 = 0 ;
9262 PyObject * obj2 = 0 ;
9263 char *kwnames[] = {
9264 (char *) "self",(char *) "fs",(char *) "location", NULL
9265 };
9266
9267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9269 if (SWIG_arg_fail(1)) SWIG_fail;
9270 {
9271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9272 if (SWIG_arg_fail(2)) SWIG_fail;
9273 if (arg2 == NULL) {
9274 SWIG_null_ref("wxFileSystem");
9275 }
9276 if (SWIG_arg_fail(2)) SWIG_fail;
9277 }
9278 {
9279 arg3 = wxString_in_helper(obj2);
9280 if (arg3 == NULL) SWIG_fail;
9281 temp3 = true;
9282 }
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9286
9287 wxPyEndAllowThreads(__tstate);
9288 if (PyErr_Occurred()) SWIG_fail;
9289 }
9290 {
9291 resultobj = wxPyMake_wxObject(result, 1);
9292 }
9293 {
9294 if (temp3)
9295 delete arg3;
9296 }
9297 return resultobj;
9298 fail:
9299 {
9300 if (temp3)
9301 delete arg3;
9302 }
9303 return NULL;
9304 }
9305
9306
9307 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9308 PyObject *obj;
9309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9310 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9311 Py_INCREF(obj);
9312 return Py_BuildValue((char *)"");
9313 }
9314 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj;
9316 wxZipFSHandler *result;
9317 char *kwnames[] = {
9318 NULL
9319 };
9320
9321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9322 {
9323 PyThreadState* __tstate = wxPyBeginAllowThreads();
9324 result = (wxZipFSHandler *)new wxZipFSHandler();
9325
9326 wxPyEndAllowThreads(__tstate);
9327 if (PyErr_Occurred()) SWIG_fail;
9328 }
9329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9330 return resultobj;
9331 fail:
9332 return NULL;
9333 }
9334
9335
9336 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9337 PyObject *resultobj;
9338 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9339 wxString *arg2 = 0 ;
9340 bool result;
9341 bool temp2 = false ;
9342 PyObject * obj0 = 0 ;
9343 PyObject * obj1 = 0 ;
9344 char *kwnames[] = {
9345 (char *) "self",(char *) "location", NULL
9346 };
9347
9348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9350 if (SWIG_arg_fail(1)) SWIG_fail;
9351 {
9352 arg2 = wxString_in_helper(obj1);
9353 if (arg2 == NULL) SWIG_fail;
9354 temp2 = true;
9355 }
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9359
9360 wxPyEndAllowThreads(__tstate);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 {
9364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9365 }
9366 {
9367 if (temp2)
9368 delete arg2;
9369 }
9370 return resultobj;
9371 fail:
9372 {
9373 if (temp2)
9374 delete arg2;
9375 }
9376 return NULL;
9377 }
9378
9379
9380 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9381 PyObject *resultobj;
9382 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9383 wxFileSystem *arg2 = 0 ;
9384 wxString *arg3 = 0 ;
9385 wxFSFile *result;
9386 bool temp3 = false ;
9387 PyObject * obj0 = 0 ;
9388 PyObject * obj1 = 0 ;
9389 PyObject * obj2 = 0 ;
9390 char *kwnames[] = {
9391 (char *) "self",(char *) "fs",(char *) "location", NULL
9392 };
9393
9394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9396 if (SWIG_arg_fail(1)) SWIG_fail;
9397 {
9398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9399 if (SWIG_arg_fail(2)) SWIG_fail;
9400 if (arg2 == NULL) {
9401 SWIG_null_ref("wxFileSystem");
9402 }
9403 if (SWIG_arg_fail(2)) SWIG_fail;
9404 }
9405 {
9406 arg3 = wxString_in_helper(obj2);
9407 if (arg3 == NULL) SWIG_fail;
9408 temp3 = true;
9409 }
9410 {
9411 PyThreadState* __tstate = wxPyBeginAllowThreads();
9412 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9413
9414 wxPyEndAllowThreads(__tstate);
9415 if (PyErr_Occurred()) SWIG_fail;
9416 }
9417 {
9418 resultobj = wxPyMake_wxObject(result, 1);
9419 }
9420 {
9421 if (temp3)
9422 delete arg3;
9423 }
9424 return resultobj;
9425 fail:
9426 {
9427 if (temp3)
9428 delete arg3;
9429 }
9430 return NULL;
9431 }
9432
9433
9434 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj;
9436 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9437 wxString *arg2 = 0 ;
9438 int arg3 = (int) 0 ;
9439 wxString result;
9440 bool temp2 = false ;
9441 PyObject * obj0 = 0 ;
9442 PyObject * obj1 = 0 ;
9443 PyObject * obj2 = 0 ;
9444 char *kwnames[] = {
9445 (char *) "self",(char *) "spec",(char *) "flags", NULL
9446 };
9447
9448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9450 if (SWIG_arg_fail(1)) SWIG_fail;
9451 {
9452 arg2 = wxString_in_helper(obj1);
9453 if (arg2 == NULL) SWIG_fail;
9454 temp2 = true;
9455 }
9456 if (obj2) {
9457 {
9458 arg3 = (int)(SWIG_As_int(obj2));
9459 if (SWIG_arg_fail(3)) SWIG_fail;
9460 }
9461 }
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 {
9470 #if wxUSE_UNICODE
9471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9472 #else
9473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9474 #endif
9475 }
9476 {
9477 if (temp2)
9478 delete arg2;
9479 }
9480 return resultobj;
9481 fail:
9482 {
9483 if (temp2)
9484 delete arg2;
9485 }
9486 return NULL;
9487 }
9488
9489
9490 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9491 PyObject *resultobj;
9492 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9493 wxString result;
9494 PyObject * obj0 = 0 ;
9495 char *kwnames[] = {
9496 (char *) "self", NULL
9497 };
9498
9499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9501 if (SWIG_arg_fail(1)) SWIG_fail;
9502 {
9503 PyThreadState* __tstate = wxPyBeginAllowThreads();
9504 result = (arg1)->FindNext();
9505
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 {
9510 #if wxUSE_UNICODE
9511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9512 #else
9513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9514 #endif
9515 }
9516 return resultobj;
9517 fail:
9518 return NULL;
9519 }
9520
9521
9522 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9523 PyObject *obj;
9524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9525 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9526 Py_INCREF(obj);
9527 return Py_BuildValue((char *)"");
9528 }
9529 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj;
9531 wxString *arg1 = 0 ;
9532 wxImage *arg2 = 0 ;
9533 long arg3 ;
9534 bool temp1 = false ;
9535 PyObject * obj0 = 0 ;
9536 PyObject * obj1 = 0 ;
9537 PyObject * obj2 = 0 ;
9538 char *kwnames[] = {
9539 (char *) "filename",(char *) "image",(char *) "type", NULL
9540 };
9541
9542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9543 {
9544 arg1 = wxString_in_helper(obj0);
9545 if (arg1 == NULL) SWIG_fail;
9546 temp1 = true;
9547 }
9548 {
9549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9550 if (SWIG_arg_fail(2)) SWIG_fail;
9551 if (arg2 == NULL) {
9552 SWIG_null_ref("wxImage");
9553 }
9554 if (SWIG_arg_fail(2)) SWIG_fail;
9555 }
9556 {
9557 arg3 = (long)(SWIG_As_long(obj2));
9558 if (SWIG_arg_fail(3)) SWIG_fail;
9559 }
9560 {
9561 PyThreadState* __tstate = wxPyBeginAllowThreads();
9562 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9563
9564 wxPyEndAllowThreads(__tstate);
9565 if (PyErr_Occurred()) SWIG_fail;
9566 }
9567 Py_INCREF(Py_None); resultobj = Py_None;
9568 {
9569 if (temp1)
9570 delete arg1;
9571 }
9572 return resultobj;
9573 fail:
9574 {
9575 if (temp1)
9576 delete arg1;
9577 }
9578 return NULL;
9579 }
9580
9581
9582 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9583 PyObject *resultobj;
9584 wxString *arg1 = 0 ;
9585 wxBitmap *arg2 = 0 ;
9586 long arg3 ;
9587 bool temp1 = false ;
9588 PyObject * obj0 = 0 ;
9589 PyObject * obj1 = 0 ;
9590 PyObject * obj2 = 0 ;
9591 char *kwnames[] = {
9592 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9593 };
9594
9595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9596 {
9597 arg1 = wxString_in_helper(obj0);
9598 if (arg1 == NULL) SWIG_fail;
9599 temp1 = true;
9600 }
9601 {
9602 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9603 if (SWIG_arg_fail(2)) SWIG_fail;
9604 if (arg2 == NULL) {
9605 SWIG_null_ref("wxBitmap");
9606 }
9607 if (SWIG_arg_fail(2)) SWIG_fail;
9608 }
9609 {
9610 arg3 = (long)(SWIG_As_long(obj2));
9611 if (SWIG_arg_fail(3)) SWIG_fail;
9612 }
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9616
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 Py_INCREF(Py_None); resultobj = Py_None;
9621 {
9622 if (temp1)
9623 delete arg1;
9624 }
9625 return resultobj;
9626 fail:
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return NULL;
9632 }
9633
9634
9635 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj;
9637 wxString *arg1 = 0 ;
9638 PyObject *arg2 = (PyObject *) 0 ;
9639 bool temp1 = false ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char *kwnames[] = {
9643 (char *) "filename",(char *) "data", NULL
9644 };
9645
9646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9647 {
9648 arg1 = wxString_in_helper(obj0);
9649 if (arg1 == NULL) SWIG_fail;
9650 temp1 = true;
9651 }
9652 arg2 = obj1;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9656
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 Py_INCREF(Py_None); resultobj = Py_None;
9661 {
9662 if (temp1)
9663 delete arg1;
9664 }
9665 return resultobj;
9666 fail:
9667 {
9668 if (temp1)
9669 delete arg1;
9670 }
9671 return NULL;
9672 }
9673
9674
9675 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9676 PyObject *resultobj;
9677 wxMemoryFSHandler *result;
9678 char *kwnames[] = {
9679 NULL
9680 };
9681
9682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9686
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9698 PyObject *resultobj;
9699 wxString *arg1 = 0 ;
9700 bool temp1 = false ;
9701 PyObject * obj0 = 0 ;
9702 char *kwnames[] = {
9703 (char *) "filename", NULL
9704 };
9705
9706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9707 {
9708 arg1 = wxString_in_helper(obj0);
9709 if (arg1 == NULL) SWIG_fail;
9710 temp1 = true;
9711 }
9712 {
9713 PyThreadState* __tstate = wxPyBeginAllowThreads();
9714 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9715
9716 wxPyEndAllowThreads(__tstate);
9717 if (PyErr_Occurred()) SWIG_fail;
9718 }
9719 Py_INCREF(Py_None); resultobj = Py_None;
9720 {
9721 if (temp1)
9722 delete arg1;
9723 }
9724 return resultobj;
9725 fail:
9726 {
9727 if (temp1)
9728 delete arg1;
9729 }
9730 return NULL;
9731 }
9732
9733
9734 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9735 PyObject *resultobj;
9736 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9737 wxString *arg2 = 0 ;
9738 bool result;
9739 bool temp2 = false ;
9740 PyObject * obj0 = 0 ;
9741 PyObject * obj1 = 0 ;
9742 char *kwnames[] = {
9743 (char *) "self",(char *) "location", NULL
9744 };
9745
9746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9748 if (SWIG_arg_fail(1)) SWIG_fail;
9749 {
9750 arg2 = wxString_in_helper(obj1);
9751 if (arg2 == NULL) SWIG_fail;
9752 temp2 = true;
9753 }
9754 {
9755 PyThreadState* __tstate = wxPyBeginAllowThreads();
9756 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9757
9758 wxPyEndAllowThreads(__tstate);
9759 if (PyErr_Occurred()) SWIG_fail;
9760 }
9761 {
9762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9763 }
9764 {
9765 if (temp2)
9766 delete arg2;
9767 }
9768 return resultobj;
9769 fail:
9770 {
9771 if (temp2)
9772 delete arg2;
9773 }
9774 return NULL;
9775 }
9776
9777
9778 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9779 PyObject *resultobj;
9780 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9781 wxFileSystem *arg2 = 0 ;
9782 wxString *arg3 = 0 ;
9783 wxFSFile *result;
9784 bool temp3 = false ;
9785 PyObject * obj0 = 0 ;
9786 PyObject * obj1 = 0 ;
9787 PyObject * obj2 = 0 ;
9788 char *kwnames[] = {
9789 (char *) "self",(char *) "fs",(char *) "location", NULL
9790 };
9791
9792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9794 if (SWIG_arg_fail(1)) SWIG_fail;
9795 {
9796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9797 if (SWIG_arg_fail(2)) SWIG_fail;
9798 if (arg2 == NULL) {
9799 SWIG_null_ref("wxFileSystem");
9800 }
9801 if (SWIG_arg_fail(2)) SWIG_fail;
9802 }
9803 {
9804 arg3 = wxString_in_helper(obj2);
9805 if (arg3 == NULL) SWIG_fail;
9806 temp3 = true;
9807 }
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9811
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 resultobj = wxPyMake_wxObject(result, 1);
9817 }
9818 {
9819 if (temp3)
9820 delete arg3;
9821 }
9822 return resultobj;
9823 fail:
9824 {
9825 if (temp3)
9826 delete arg3;
9827 }
9828 return NULL;
9829 }
9830
9831
9832 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9833 PyObject *resultobj;
9834 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9835 wxString *arg2 = 0 ;
9836 int arg3 = (int) 0 ;
9837 wxString result;
9838 bool temp2 = false ;
9839 PyObject * obj0 = 0 ;
9840 PyObject * obj1 = 0 ;
9841 PyObject * obj2 = 0 ;
9842 char *kwnames[] = {
9843 (char *) "self",(char *) "spec",(char *) "flags", NULL
9844 };
9845
9846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9848 if (SWIG_arg_fail(1)) SWIG_fail;
9849 {
9850 arg2 = wxString_in_helper(obj1);
9851 if (arg2 == NULL) SWIG_fail;
9852 temp2 = true;
9853 }
9854 if (obj2) {
9855 {
9856 arg3 = (int)(SWIG_As_int(obj2));
9857 if (SWIG_arg_fail(3)) SWIG_fail;
9858 }
9859 }
9860 {
9861 PyThreadState* __tstate = wxPyBeginAllowThreads();
9862 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9863
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 {
9868 #if wxUSE_UNICODE
9869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9870 #else
9871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9872 #endif
9873 }
9874 {
9875 if (temp2)
9876 delete arg2;
9877 }
9878 return resultobj;
9879 fail:
9880 {
9881 if (temp2)
9882 delete arg2;
9883 }
9884 return NULL;
9885 }
9886
9887
9888 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9889 PyObject *resultobj;
9890 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9891 wxString result;
9892 PyObject * obj0 = 0 ;
9893 char *kwnames[] = {
9894 (char *) "self", NULL
9895 };
9896
9897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9899 if (SWIG_arg_fail(1)) SWIG_fail;
9900 {
9901 PyThreadState* __tstate = wxPyBeginAllowThreads();
9902 result = (arg1)->FindNext();
9903
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 #if wxUSE_UNICODE
9909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9910 #else
9911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9912 #endif
9913 }
9914 return resultobj;
9915 fail:
9916 return NULL;
9917 }
9918
9919
9920 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9921 PyObject *obj;
9922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9923 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9924 Py_INCREF(obj);
9925 return Py_BuildValue((char *)"");
9926 }
9927 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9928 PyObject *resultobj;
9929 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9930 wxString result;
9931 PyObject * obj0 = 0 ;
9932 char *kwnames[] = {
9933 (char *) "self", NULL
9934 };
9935
9936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9938 if (SWIG_arg_fail(1)) SWIG_fail;
9939 {
9940 PyThreadState* __tstate = wxPyBeginAllowThreads();
9941 result = (arg1)->GetName();
9942
9943 wxPyEndAllowThreads(__tstate);
9944 if (PyErr_Occurred()) SWIG_fail;
9945 }
9946 {
9947 #if wxUSE_UNICODE
9948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9949 #else
9950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9951 #endif
9952 }
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj;
9961 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9962 wxString result;
9963 PyObject * obj0 = 0 ;
9964 char *kwnames[] = {
9965 (char *) "self", NULL
9966 };
9967
9968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9970 if (SWIG_arg_fail(1)) SWIG_fail;
9971 {
9972 PyThreadState* __tstate = wxPyBeginAllowThreads();
9973 result = (arg1)->GetExtension();
9974
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 {
9979 #if wxUSE_UNICODE
9980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9981 #else
9982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9983 #endif
9984 }
9985 return resultobj;
9986 fail:
9987 return NULL;
9988 }
9989
9990
9991 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9992 PyObject *resultobj;
9993 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9994 long result;
9995 PyObject * obj0 = 0 ;
9996 char *kwnames[] = {
9997 (char *) "self", NULL
9998 };
9999
10000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10002 if (SWIG_arg_fail(1)) SWIG_fail;
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 result = (long)(arg1)->GetType();
10006
10007 wxPyEndAllowThreads(__tstate);
10008 if (PyErr_Occurred()) SWIG_fail;
10009 }
10010 {
10011 resultobj = SWIG_From_long((long)(result));
10012 }
10013 return resultobj;
10014 fail:
10015 return NULL;
10016 }
10017
10018
10019 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10020 PyObject *resultobj;
10021 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10022 wxString result;
10023 PyObject * obj0 = 0 ;
10024 char *kwnames[] = {
10025 (char *) "self", NULL
10026 };
10027
10028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10030 if (SWIG_arg_fail(1)) SWIG_fail;
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 result = (arg1)->GetMimeType();
10034
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 {
10039 #if wxUSE_UNICODE
10040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10041 #else
10042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10043 #endif
10044 }
10045 return resultobj;
10046 fail:
10047 return NULL;
10048 }
10049
10050
10051 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10052 PyObject *resultobj;
10053 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10054 wxString *arg2 = 0 ;
10055 bool result;
10056 bool temp2 = false ;
10057 PyObject * obj0 = 0 ;
10058 PyObject * obj1 = 0 ;
10059 char *kwnames[] = {
10060 (char *) "self",(char *) "name", NULL
10061 };
10062
10063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10065 if (SWIG_arg_fail(1)) SWIG_fail;
10066 {
10067 arg2 = wxString_in_helper(obj1);
10068 if (arg2 == NULL) SWIG_fail;
10069 temp2 = true;
10070 }
10071 {
10072 PyThreadState* __tstate = wxPyBeginAllowThreads();
10073 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10074
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 {
10079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10080 }
10081 {
10082 if (temp2)
10083 delete arg2;
10084 }
10085 return resultobj;
10086 fail:
10087 {
10088 if (temp2)
10089 delete arg2;
10090 }
10091 return NULL;
10092 }
10093
10094
10095 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj;
10097 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10098 wxString *arg2 = 0 ;
10099 bool temp2 = false ;
10100 PyObject * obj0 = 0 ;
10101 PyObject * obj1 = 0 ;
10102 char *kwnames[] = {
10103 (char *) "self",(char *) "name", NULL
10104 };
10105
10106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10108 if (SWIG_arg_fail(1)) SWIG_fail;
10109 {
10110 arg2 = wxString_in_helper(obj1);
10111 if (arg2 == NULL) SWIG_fail;
10112 temp2 = true;
10113 }
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 (arg1)->SetName((wxString const &)*arg2);
10117
10118 wxPyEndAllowThreads(__tstate);
10119 if (PyErr_Occurred()) SWIG_fail;
10120 }
10121 Py_INCREF(Py_None); resultobj = Py_None;
10122 {
10123 if (temp2)
10124 delete arg2;
10125 }
10126 return resultobj;
10127 fail:
10128 {
10129 if (temp2)
10130 delete arg2;
10131 }
10132 return NULL;
10133 }
10134
10135
10136 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10137 PyObject *resultobj;
10138 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10139 wxString *arg2 = 0 ;
10140 bool temp2 = false ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 char *kwnames[] = {
10144 (char *) "self",(char *) "extension", NULL
10145 };
10146
10147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10149 if (SWIG_arg_fail(1)) SWIG_fail;
10150 {
10151 arg2 = wxString_in_helper(obj1);
10152 if (arg2 == NULL) SWIG_fail;
10153 temp2 = true;
10154 }
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 (arg1)->SetExtension((wxString const &)*arg2);
10158
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 Py_INCREF(Py_None); resultobj = Py_None;
10163 {
10164 if (temp2)
10165 delete arg2;
10166 }
10167 return resultobj;
10168 fail:
10169 {
10170 if (temp2)
10171 delete arg2;
10172 }
10173 return NULL;
10174 }
10175
10176
10177 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10178 PyObject *resultobj;
10179 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10180 long arg2 ;
10181 PyObject * obj0 = 0 ;
10182 PyObject * obj1 = 0 ;
10183 char *kwnames[] = {
10184 (char *) "self",(char *) "type", NULL
10185 };
10186
10187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10189 if (SWIG_arg_fail(1)) SWIG_fail;
10190 {
10191 arg2 = (long)(SWIG_As_long(obj1));
10192 if (SWIG_arg_fail(2)) SWIG_fail;
10193 }
10194 {
10195 PyThreadState* __tstate = wxPyBeginAllowThreads();
10196 (arg1)->SetType(arg2);
10197
10198 wxPyEndAllowThreads(__tstate);
10199 if (PyErr_Occurred()) SWIG_fail;
10200 }
10201 Py_INCREF(Py_None); resultobj = Py_None;
10202 return resultobj;
10203 fail:
10204 return NULL;
10205 }
10206
10207
10208 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10209 PyObject *resultobj;
10210 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10211 wxString *arg2 = 0 ;
10212 bool temp2 = false ;
10213 PyObject * obj0 = 0 ;
10214 PyObject * obj1 = 0 ;
10215 char *kwnames[] = {
10216 (char *) "self",(char *) "mimetype", NULL
10217 };
10218
10219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10221 if (SWIG_arg_fail(1)) SWIG_fail;
10222 {
10223 arg2 = wxString_in_helper(obj1);
10224 if (arg2 == NULL) SWIG_fail;
10225 temp2 = true;
10226 }
10227 {
10228 PyThreadState* __tstate = wxPyBeginAllowThreads();
10229 (arg1)->SetMimeType((wxString const &)*arg2);
10230
10231 wxPyEndAllowThreads(__tstate);
10232 if (PyErr_Occurred()) SWIG_fail;
10233 }
10234 Py_INCREF(Py_None); resultobj = Py_None;
10235 {
10236 if (temp2)
10237 delete arg2;
10238 }
10239 return resultobj;
10240 fail:
10241 {
10242 if (temp2)
10243 delete arg2;
10244 }
10245 return NULL;
10246 }
10247
10248
10249 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10250 PyObject *obj;
10251 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10252 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10253 Py_INCREF(obj);
10254 return Py_BuildValue((char *)"");
10255 }
10256 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10257 PyObject *resultobj;
10258 wxPyImageHandler *result;
10259 char *kwnames[] = {
10260 NULL
10261 };
10262
10263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10264 {
10265 PyThreadState* __tstate = wxPyBeginAllowThreads();
10266 result = (wxPyImageHandler *)new wxPyImageHandler();
10267
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10272 return resultobj;
10273 fail:
10274 return NULL;
10275 }
10276
10277
10278 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10279 PyObject *resultobj;
10280 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10281 PyObject *arg2 = (PyObject *) 0 ;
10282 PyObject * obj0 = 0 ;
10283 PyObject * obj1 = 0 ;
10284 char *kwnames[] = {
10285 (char *) "self",(char *) "self", NULL
10286 };
10287
10288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10290 if (SWIG_arg_fail(1)) SWIG_fail;
10291 arg2 = obj1;
10292 {
10293 PyThreadState* __tstate = wxPyBeginAllowThreads();
10294 (arg1)->_SetSelf(arg2);
10295
10296 wxPyEndAllowThreads(__tstate);
10297 if (PyErr_Occurred()) SWIG_fail;
10298 }
10299 Py_INCREF(Py_None); resultobj = Py_None;
10300 return resultobj;
10301 fail:
10302 return NULL;
10303 }
10304
10305
10306 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10307 PyObject *obj;
10308 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10309 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10310 Py_INCREF(obj);
10311 return Py_BuildValue((char *)"");
10312 }
10313 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10314 PyObject *resultobj;
10315 wxImageHistogram *result;
10316 char *kwnames[] = {
10317 NULL
10318 };
10319
10320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10321 {
10322 PyThreadState* __tstate = wxPyBeginAllowThreads();
10323 result = (wxImageHistogram *)new wxImageHistogram();
10324
10325 wxPyEndAllowThreads(__tstate);
10326 if (PyErr_Occurred()) SWIG_fail;
10327 }
10328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10329 return resultobj;
10330 fail:
10331 return NULL;
10332 }
10333
10334
10335 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10336 PyObject *resultobj;
10337 byte arg1 ;
10338 byte arg2 ;
10339 byte arg3 ;
10340 unsigned long result;
10341 PyObject * obj0 = 0 ;
10342 PyObject * obj1 = 0 ;
10343 PyObject * obj2 = 0 ;
10344 char *kwnames[] = {
10345 (char *) "r",(char *) "g",(char *) "b", NULL
10346 };
10347
10348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10349 {
10350 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10351 if (SWIG_arg_fail(1)) SWIG_fail;
10352 }
10353 {
10354 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10355 if (SWIG_arg_fail(2)) SWIG_fail;
10356 }
10357 {
10358 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10359 if (SWIG_arg_fail(3)) SWIG_fail;
10360 }
10361 {
10362 PyThreadState* __tstate = wxPyBeginAllowThreads();
10363 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10364
10365 wxPyEndAllowThreads(__tstate);
10366 if (PyErr_Occurred()) SWIG_fail;
10367 }
10368 {
10369 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10370 }
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj;
10379 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10380 byte *arg2 = (byte *) 0 ;
10381 byte *arg3 = (byte *) 0 ;
10382 byte *arg4 = (byte *) 0 ;
10383 byte arg5 = (byte) 1 ;
10384 byte arg6 = (byte) 0 ;
10385 byte arg7 = (byte) 0 ;
10386 bool result;
10387 byte temp2 ;
10388 int res2 = 0 ;
10389 byte temp3 ;
10390 int res3 = 0 ;
10391 byte temp4 ;
10392 int res4 = 0 ;
10393 PyObject * obj0 = 0 ;
10394 PyObject * obj1 = 0 ;
10395 PyObject * obj2 = 0 ;
10396 PyObject * obj3 = 0 ;
10397 char *kwnames[] = {
10398 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10399 };
10400
10401 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10402 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10403 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10406 if (SWIG_arg_fail(1)) SWIG_fail;
10407 if (obj1) {
10408 {
10409 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10410 if (SWIG_arg_fail(5)) SWIG_fail;
10411 }
10412 }
10413 if (obj2) {
10414 {
10415 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10416 if (SWIG_arg_fail(6)) SWIG_fail;
10417 }
10418 }
10419 if (obj3) {
10420 {
10421 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10422 if (SWIG_arg_fail(7)) SWIG_fail;
10423 }
10424 }
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10428
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 {
10433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10434 }
10435 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10436 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10437 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10438 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10439 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10440 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10441 return resultobj;
10442 fail:
10443 return NULL;
10444 }
10445
10446
10447 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10448 PyObject *resultobj;
10449 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10450 unsigned long arg2 ;
10451 unsigned long result;
10452 PyObject * obj0 = 0 ;
10453 PyObject * obj1 = 0 ;
10454 char *kwnames[] = {
10455 (char *) "self",(char *) "key", NULL
10456 };
10457
10458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10460 if (SWIG_arg_fail(1)) SWIG_fail;
10461 {
10462 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10463 if (SWIG_arg_fail(2)) SWIG_fail;
10464 }
10465 {
10466 PyThreadState* __tstate = wxPyBeginAllowThreads();
10467 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10468
10469 wxPyEndAllowThreads(__tstate);
10470 if (PyErr_Occurred()) SWIG_fail;
10471 }
10472 {
10473 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10474 }
10475 return resultobj;
10476 fail:
10477 return NULL;
10478 }
10479
10480
10481 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10482 PyObject *resultobj;
10483 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10484 byte arg2 ;
10485 byte arg3 ;
10486 byte arg4 ;
10487 unsigned long result;
10488 PyObject * obj0 = 0 ;
10489 PyObject * obj1 = 0 ;
10490 PyObject * obj2 = 0 ;
10491 PyObject * obj3 = 0 ;
10492 char *kwnames[] = {
10493 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10494 };
10495
10496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10498 if (SWIG_arg_fail(1)) SWIG_fail;
10499 {
10500 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10501 if (SWIG_arg_fail(2)) SWIG_fail;
10502 }
10503 {
10504 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10505 if (SWIG_arg_fail(3)) SWIG_fail;
10506 }
10507 {
10508 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10509 if (SWIG_arg_fail(4)) SWIG_fail;
10510 }
10511 {
10512 PyThreadState* __tstate = wxPyBeginAllowThreads();
10513 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10514
10515 wxPyEndAllowThreads(__tstate);
10516 if (PyErr_Occurred()) SWIG_fail;
10517 }
10518 {
10519 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10520 }
10521 return resultobj;
10522 fail:
10523 return NULL;
10524 }
10525
10526
10527 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10528 PyObject *resultobj;
10529 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10530 wxColour *arg2 = 0 ;
10531 unsigned long result;
10532 wxColour temp2 ;
10533 PyObject * obj0 = 0 ;
10534 PyObject * obj1 = 0 ;
10535 char *kwnames[] = {
10536 (char *) "self",(char *) "colour", NULL
10537 };
10538
10539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10541 if (SWIG_arg_fail(1)) SWIG_fail;
10542 {
10543 arg2 = &temp2;
10544 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10545 }
10546 {
10547 PyThreadState* __tstate = wxPyBeginAllowThreads();
10548 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10549
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 {
10554 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10555 }
10556 return resultobj;
10557 fail:
10558 return NULL;
10559 }
10560
10561
10562 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10563 PyObject *obj;
10564 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10565 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10566 Py_INCREF(obj);
10567 return Py_BuildValue((char *)"");
10568 }
10569 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10570 PyObject *resultobj;
10571 byte arg1 = (byte) 0 ;
10572 byte arg2 = (byte) 0 ;
10573 byte arg3 = (byte) 0 ;
10574 wxImage_RGBValue *result;
10575 PyObject * obj0 = 0 ;
10576 PyObject * obj1 = 0 ;
10577 PyObject * obj2 = 0 ;
10578 char *kwnames[] = {
10579 (char *) "r",(char *) "g",(char *) "b", NULL
10580 };
10581
10582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10583 if (obj0) {
10584 {
10585 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10586 if (SWIG_arg_fail(1)) SWIG_fail;
10587 }
10588 }
10589 if (obj1) {
10590 {
10591 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10592 if (SWIG_arg_fail(2)) SWIG_fail;
10593 }
10594 }
10595 if (obj2) {
10596 {
10597 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10598 if (SWIG_arg_fail(3)) SWIG_fail;
10599 }
10600 }
10601 {
10602 PyThreadState* __tstate = wxPyBeginAllowThreads();
10603 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10604
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10609 return resultobj;
10610 fail:
10611 return NULL;
10612 }
10613
10614
10615 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10616 PyObject *resultobj;
10617 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10618 byte arg2 ;
10619 PyObject * obj0 = 0 ;
10620 PyObject * obj1 = 0 ;
10621 char *kwnames[] = {
10622 (char *) "self",(char *) "red", NULL
10623 };
10624
10625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10627 if (SWIG_arg_fail(1)) SWIG_fail;
10628 {
10629 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10630 if (SWIG_arg_fail(2)) SWIG_fail;
10631 }
10632 if (arg1) (arg1)->red = arg2;
10633
10634 Py_INCREF(Py_None); resultobj = Py_None;
10635 return resultobj;
10636 fail:
10637 return NULL;
10638 }
10639
10640
10641 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10642 PyObject *resultobj;
10643 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10644 byte result;
10645 PyObject * obj0 = 0 ;
10646 char *kwnames[] = {
10647 (char *) "self", NULL
10648 };
10649
10650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10652 if (SWIG_arg_fail(1)) SWIG_fail;
10653 result = (byte) ((arg1)->red);
10654
10655 {
10656 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10657 }
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10665 PyObject *resultobj;
10666 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10667 byte arg2 ;
10668 PyObject * obj0 = 0 ;
10669 PyObject * obj1 = 0 ;
10670 char *kwnames[] = {
10671 (char *) "self",(char *) "green", NULL
10672 };
10673
10674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10676 if (SWIG_arg_fail(1)) SWIG_fail;
10677 {
10678 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10679 if (SWIG_arg_fail(2)) SWIG_fail;
10680 }
10681 if (arg1) (arg1)->green = arg2;
10682
10683 Py_INCREF(Py_None); resultobj = Py_None;
10684 return resultobj;
10685 fail:
10686 return NULL;
10687 }
10688
10689
10690 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj;
10692 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10693 byte result;
10694 PyObject * obj0 = 0 ;
10695 char *kwnames[] = {
10696 (char *) "self", NULL
10697 };
10698
10699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10701 if (SWIG_arg_fail(1)) SWIG_fail;
10702 result = (byte) ((arg1)->green);
10703
10704 {
10705 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10706 }
10707 return resultobj;
10708 fail:
10709 return NULL;
10710 }
10711
10712
10713 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10714 PyObject *resultobj;
10715 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10716 byte arg2 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 char *kwnames[] = {
10720 (char *) "self",(char *) "blue", NULL
10721 };
10722
10723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10725 if (SWIG_arg_fail(1)) SWIG_fail;
10726 {
10727 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10728 if (SWIG_arg_fail(2)) SWIG_fail;
10729 }
10730 if (arg1) (arg1)->blue = arg2;
10731
10732 Py_INCREF(Py_None); resultobj = Py_None;
10733 return resultobj;
10734 fail:
10735 return NULL;
10736 }
10737
10738
10739 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10740 PyObject *resultobj;
10741 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10742 byte result;
10743 PyObject * obj0 = 0 ;
10744 char *kwnames[] = {
10745 (char *) "self", NULL
10746 };
10747
10748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10750 if (SWIG_arg_fail(1)) SWIG_fail;
10751 result = (byte) ((arg1)->blue);
10752
10753 {
10754 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10755 }
10756 return resultobj;
10757 fail:
10758 return NULL;
10759 }
10760
10761
10762 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10763 PyObject *obj;
10764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10765 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10766 Py_INCREF(obj);
10767 return Py_BuildValue((char *)"");
10768 }
10769 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10770 PyObject *resultobj;
10771 double arg1 = (double) 0.0 ;
10772 double arg2 = (double) 0.0 ;
10773 double arg3 = (double) 0.0 ;
10774 wxImage_HSVValue *result;
10775 PyObject * obj0 = 0 ;
10776 PyObject * obj1 = 0 ;
10777 PyObject * obj2 = 0 ;
10778 char *kwnames[] = {
10779 (char *) "h",(char *) "s",(char *) "v", NULL
10780 };
10781
10782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10783 if (obj0) {
10784 {
10785 arg1 = (double)(SWIG_As_double(obj0));
10786 if (SWIG_arg_fail(1)) SWIG_fail;
10787 }
10788 }
10789 if (obj1) {
10790 {
10791 arg2 = (double)(SWIG_As_double(obj1));
10792 if (SWIG_arg_fail(2)) SWIG_fail;
10793 }
10794 }
10795 if (obj2) {
10796 {
10797 arg3 = (double)(SWIG_As_double(obj2));
10798 if (SWIG_arg_fail(3)) SWIG_fail;
10799 }
10800 }
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10804
10805 wxPyEndAllowThreads(__tstate);
10806 if (PyErr_Occurred()) SWIG_fail;
10807 }
10808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10809 return resultobj;
10810 fail:
10811 return NULL;
10812 }
10813
10814
10815 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10816 PyObject *resultobj;
10817 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10818 double arg2 ;
10819 PyObject * obj0 = 0 ;
10820 PyObject * obj1 = 0 ;
10821 char *kwnames[] = {
10822 (char *) "self",(char *) "hue", NULL
10823 };
10824
10825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10827 if (SWIG_arg_fail(1)) SWIG_fail;
10828 {
10829 arg2 = (double)(SWIG_As_double(obj1));
10830 if (SWIG_arg_fail(2)) SWIG_fail;
10831 }
10832 if (arg1) (arg1)->hue = arg2;
10833
10834 Py_INCREF(Py_None); resultobj = Py_None;
10835 return resultobj;
10836 fail:
10837 return NULL;
10838 }
10839
10840
10841 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10842 PyObject *resultobj;
10843 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10844 double result;
10845 PyObject * obj0 = 0 ;
10846 char *kwnames[] = {
10847 (char *) "self", NULL
10848 };
10849
10850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10852 if (SWIG_arg_fail(1)) SWIG_fail;
10853 result = (double) ((arg1)->hue);
10854
10855 {
10856 resultobj = SWIG_From_double((double)(result));
10857 }
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj;
10866 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10867 double arg2 ;
10868 PyObject * obj0 = 0 ;
10869 PyObject * obj1 = 0 ;
10870 char *kwnames[] = {
10871 (char *) "self",(char *) "saturation", NULL
10872 };
10873
10874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10876 if (SWIG_arg_fail(1)) SWIG_fail;
10877 {
10878 arg2 = (double)(SWIG_As_double(obj1));
10879 if (SWIG_arg_fail(2)) SWIG_fail;
10880 }
10881 if (arg1) (arg1)->saturation = arg2;
10882
10883 Py_INCREF(Py_None); resultobj = Py_None;
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj;
10892 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10893 double result;
10894 PyObject * obj0 = 0 ;
10895 char *kwnames[] = {
10896 (char *) "self", NULL
10897 };
10898
10899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
10900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10901 if (SWIG_arg_fail(1)) SWIG_fail;
10902 result = (double) ((arg1)->saturation);
10903
10904 {
10905 resultobj = SWIG_From_double((double)(result));
10906 }
10907 return resultobj;
10908 fail:
10909 return NULL;
10910 }
10911
10912
10913 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
10914 PyObject *resultobj;
10915 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10916 double arg2 ;
10917 PyObject * obj0 = 0 ;
10918 PyObject * obj1 = 0 ;
10919 char *kwnames[] = {
10920 (char *) "self",(char *) "value", NULL
10921 };
10922
10923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
10924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10925 if (SWIG_arg_fail(1)) SWIG_fail;
10926 {
10927 arg2 = (double)(SWIG_As_double(obj1));
10928 if (SWIG_arg_fail(2)) SWIG_fail;
10929 }
10930 if (arg1) (arg1)->value = arg2;
10931
10932 Py_INCREF(Py_None); resultobj = Py_None;
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
10940 PyObject *resultobj;
10941 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10942 double result;
10943 PyObject * obj0 = 0 ;
10944 char *kwnames[] = {
10945 (char *) "self", NULL
10946 };
10947
10948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
10949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10950 if (SWIG_arg_fail(1)) SWIG_fail;
10951 result = (double) ((arg1)->value);
10952
10953 {
10954 resultobj = SWIG_From_double((double)(result));
10955 }
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
10963 PyObject *obj;
10964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10965 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
10966 Py_INCREF(obj);
10967 return Py_BuildValue((char *)"");
10968 }
10969 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj;
10971 wxString *arg1 = 0 ;
10972 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10973 int arg3 = (int) -1 ;
10974 wxImage *result;
10975 bool temp1 = false ;
10976 PyObject * obj0 = 0 ;
10977 PyObject * obj1 = 0 ;
10978 PyObject * obj2 = 0 ;
10979 char *kwnames[] = {
10980 (char *) "name",(char *) "type",(char *) "index", NULL
10981 };
10982
10983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10984 {
10985 arg1 = wxString_in_helper(obj0);
10986 if (arg1 == NULL) SWIG_fail;
10987 temp1 = true;
10988 }
10989 if (obj1) {
10990 {
10991 arg2 = (long)(SWIG_As_long(obj1));
10992 if (SWIG_arg_fail(2)) SWIG_fail;
10993 }
10994 }
10995 if (obj2) {
10996 {
10997 arg3 = (int)(SWIG_As_int(obj2));
10998 if (SWIG_arg_fail(3)) SWIG_fail;
10999 }
11000 }
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11004
11005 wxPyEndAllowThreads(__tstate);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11009 {
11010 if (temp1)
11011 delete arg1;
11012 }
11013 return resultobj;
11014 fail:
11015 {
11016 if (temp1)
11017 delete arg1;
11018 }
11019 return NULL;
11020 }
11021
11022
11023 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11024 PyObject *resultobj;
11025 wxImage *arg1 = (wxImage *) 0 ;
11026 PyObject * obj0 = 0 ;
11027 char *kwnames[] = {
11028 (char *) "self", NULL
11029 };
11030
11031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11033 if (SWIG_arg_fail(1)) SWIG_fail;
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 delete arg1;
11037
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 Py_INCREF(Py_None); resultobj = Py_None;
11042 return resultobj;
11043 fail:
11044 return NULL;
11045 }
11046
11047
11048 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11049 PyObject *resultobj;
11050 wxString *arg1 = 0 ;
11051 wxString *arg2 = 0 ;
11052 int arg3 = (int) -1 ;
11053 wxImage *result;
11054 bool temp1 = false ;
11055 bool temp2 = false ;
11056 PyObject * obj0 = 0 ;
11057 PyObject * obj1 = 0 ;
11058 PyObject * obj2 = 0 ;
11059 char *kwnames[] = {
11060 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11061 };
11062
11063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11064 {
11065 arg1 = wxString_in_helper(obj0);
11066 if (arg1 == NULL) SWIG_fail;
11067 temp1 = true;
11068 }
11069 {
11070 arg2 = wxString_in_helper(obj1);
11071 if (arg2 == NULL) SWIG_fail;
11072 temp2 = true;
11073 }
11074 if (obj2) {
11075 {
11076 arg3 = (int)(SWIG_As_int(obj2));
11077 if (SWIG_arg_fail(3)) SWIG_fail;
11078 }
11079 }
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11083
11084 wxPyEndAllowThreads(__tstate);
11085 if (PyErr_Occurred()) SWIG_fail;
11086 }
11087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11088 {
11089 if (temp1)
11090 delete arg1;
11091 }
11092 {
11093 if (temp2)
11094 delete arg2;
11095 }
11096 return resultobj;
11097 fail:
11098 {
11099 if (temp1)
11100 delete arg1;
11101 }
11102 {
11103 if (temp2)
11104 delete arg2;
11105 }
11106 return NULL;
11107 }
11108
11109
11110 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11111 PyObject *resultobj;
11112 wxInputStream *arg1 = 0 ;
11113 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11114 int arg3 = (int) -1 ;
11115 wxImage *result;
11116 wxPyInputStream *temp1 ;
11117 bool created1 ;
11118 PyObject * obj0 = 0 ;
11119 PyObject * obj1 = 0 ;
11120 PyObject * obj2 = 0 ;
11121 char *kwnames[] = {
11122 (char *) "stream",(char *) "type",(char *) "index", NULL
11123 };
11124
11125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11126 {
11127 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11128 arg1 = temp1->m_wxis;
11129 created1 = false;
11130 } else {
11131 PyErr_Clear(); // clear the failure of the wxPyConvert above
11132 arg1 = wxPyCBInputStream_create(obj0, false);
11133 if (arg1 == NULL) {
11134 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11135 SWIG_fail;
11136 }
11137 created1 = true;
11138 }
11139 }
11140 if (obj1) {
11141 {
11142 arg2 = (long)(SWIG_As_long(obj1));
11143 if (SWIG_arg_fail(2)) SWIG_fail;
11144 }
11145 }
11146 if (obj2) {
11147 {
11148 arg3 = (int)(SWIG_As_int(obj2));
11149 if (SWIG_arg_fail(3)) SWIG_fail;
11150 }
11151 }
11152 {
11153 PyThreadState* __tstate = wxPyBeginAllowThreads();
11154 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11155
11156 wxPyEndAllowThreads(__tstate);
11157 if (PyErr_Occurred()) SWIG_fail;
11158 }
11159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11160 {
11161 if (created1) delete arg1;
11162 }
11163 return resultobj;
11164 fail:
11165 {
11166 if (created1) delete arg1;
11167 }
11168 return NULL;
11169 }
11170
11171
11172 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11173 PyObject *resultobj;
11174 wxInputStream *arg1 = 0 ;
11175 wxString *arg2 = 0 ;
11176 int arg3 = (int) -1 ;
11177 wxImage *result;
11178 wxPyInputStream *temp1 ;
11179 bool created1 ;
11180 bool temp2 = false ;
11181 PyObject * obj0 = 0 ;
11182 PyObject * obj1 = 0 ;
11183 PyObject * obj2 = 0 ;
11184 char *kwnames[] = {
11185 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11186 };
11187
11188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11189 {
11190 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11191 arg1 = temp1->m_wxis;
11192 created1 = false;
11193 } else {
11194 PyErr_Clear(); // clear the failure of the wxPyConvert above
11195 arg1 = wxPyCBInputStream_create(obj0, false);
11196 if (arg1 == NULL) {
11197 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11198 SWIG_fail;
11199 }
11200 created1 = true;
11201 }
11202 }
11203 {
11204 arg2 = wxString_in_helper(obj1);
11205 if (arg2 == NULL) SWIG_fail;
11206 temp2 = true;
11207 }
11208 if (obj2) {
11209 {
11210 arg3 = (int)(SWIG_As_int(obj2));
11211 if (SWIG_arg_fail(3)) SWIG_fail;
11212 }
11213 }
11214 {
11215 PyThreadState* __tstate = wxPyBeginAllowThreads();
11216 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11217
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11222 {
11223 if (created1) delete arg1;
11224 }
11225 {
11226 if (temp2)
11227 delete arg2;
11228 }
11229 return resultobj;
11230 fail:
11231 {
11232 if (created1) delete arg1;
11233 }
11234 {
11235 if (temp2)
11236 delete arg2;
11237 }
11238 return NULL;
11239 }
11240
11241
11242 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11243 PyObject *resultobj;
11244 int arg1 = (int) 0 ;
11245 int arg2 = (int) 0 ;
11246 bool arg3 = (bool) true ;
11247 wxImage *result;
11248 PyObject * obj0 = 0 ;
11249 PyObject * obj1 = 0 ;
11250 PyObject * obj2 = 0 ;
11251 char *kwnames[] = {
11252 (char *) "width",(char *) "height",(char *) "clear", NULL
11253 };
11254
11255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11256 if (obj0) {
11257 {
11258 arg1 = (int)(SWIG_As_int(obj0));
11259 if (SWIG_arg_fail(1)) SWIG_fail;
11260 }
11261 }
11262 if (obj1) {
11263 {
11264 arg2 = (int)(SWIG_As_int(obj1));
11265 if (SWIG_arg_fail(2)) SWIG_fail;
11266 }
11267 }
11268 if (obj2) {
11269 {
11270 arg3 = (bool)(SWIG_As_bool(obj2));
11271 if (SWIG_arg_fail(3)) SWIG_fail;
11272 }
11273 }
11274 {
11275 PyThreadState* __tstate = wxPyBeginAllowThreads();
11276 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11277
11278 wxPyEndAllowThreads(__tstate);
11279 if (PyErr_Occurred()) SWIG_fail;
11280 }
11281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11282 return resultobj;
11283 fail:
11284 return NULL;
11285 }
11286
11287
11288 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11289 PyObject *resultobj;
11290 wxBitmap *arg1 = 0 ;
11291 wxImage *result;
11292 PyObject * obj0 = 0 ;
11293 char *kwnames[] = {
11294 (char *) "bitmap", NULL
11295 };
11296
11297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11298 {
11299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11300 if (SWIG_arg_fail(1)) SWIG_fail;
11301 if (arg1 == NULL) {
11302 SWIG_null_ref("wxBitmap");
11303 }
11304 if (SWIG_arg_fail(1)) SWIG_fail;
11305 }
11306 {
11307 if (!wxPyCheckForApp()) SWIG_fail;
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11310
11311 wxPyEndAllowThreads(__tstate);
11312 if (PyErr_Occurred()) SWIG_fail;
11313 }
11314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11315 return resultobj;
11316 fail:
11317 return NULL;
11318 }
11319
11320
11321 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj;
11323 int arg1 ;
11324 int arg2 ;
11325 buffer arg3 ;
11326 int arg4 ;
11327 wxImage *result;
11328 PyObject * obj0 = 0 ;
11329 PyObject * obj1 = 0 ;
11330 PyObject * obj2 = 0 ;
11331 char *kwnames[] = {
11332 (char *) "width",(char *) "height",(char *) "data", NULL
11333 };
11334
11335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11336 {
11337 arg1 = (int)(SWIG_As_int(obj0));
11338 if (SWIG_arg_fail(1)) SWIG_fail;
11339 }
11340 {
11341 arg2 = (int)(SWIG_As_int(obj1));
11342 if (SWIG_arg_fail(2)) SWIG_fail;
11343 }
11344 {
11345 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11346 }
11347 {
11348 PyThreadState* __tstate = wxPyBeginAllowThreads();
11349 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11350
11351 wxPyEndAllowThreads(__tstate);
11352 if (PyErr_Occurred()) SWIG_fail;
11353 }
11354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11355 return resultobj;
11356 fail:
11357 return NULL;
11358 }
11359
11360
11361 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11362 PyObject *resultobj;
11363 int arg1 ;
11364 int arg2 ;
11365 buffer arg3 ;
11366 int arg4 ;
11367 buffer arg5 ;
11368 int arg6 ;
11369 wxImage *result;
11370 PyObject * obj0 = 0 ;
11371 PyObject * obj1 = 0 ;
11372 PyObject * obj2 = 0 ;
11373 PyObject * obj3 = 0 ;
11374 char *kwnames[] = {
11375 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11376 };
11377
11378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11379 {
11380 arg1 = (int)(SWIG_As_int(obj0));
11381 if (SWIG_arg_fail(1)) SWIG_fail;
11382 }
11383 {
11384 arg2 = (int)(SWIG_As_int(obj1));
11385 if (SWIG_arg_fail(2)) SWIG_fail;
11386 }
11387 {
11388 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11389 }
11390 {
11391 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11392 }
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11396
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11401 return resultobj;
11402 fail:
11403 return NULL;
11404 }
11405
11406
11407 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj;
11409 wxImage *arg1 = (wxImage *) 0 ;
11410 int arg2 ;
11411 int arg3 ;
11412 bool arg4 = (bool) true ;
11413 PyObject * obj0 = 0 ;
11414 PyObject * obj1 = 0 ;
11415 PyObject * obj2 = 0 ;
11416 PyObject * obj3 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",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 if (obj3) {
11433 {
11434 arg4 = (bool)(SWIG_As_bool(obj3));
11435 if (SWIG_arg_fail(4)) SWIG_fail;
11436 }
11437 }
11438 {
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 (arg1)->Create(arg2,arg3,arg4);
11441
11442 wxPyEndAllowThreads(__tstate);
11443 if (PyErr_Occurred()) SWIG_fail;
11444 }
11445 Py_INCREF(Py_None); resultobj = Py_None;
11446 return resultobj;
11447 fail:
11448 return NULL;
11449 }
11450
11451
11452 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11453 PyObject *resultobj;
11454 wxImage *arg1 = (wxImage *) 0 ;
11455 PyObject * obj0 = 0 ;
11456 char *kwnames[] = {
11457 (char *) "self", NULL
11458 };
11459
11460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11462 if (SWIG_arg_fail(1)) SWIG_fail;
11463 {
11464 PyThreadState* __tstate = wxPyBeginAllowThreads();
11465 (arg1)->Destroy();
11466
11467 wxPyEndAllowThreads(__tstate);
11468 if (PyErr_Occurred()) SWIG_fail;
11469 }
11470 Py_INCREF(Py_None); resultobj = Py_None;
11471 return resultobj;
11472 fail:
11473 return NULL;
11474 }
11475
11476
11477 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11478 PyObject *resultobj;
11479 wxImage *arg1 = (wxImage *) 0 ;
11480 int arg2 ;
11481 int arg3 ;
11482 SwigValueWrapper<wxImage > result;
11483 PyObject * obj0 = 0 ;
11484 PyObject * obj1 = 0 ;
11485 PyObject * obj2 = 0 ;
11486 char *kwnames[] = {
11487 (char *) "self",(char *) "width",(char *) "height", NULL
11488 };
11489
11490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11492 if (SWIG_arg_fail(1)) SWIG_fail;
11493 {
11494 arg2 = (int)(SWIG_As_int(obj1));
11495 if (SWIG_arg_fail(2)) SWIG_fail;
11496 }
11497 {
11498 arg3 = (int)(SWIG_As_int(obj2));
11499 if (SWIG_arg_fail(3)) SWIG_fail;
11500 }
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 result = (arg1)->Scale(arg2,arg3);
11504
11505 wxPyEndAllowThreads(__tstate);
11506 if (PyErr_Occurred()) SWIG_fail;
11507 }
11508 {
11509 wxImage * resultptr;
11510 resultptr = new wxImage((wxImage &)(result));
11511 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11512 }
11513 return resultobj;
11514 fail:
11515 return NULL;
11516 }
11517
11518
11519 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11520 PyObject *resultobj;
11521 wxImage *arg1 = (wxImage *) 0 ;
11522 int arg2 ;
11523 int arg3 ;
11524 SwigValueWrapper<wxImage > result;
11525 PyObject * obj0 = 0 ;
11526 PyObject * obj1 = 0 ;
11527 PyObject * obj2 = 0 ;
11528 char *kwnames[] = {
11529 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11530 };
11531
11532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11534 if (SWIG_arg_fail(1)) SWIG_fail;
11535 {
11536 arg2 = (int)(SWIG_As_int(obj1));
11537 if (SWIG_arg_fail(2)) SWIG_fail;
11538 }
11539 {
11540 arg3 = (int)(SWIG_As_int(obj2));
11541 if (SWIG_arg_fail(3)) SWIG_fail;
11542 }
11543 {
11544 PyThreadState* __tstate = wxPyBeginAllowThreads();
11545 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11546
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 {
11551 wxImage * resultptr;
11552 resultptr = new wxImage((wxImage &)(result));
11553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11554 }
11555 return resultobj;
11556 fail:
11557 return NULL;
11558 }
11559
11560
11561 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11562 PyObject *resultobj;
11563 wxImage *arg1 = (wxImage *) 0 ;
11564 int arg2 ;
11565 int arg3 ;
11566 wxImage *result;
11567 PyObject * obj0 = 0 ;
11568 PyObject * obj1 = 0 ;
11569 PyObject * obj2 = 0 ;
11570 char *kwnames[] = {
11571 (char *) "self",(char *) "width",(char *) "height", NULL
11572 };
11573
11574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11576 if (SWIG_arg_fail(1)) SWIG_fail;
11577 {
11578 arg2 = (int)(SWIG_As_int(obj1));
11579 if (SWIG_arg_fail(2)) SWIG_fail;
11580 }
11581 {
11582 arg3 = (int)(SWIG_As_int(obj2));
11583 if (SWIG_arg_fail(3)) SWIG_fail;
11584 }
11585 {
11586 PyThreadState* __tstate = wxPyBeginAllowThreads();
11587 {
11588 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11589 result = (wxImage *) &_result_ref;
11590 }
11591
11592 wxPyEndAllowThreads(__tstate);
11593 if (PyErr_Occurred()) SWIG_fail;
11594 }
11595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11603 PyObject *resultobj;
11604 wxImage *arg1 = (wxImage *) 0 ;
11605 wxSize *arg2 = 0 ;
11606 wxPoint *arg3 = 0 ;
11607 int arg4 = (int) -1 ;
11608 int arg5 = (int) -1 ;
11609 int arg6 = (int) -1 ;
11610 wxImage *result;
11611 wxSize temp2 ;
11612 wxPoint temp3 ;
11613 PyObject * obj0 = 0 ;
11614 PyObject * obj1 = 0 ;
11615 PyObject * obj2 = 0 ;
11616 PyObject * obj3 = 0 ;
11617 PyObject * obj4 = 0 ;
11618 PyObject * obj5 = 0 ;
11619 char *kwnames[] = {
11620 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11621 };
11622
11623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11625 if (SWIG_arg_fail(1)) SWIG_fail;
11626 {
11627 arg2 = &temp2;
11628 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11629 }
11630 {
11631 arg3 = &temp3;
11632 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11633 }
11634 if (obj3) {
11635 {
11636 arg4 = (int)(SWIG_As_int(obj3));
11637 if (SWIG_arg_fail(4)) SWIG_fail;
11638 }
11639 }
11640 if (obj4) {
11641 {
11642 arg5 = (int)(SWIG_As_int(obj4));
11643 if (SWIG_arg_fail(5)) SWIG_fail;
11644 }
11645 }
11646 if (obj5) {
11647 {
11648 arg6 = (int)(SWIG_As_int(obj5));
11649 if (SWIG_arg_fail(6)) SWIG_fail;
11650 }
11651 }
11652 {
11653 PyThreadState* __tstate = wxPyBeginAllowThreads();
11654 {
11655 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11656 result = (wxImage *) &_result_ref;
11657 }
11658
11659 wxPyEndAllowThreads(__tstate);
11660 if (PyErr_Occurred()) SWIG_fail;
11661 }
11662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11670 PyObject *resultobj;
11671 wxImage *arg1 = (wxImage *) 0 ;
11672 int arg2 ;
11673 int arg3 ;
11674 byte arg4 ;
11675 byte arg5 ;
11676 byte arg6 ;
11677 PyObject * obj0 = 0 ;
11678 PyObject * obj1 = 0 ;
11679 PyObject * obj2 = 0 ;
11680 PyObject * obj3 = 0 ;
11681 PyObject * obj4 = 0 ;
11682 PyObject * obj5 = 0 ;
11683 char *kwnames[] = {
11684 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11685 };
11686
11687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11689 if (SWIG_arg_fail(1)) SWIG_fail;
11690 {
11691 arg2 = (int)(SWIG_As_int(obj1));
11692 if (SWIG_arg_fail(2)) SWIG_fail;
11693 }
11694 {
11695 arg3 = (int)(SWIG_As_int(obj2));
11696 if (SWIG_arg_fail(3)) SWIG_fail;
11697 }
11698 {
11699 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11700 if (SWIG_arg_fail(4)) SWIG_fail;
11701 }
11702 {
11703 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11704 if (SWIG_arg_fail(5)) SWIG_fail;
11705 }
11706 {
11707 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11708 if (SWIG_arg_fail(6)) SWIG_fail;
11709 }
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11713
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 Py_INCREF(Py_None); resultobj = Py_None;
11718 return resultobj;
11719 fail:
11720 return NULL;
11721 }
11722
11723
11724 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11725 PyObject *resultobj;
11726 wxImage *arg1 = (wxImage *) 0 ;
11727 wxRect *arg2 = 0 ;
11728 byte arg3 ;
11729 byte arg4 ;
11730 byte arg5 ;
11731 wxRect temp2 ;
11732 PyObject * obj0 = 0 ;
11733 PyObject * obj1 = 0 ;
11734 PyObject * obj2 = 0 ;
11735 PyObject * obj3 = 0 ;
11736 PyObject * obj4 = 0 ;
11737 char *kwnames[] = {
11738 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11739 };
11740
11741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11743 if (SWIG_arg_fail(1)) SWIG_fail;
11744 {
11745 arg2 = &temp2;
11746 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11747 }
11748 {
11749 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11750 if (SWIG_arg_fail(3)) SWIG_fail;
11751 }
11752 {
11753 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11754 if (SWIG_arg_fail(4)) SWIG_fail;
11755 }
11756 {
11757 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11758 if (SWIG_arg_fail(5)) SWIG_fail;
11759 }
11760 {
11761 PyThreadState* __tstate = wxPyBeginAllowThreads();
11762 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11763
11764 wxPyEndAllowThreads(__tstate);
11765 if (PyErr_Occurred()) SWIG_fail;
11766 }
11767 Py_INCREF(Py_None); resultobj = Py_None;
11768 return resultobj;
11769 fail:
11770 return NULL;
11771 }
11772
11773
11774 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11775 PyObject *resultobj;
11776 wxImage *arg1 = (wxImage *) 0 ;
11777 int arg2 ;
11778 int arg3 ;
11779 byte result;
11780 PyObject * obj0 = 0 ;
11781 PyObject * obj1 = 0 ;
11782 PyObject * obj2 = 0 ;
11783 char *kwnames[] = {
11784 (char *) "self",(char *) "x",(char *) "y", NULL
11785 };
11786
11787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11789 if (SWIG_arg_fail(1)) SWIG_fail;
11790 {
11791 arg2 = (int)(SWIG_As_int(obj1));
11792 if (SWIG_arg_fail(2)) SWIG_fail;
11793 }
11794 {
11795 arg3 = (int)(SWIG_As_int(obj2));
11796 if (SWIG_arg_fail(3)) SWIG_fail;
11797 }
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 result = (byte)(arg1)->GetRed(arg2,arg3);
11801
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 {
11806 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11807 }
11808 return resultobj;
11809 fail:
11810 return NULL;
11811 }
11812
11813
11814 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11815 PyObject *resultobj;
11816 wxImage *arg1 = (wxImage *) 0 ;
11817 int arg2 ;
11818 int arg3 ;
11819 byte result;
11820 PyObject * obj0 = 0 ;
11821 PyObject * obj1 = 0 ;
11822 PyObject * obj2 = 0 ;
11823 char *kwnames[] = {
11824 (char *) "self",(char *) "x",(char *) "y", NULL
11825 };
11826
11827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11829 if (SWIG_arg_fail(1)) SWIG_fail;
11830 {
11831 arg2 = (int)(SWIG_As_int(obj1));
11832 if (SWIG_arg_fail(2)) SWIG_fail;
11833 }
11834 {
11835 arg3 = (int)(SWIG_As_int(obj2));
11836 if (SWIG_arg_fail(3)) SWIG_fail;
11837 }
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 result = (byte)(arg1)->GetGreen(arg2,arg3);
11841
11842 wxPyEndAllowThreads(__tstate);
11843 if (PyErr_Occurred()) SWIG_fail;
11844 }
11845 {
11846 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11847 }
11848 return resultobj;
11849 fail:
11850 return NULL;
11851 }
11852
11853
11854 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11855 PyObject *resultobj;
11856 wxImage *arg1 = (wxImage *) 0 ;
11857 int arg2 ;
11858 int arg3 ;
11859 byte result;
11860 PyObject * obj0 = 0 ;
11861 PyObject * obj1 = 0 ;
11862 PyObject * obj2 = 0 ;
11863 char *kwnames[] = {
11864 (char *) "self",(char *) "x",(char *) "y", NULL
11865 };
11866
11867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11869 if (SWIG_arg_fail(1)) SWIG_fail;
11870 {
11871 arg2 = (int)(SWIG_As_int(obj1));
11872 if (SWIG_arg_fail(2)) SWIG_fail;
11873 }
11874 {
11875 arg3 = (int)(SWIG_As_int(obj2));
11876 if (SWIG_arg_fail(3)) SWIG_fail;
11877 }
11878 {
11879 PyThreadState* __tstate = wxPyBeginAllowThreads();
11880 result = (byte)(arg1)->GetBlue(arg2,arg3);
11881
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 {
11886 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11887 }
11888 return resultobj;
11889 fail:
11890 return NULL;
11891 }
11892
11893
11894 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11895 PyObject *resultobj;
11896 wxImage *arg1 = (wxImage *) 0 ;
11897 int arg2 ;
11898 int arg3 ;
11899 byte arg4 ;
11900 PyObject * obj0 = 0 ;
11901 PyObject * obj1 = 0 ;
11902 PyObject * obj2 = 0 ;
11903 PyObject * obj3 = 0 ;
11904 char *kwnames[] = {
11905 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11906 };
11907
11908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11910 if (SWIG_arg_fail(1)) SWIG_fail;
11911 {
11912 arg2 = (int)(SWIG_As_int(obj1));
11913 if (SWIG_arg_fail(2)) SWIG_fail;
11914 }
11915 {
11916 arg3 = (int)(SWIG_As_int(obj2));
11917 if (SWIG_arg_fail(3)) SWIG_fail;
11918 }
11919 {
11920 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11921 if (SWIG_arg_fail(4)) SWIG_fail;
11922 }
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 (arg1)->SetAlpha(arg2,arg3,arg4);
11926
11927 wxPyEndAllowThreads(__tstate);
11928 if (PyErr_Occurred()) SWIG_fail;
11929 }
11930 Py_INCREF(Py_None); resultobj = Py_None;
11931 return resultobj;
11932 fail:
11933 return NULL;
11934 }
11935
11936
11937 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj;
11939 wxImage *arg1 = (wxImage *) 0 ;
11940 int arg2 ;
11941 int arg3 ;
11942 byte result;
11943 PyObject * obj0 = 0 ;
11944 PyObject * obj1 = 0 ;
11945 PyObject * obj2 = 0 ;
11946 char *kwnames[] = {
11947 (char *) "self",(char *) "x",(char *) "y", NULL
11948 };
11949
11950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11952 if (SWIG_arg_fail(1)) SWIG_fail;
11953 {
11954 arg2 = (int)(SWIG_As_int(obj1));
11955 if (SWIG_arg_fail(2)) SWIG_fail;
11956 }
11957 {
11958 arg3 = (int)(SWIG_As_int(obj2));
11959 if (SWIG_arg_fail(3)) SWIG_fail;
11960 }
11961 {
11962 PyThreadState* __tstate = wxPyBeginAllowThreads();
11963 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11964
11965 wxPyEndAllowThreads(__tstate);
11966 if (PyErr_Occurred()) SWIG_fail;
11967 }
11968 {
11969 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11970 }
11971 return resultobj;
11972 fail:
11973 return NULL;
11974 }
11975
11976
11977 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11978 PyObject *resultobj;
11979 wxImage *arg1 = (wxImage *) 0 ;
11980 bool result;
11981 PyObject * obj0 = 0 ;
11982 char *kwnames[] = {
11983 (char *) "self", NULL
11984 };
11985
11986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11988 if (SWIG_arg_fail(1)) SWIG_fail;
11989 {
11990 PyThreadState* __tstate = wxPyBeginAllowThreads();
11991 result = (bool)(arg1)->HasAlpha();
11992
11993 wxPyEndAllowThreads(__tstate);
11994 if (PyErr_Occurred()) SWIG_fail;
11995 }
11996 {
11997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11998 }
11999 return resultobj;
12000 fail:
12001 return NULL;
12002 }
12003
12004
12005 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12006 PyObject *resultobj;
12007 wxImage *arg1 = (wxImage *) 0 ;
12008 PyObject * obj0 = 0 ;
12009 char *kwnames[] = {
12010 (char *) "self", NULL
12011 };
12012
12013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12015 if (SWIG_arg_fail(1)) SWIG_fail;
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 (arg1)->InitAlpha();
12019
12020 wxPyEndAllowThreads(__tstate);
12021 if (PyErr_Occurred()) SWIG_fail;
12022 }
12023 Py_INCREF(Py_None); resultobj = Py_None;
12024 return resultobj;
12025 fail:
12026 return NULL;
12027 }
12028
12029
12030 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12031 PyObject *resultobj;
12032 wxImage *arg1 = (wxImage *) 0 ;
12033 int arg2 ;
12034 int arg3 ;
12035 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12036 bool result;
12037 PyObject * obj0 = 0 ;
12038 PyObject * obj1 = 0 ;
12039 PyObject * obj2 = 0 ;
12040 PyObject * obj3 = 0 ;
12041 char *kwnames[] = {
12042 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12043 };
12044
12045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12047 if (SWIG_arg_fail(1)) SWIG_fail;
12048 {
12049 arg2 = (int)(SWIG_As_int(obj1));
12050 if (SWIG_arg_fail(2)) SWIG_fail;
12051 }
12052 {
12053 arg3 = (int)(SWIG_As_int(obj2));
12054 if (SWIG_arg_fail(3)) SWIG_fail;
12055 }
12056 if (obj3) {
12057 {
12058 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12059 if (SWIG_arg_fail(4)) SWIG_fail;
12060 }
12061 }
12062 {
12063 PyThreadState* __tstate = wxPyBeginAllowThreads();
12064 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12065
12066 wxPyEndAllowThreads(__tstate);
12067 if (PyErr_Occurred()) SWIG_fail;
12068 }
12069 {
12070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12071 }
12072 return resultobj;
12073 fail:
12074 return NULL;
12075 }
12076
12077
12078 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12079 PyObject *resultobj;
12080 wxImage *arg1 = (wxImage *) 0 ;
12081 byte *arg2 = (byte *) 0 ;
12082 byte *arg3 = (byte *) 0 ;
12083 byte *arg4 = (byte *) 0 ;
12084 byte arg5 = (byte) 0 ;
12085 byte arg6 = (byte) 0 ;
12086 byte arg7 = (byte) 0 ;
12087 bool result;
12088 byte temp2 ;
12089 int res2 = 0 ;
12090 byte temp3 ;
12091 int res3 = 0 ;
12092 byte temp4 ;
12093 int res4 = 0 ;
12094 PyObject * obj0 = 0 ;
12095 PyObject * obj1 = 0 ;
12096 PyObject * obj2 = 0 ;
12097 PyObject * obj3 = 0 ;
12098 char *kwnames[] = {
12099 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12100 };
12101
12102 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12103 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12104 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12107 if (SWIG_arg_fail(1)) SWIG_fail;
12108 if (obj1) {
12109 {
12110 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12111 if (SWIG_arg_fail(5)) SWIG_fail;
12112 }
12113 }
12114 if (obj2) {
12115 {
12116 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12117 if (SWIG_arg_fail(6)) SWIG_fail;
12118 }
12119 }
12120 if (obj3) {
12121 {
12122 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12123 if (SWIG_arg_fail(7)) SWIG_fail;
12124 }
12125 }
12126 {
12127 PyThreadState* __tstate = wxPyBeginAllowThreads();
12128 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12129
12130 wxPyEndAllowThreads(__tstate);
12131 if (PyErr_Occurred()) SWIG_fail;
12132 }
12133 {
12134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12135 }
12136 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12137 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12138 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12139 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12140 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12141 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12142 return resultobj;
12143 fail:
12144 return NULL;
12145 }
12146
12147
12148 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12149 PyObject *resultobj;
12150 wxImage *arg1 = (wxImage *) 0 ;
12151 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12152 bool result;
12153 PyObject * obj0 = 0 ;
12154 PyObject * obj1 = 0 ;
12155 char *kwnames[] = {
12156 (char *) "self",(char *) "threshold", NULL
12157 };
12158
12159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12161 if (SWIG_arg_fail(1)) SWIG_fail;
12162 if (obj1) {
12163 {
12164 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12165 if (SWIG_arg_fail(2)) SWIG_fail;
12166 }
12167 }
12168 {
12169 PyThreadState* __tstate = wxPyBeginAllowThreads();
12170 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12171
12172 wxPyEndAllowThreads(__tstate);
12173 if (PyErr_Occurred()) SWIG_fail;
12174 }
12175 {
12176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12177 }
12178 return resultobj;
12179 fail:
12180 return NULL;
12181 }
12182
12183
12184 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12185 PyObject *resultobj;
12186 wxImage *arg1 = (wxImage *) 0 ;
12187 byte arg2 ;
12188 byte arg3 ;
12189 byte arg4 ;
12190 bool result;
12191 PyObject * obj0 = 0 ;
12192 PyObject * obj1 = 0 ;
12193 PyObject * obj2 = 0 ;
12194 PyObject * obj3 = 0 ;
12195 char *kwnames[] = {
12196 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12197 };
12198
12199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12201 if (SWIG_arg_fail(1)) SWIG_fail;
12202 {
12203 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12204 if (SWIG_arg_fail(2)) SWIG_fail;
12205 }
12206 {
12207 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12208 if (SWIG_arg_fail(3)) SWIG_fail;
12209 }
12210 {
12211 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12212 if (SWIG_arg_fail(4)) SWIG_fail;
12213 }
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12217
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 {
12222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12223 }
12224 return resultobj;
12225 fail:
12226 return NULL;
12227 }
12228
12229
12230 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12231 PyObject *resultobj;
12232 wxImage *arg1 = (wxImage *) 0 ;
12233 wxImage *arg2 = 0 ;
12234 byte arg3 ;
12235 byte arg4 ;
12236 byte arg5 ;
12237 bool result;
12238 PyObject * obj0 = 0 ;
12239 PyObject * obj1 = 0 ;
12240 PyObject * obj2 = 0 ;
12241 PyObject * obj3 = 0 ;
12242 PyObject * obj4 = 0 ;
12243 char *kwnames[] = {
12244 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12245 };
12246
12247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12249 if (SWIG_arg_fail(1)) SWIG_fail;
12250 {
12251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12252 if (SWIG_arg_fail(2)) SWIG_fail;
12253 if (arg2 == NULL) {
12254 SWIG_null_ref("wxImage");
12255 }
12256 if (SWIG_arg_fail(2)) SWIG_fail;
12257 }
12258 {
12259 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12260 if (SWIG_arg_fail(3)) SWIG_fail;
12261 }
12262 {
12263 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12264 if (SWIG_arg_fail(4)) SWIG_fail;
12265 }
12266 {
12267 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
12268 if (SWIG_arg_fail(5)) SWIG_fail;
12269 }
12270 {
12271 PyThreadState* __tstate = wxPyBeginAllowThreads();
12272 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12273
12274 wxPyEndAllowThreads(__tstate);
12275 if (PyErr_Occurred()) SWIG_fail;
12276 }
12277 {
12278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12279 }
12280 return resultobj;
12281 fail:
12282 return NULL;
12283 }
12284
12285
12286 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12287 PyObject *resultobj;
12288 wxString *arg1 = 0 ;
12289 bool result;
12290 bool temp1 = false ;
12291 PyObject * obj0 = 0 ;
12292 char *kwnames[] = {
12293 (char *) "filename", NULL
12294 };
12295
12296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12297 {
12298 arg1 = wxString_in_helper(obj0);
12299 if (arg1 == NULL) SWIG_fail;
12300 temp1 = true;
12301 }
12302 {
12303 PyThreadState* __tstate = wxPyBeginAllowThreads();
12304 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12305
12306 wxPyEndAllowThreads(__tstate);
12307 if (PyErr_Occurred()) SWIG_fail;
12308 }
12309 {
12310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12311 }
12312 {
12313 if (temp1)
12314 delete arg1;
12315 }
12316 return resultobj;
12317 fail:
12318 {
12319 if (temp1)
12320 delete arg1;
12321 }
12322 return NULL;
12323 }
12324
12325
12326 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12327 PyObject *resultobj;
12328 wxString *arg1 = 0 ;
12329 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12330 int result;
12331 bool temp1 = false ;
12332 PyObject * obj0 = 0 ;
12333 PyObject * obj1 = 0 ;
12334 char *kwnames[] = {
12335 (char *) "filename",(char *) "type", NULL
12336 };
12337
12338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12339 {
12340 arg1 = wxString_in_helper(obj0);
12341 if (arg1 == NULL) SWIG_fail;
12342 temp1 = true;
12343 }
12344 if (obj1) {
12345 {
12346 arg2 = (long)(SWIG_As_long(obj1));
12347 if (SWIG_arg_fail(2)) SWIG_fail;
12348 }
12349 }
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12353
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 {
12358 resultobj = SWIG_From_int((int)(result));
12359 }
12360 {
12361 if (temp1)
12362 delete arg1;
12363 }
12364 return resultobj;
12365 fail:
12366 {
12367 if (temp1)
12368 delete arg1;
12369 }
12370 return NULL;
12371 }
12372
12373
12374 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj;
12376 wxImage *arg1 = (wxImage *) 0 ;
12377 wxString *arg2 = 0 ;
12378 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12379 int arg4 = (int) -1 ;
12380 bool result;
12381 bool temp2 = false ;
12382 PyObject * obj0 = 0 ;
12383 PyObject * obj1 = 0 ;
12384 PyObject * obj2 = 0 ;
12385 PyObject * obj3 = 0 ;
12386 char *kwnames[] = {
12387 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12388 };
12389
12390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12392 if (SWIG_arg_fail(1)) SWIG_fail;
12393 {
12394 arg2 = wxString_in_helper(obj1);
12395 if (arg2 == NULL) SWIG_fail;
12396 temp2 = true;
12397 }
12398 if (obj2) {
12399 {
12400 arg3 = (long)(SWIG_As_long(obj2));
12401 if (SWIG_arg_fail(3)) SWIG_fail;
12402 }
12403 }
12404 if (obj3) {
12405 {
12406 arg4 = (int)(SWIG_As_int(obj3));
12407 if (SWIG_arg_fail(4)) SWIG_fail;
12408 }
12409 }
12410 {
12411 PyThreadState* __tstate = wxPyBeginAllowThreads();
12412 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12413
12414 wxPyEndAllowThreads(__tstate);
12415 if (PyErr_Occurred()) SWIG_fail;
12416 }
12417 {
12418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12419 }
12420 {
12421 if (temp2)
12422 delete arg2;
12423 }
12424 return resultobj;
12425 fail:
12426 {
12427 if (temp2)
12428 delete arg2;
12429 }
12430 return NULL;
12431 }
12432
12433
12434 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12435 PyObject *resultobj;
12436 wxImage *arg1 = (wxImage *) 0 ;
12437 wxString *arg2 = 0 ;
12438 wxString *arg3 = 0 ;
12439 int arg4 = (int) -1 ;
12440 bool result;
12441 bool temp2 = false ;
12442 bool temp3 = false ;
12443 PyObject * obj0 = 0 ;
12444 PyObject * obj1 = 0 ;
12445 PyObject * obj2 = 0 ;
12446 PyObject * obj3 = 0 ;
12447 char *kwnames[] = {
12448 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12449 };
12450
12451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12453 if (SWIG_arg_fail(1)) SWIG_fail;
12454 {
12455 arg2 = wxString_in_helper(obj1);
12456 if (arg2 == NULL) SWIG_fail;
12457 temp2 = true;
12458 }
12459 {
12460 arg3 = wxString_in_helper(obj2);
12461 if (arg3 == NULL) SWIG_fail;
12462 temp3 = true;
12463 }
12464 if (obj3) {
12465 {
12466 arg4 = (int)(SWIG_As_int(obj3));
12467 if (SWIG_arg_fail(4)) SWIG_fail;
12468 }
12469 }
12470 {
12471 PyThreadState* __tstate = wxPyBeginAllowThreads();
12472 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12473
12474 wxPyEndAllowThreads(__tstate);
12475 if (PyErr_Occurred()) SWIG_fail;
12476 }
12477 {
12478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12479 }
12480 {
12481 if (temp2)
12482 delete arg2;
12483 }
12484 {
12485 if (temp3)
12486 delete arg3;
12487 }
12488 return resultobj;
12489 fail:
12490 {
12491 if (temp2)
12492 delete arg2;
12493 }
12494 {
12495 if (temp3)
12496 delete arg3;
12497 }
12498 return NULL;
12499 }
12500
12501
12502 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj;
12504 wxImage *arg1 = (wxImage *) 0 ;
12505 wxString *arg2 = 0 ;
12506 int arg3 ;
12507 bool result;
12508 bool temp2 = false ;
12509 PyObject * obj0 = 0 ;
12510 PyObject * obj1 = 0 ;
12511 PyObject * obj2 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self",(char *) "name",(char *) "type", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 {
12520 arg2 = wxString_in_helper(obj1);
12521 if (arg2 == NULL) SWIG_fail;
12522 temp2 = true;
12523 }
12524 {
12525 arg3 = (int)(SWIG_As_int(obj2));
12526 if (SWIG_arg_fail(3)) SWIG_fail;
12527 }
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12531
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 {
12536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12537 }
12538 {
12539 if (temp2)
12540 delete arg2;
12541 }
12542 return resultobj;
12543 fail:
12544 {
12545 if (temp2)
12546 delete arg2;
12547 }
12548 return NULL;
12549 }
12550
12551
12552 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12553 PyObject *resultobj;
12554 wxImage *arg1 = (wxImage *) 0 ;
12555 wxString *arg2 = 0 ;
12556 wxString *arg3 = 0 ;
12557 bool result;
12558 bool temp2 = false ;
12559 bool temp3 = false ;
12560 PyObject * obj0 = 0 ;
12561 PyObject * obj1 = 0 ;
12562 PyObject * obj2 = 0 ;
12563 char *kwnames[] = {
12564 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12565 };
12566
12567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12569 if (SWIG_arg_fail(1)) SWIG_fail;
12570 {
12571 arg2 = wxString_in_helper(obj1);
12572 if (arg2 == NULL) SWIG_fail;
12573 temp2 = true;
12574 }
12575 {
12576 arg3 = wxString_in_helper(obj2);
12577 if (arg3 == NULL) SWIG_fail;
12578 temp3 = true;
12579 }
12580 {
12581 PyThreadState* __tstate = wxPyBeginAllowThreads();
12582 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12583
12584 wxPyEndAllowThreads(__tstate);
12585 if (PyErr_Occurred()) SWIG_fail;
12586 }
12587 {
12588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12589 }
12590 {
12591 if (temp2)
12592 delete arg2;
12593 }
12594 {
12595 if (temp3)
12596 delete arg3;
12597 }
12598 return resultobj;
12599 fail:
12600 {
12601 if (temp2)
12602 delete arg2;
12603 }
12604 {
12605 if (temp3)
12606 delete arg3;
12607 }
12608 return NULL;
12609 }
12610
12611
12612 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12613 PyObject *resultobj;
12614 wxInputStream *arg1 = 0 ;
12615 bool result;
12616 wxPyInputStream *temp1 ;
12617 bool created1 ;
12618 PyObject * obj0 = 0 ;
12619 char *kwnames[] = {
12620 (char *) "stream", NULL
12621 };
12622
12623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12624 {
12625 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12626 arg1 = temp1->m_wxis;
12627 created1 = false;
12628 } else {
12629 PyErr_Clear(); // clear the failure of the wxPyConvert above
12630 arg1 = wxPyCBInputStream_create(obj0, false);
12631 if (arg1 == NULL) {
12632 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12633 SWIG_fail;
12634 }
12635 created1 = true;
12636 }
12637 }
12638 {
12639 PyThreadState* __tstate = wxPyBeginAllowThreads();
12640 result = (bool)wxImage::CanRead(*arg1);
12641
12642 wxPyEndAllowThreads(__tstate);
12643 if (PyErr_Occurred()) SWIG_fail;
12644 }
12645 {
12646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12647 }
12648 {
12649 if (created1) delete arg1;
12650 }
12651 return resultobj;
12652 fail:
12653 {
12654 if (created1) delete arg1;
12655 }
12656 return NULL;
12657 }
12658
12659
12660 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12661 PyObject *resultobj;
12662 wxImage *arg1 = (wxImage *) 0 ;
12663 wxInputStream *arg2 = 0 ;
12664 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12665 int arg4 = (int) -1 ;
12666 bool result;
12667 wxPyInputStream *temp2 ;
12668 bool created2 ;
12669 PyObject * obj0 = 0 ;
12670 PyObject * obj1 = 0 ;
12671 PyObject * obj2 = 0 ;
12672 PyObject * obj3 = 0 ;
12673 char *kwnames[] = {
12674 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12675 };
12676
12677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12679 if (SWIG_arg_fail(1)) SWIG_fail;
12680 {
12681 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12682 arg2 = temp2->m_wxis;
12683 created2 = false;
12684 } else {
12685 PyErr_Clear(); // clear the failure of the wxPyConvert above
12686 arg2 = wxPyCBInputStream_create(obj1, false);
12687 if (arg2 == NULL) {
12688 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12689 SWIG_fail;
12690 }
12691 created2 = true;
12692 }
12693 }
12694 if (obj2) {
12695 {
12696 arg3 = (long)(SWIG_As_long(obj2));
12697 if (SWIG_arg_fail(3)) SWIG_fail;
12698 }
12699 }
12700 if (obj3) {
12701 {
12702 arg4 = (int)(SWIG_As_int(obj3));
12703 if (SWIG_arg_fail(4)) SWIG_fail;
12704 }
12705 }
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12709
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 {
12714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12715 }
12716 {
12717 if (created2) delete arg2;
12718 }
12719 return resultobj;
12720 fail:
12721 {
12722 if (created2) delete arg2;
12723 }
12724 return NULL;
12725 }
12726
12727
12728 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12729 PyObject *resultobj;
12730 wxImage *arg1 = (wxImage *) 0 ;
12731 wxInputStream *arg2 = 0 ;
12732 wxString *arg3 = 0 ;
12733 int arg4 = (int) -1 ;
12734 bool result;
12735 wxPyInputStream *temp2 ;
12736 bool created2 ;
12737 bool temp3 = false ;
12738 PyObject * obj0 = 0 ;
12739 PyObject * obj1 = 0 ;
12740 PyObject * obj2 = 0 ;
12741 PyObject * obj3 = 0 ;
12742 char *kwnames[] = {
12743 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12744 };
12745
12746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12748 if (SWIG_arg_fail(1)) SWIG_fail;
12749 {
12750 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12751 arg2 = temp2->m_wxis;
12752 created2 = false;
12753 } else {
12754 PyErr_Clear(); // clear the failure of the wxPyConvert above
12755 arg2 = wxPyCBInputStream_create(obj1, false);
12756 if (arg2 == NULL) {
12757 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12758 SWIG_fail;
12759 }
12760 created2 = true;
12761 }
12762 }
12763 {
12764 arg3 = wxString_in_helper(obj2);
12765 if (arg3 == NULL) SWIG_fail;
12766 temp3 = true;
12767 }
12768 if (obj3) {
12769 {
12770 arg4 = (int)(SWIG_As_int(obj3));
12771 if (SWIG_arg_fail(4)) SWIG_fail;
12772 }
12773 }
12774 {
12775 PyThreadState* __tstate = wxPyBeginAllowThreads();
12776 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12777
12778 wxPyEndAllowThreads(__tstate);
12779 if (PyErr_Occurred()) SWIG_fail;
12780 }
12781 {
12782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12783 }
12784 {
12785 if (created2) delete arg2;
12786 }
12787 {
12788 if (temp3)
12789 delete arg3;
12790 }
12791 return resultobj;
12792 fail:
12793 {
12794 if (created2) delete arg2;
12795 }
12796 {
12797 if (temp3)
12798 delete arg3;
12799 }
12800 return NULL;
12801 }
12802
12803
12804 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12805 PyObject *resultobj;
12806 wxImage *arg1 = (wxImage *) 0 ;
12807 bool result;
12808 PyObject * obj0 = 0 ;
12809 char *kwnames[] = {
12810 (char *) "self", NULL
12811 };
12812
12813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12815 if (SWIG_arg_fail(1)) SWIG_fail;
12816 {
12817 PyThreadState* __tstate = wxPyBeginAllowThreads();
12818 result = (bool)(arg1)->Ok();
12819
12820 wxPyEndAllowThreads(__tstate);
12821 if (PyErr_Occurred()) SWIG_fail;
12822 }
12823 {
12824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12825 }
12826 return resultobj;
12827 fail:
12828 return NULL;
12829 }
12830
12831
12832 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12833 PyObject *resultobj;
12834 wxImage *arg1 = (wxImage *) 0 ;
12835 int result;
12836 PyObject * obj0 = 0 ;
12837 char *kwnames[] = {
12838 (char *) "self", NULL
12839 };
12840
12841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12843 if (SWIG_arg_fail(1)) SWIG_fail;
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 result = (int)(arg1)->GetWidth();
12847
12848 wxPyEndAllowThreads(__tstate);
12849 if (PyErr_Occurred()) SWIG_fail;
12850 }
12851 {
12852 resultobj = SWIG_From_int((int)(result));
12853 }
12854 return resultobj;
12855 fail:
12856 return NULL;
12857 }
12858
12859
12860 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12861 PyObject *resultobj;
12862 wxImage *arg1 = (wxImage *) 0 ;
12863 int result;
12864 PyObject * obj0 = 0 ;
12865 char *kwnames[] = {
12866 (char *) "self", NULL
12867 };
12868
12869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12871 if (SWIG_arg_fail(1)) SWIG_fail;
12872 {
12873 PyThreadState* __tstate = wxPyBeginAllowThreads();
12874 result = (int)(arg1)->GetHeight();
12875
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 {
12880 resultobj = SWIG_From_int((int)(result));
12881 }
12882 return resultobj;
12883 fail:
12884 return NULL;
12885 }
12886
12887
12888 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12889 PyObject *resultobj;
12890 wxImage *arg1 = (wxImage *) 0 ;
12891 wxSize result;
12892 PyObject * obj0 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "self", NULL
12895 };
12896
12897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12899 if (SWIG_arg_fail(1)) SWIG_fail;
12900 {
12901 PyThreadState* __tstate = wxPyBeginAllowThreads();
12902 result = wxImage_GetSize(arg1);
12903
12904 wxPyEndAllowThreads(__tstate);
12905 if (PyErr_Occurred()) SWIG_fail;
12906 }
12907 {
12908 wxSize * resultptr;
12909 resultptr = new wxSize((wxSize &)(result));
12910 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12911 }
12912 return resultobj;
12913 fail:
12914 return NULL;
12915 }
12916
12917
12918 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj;
12920 wxImage *arg1 = (wxImage *) 0 ;
12921 wxRect *arg2 = 0 ;
12922 SwigValueWrapper<wxImage > result;
12923 wxRect temp2 ;
12924 PyObject * obj0 = 0 ;
12925 PyObject * obj1 = 0 ;
12926 char *kwnames[] = {
12927 (char *) "self",(char *) "rect", NULL
12928 };
12929
12930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12932 if (SWIG_arg_fail(1)) SWIG_fail;
12933 {
12934 arg2 = &temp2;
12935 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12936 }
12937 {
12938 PyThreadState* __tstate = wxPyBeginAllowThreads();
12939 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12940
12941 wxPyEndAllowThreads(__tstate);
12942 if (PyErr_Occurred()) SWIG_fail;
12943 }
12944 {
12945 wxImage * resultptr;
12946 resultptr = new wxImage((wxImage &)(result));
12947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12948 }
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj;
12957 wxImage *arg1 = (wxImage *) 0 ;
12958 wxSize *arg2 = 0 ;
12959 wxPoint *arg3 = 0 ;
12960 int arg4 = (int) -1 ;
12961 int arg5 = (int) -1 ;
12962 int arg6 = (int) -1 ;
12963 SwigValueWrapper<wxImage > result;
12964 wxSize temp2 ;
12965 wxPoint temp3 ;
12966 PyObject * obj0 = 0 ;
12967 PyObject * obj1 = 0 ;
12968 PyObject * obj2 = 0 ;
12969 PyObject * obj3 = 0 ;
12970 PyObject * obj4 = 0 ;
12971 PyObject * obj5 = 0 ;
12972 char *kwnames[] = {
12973 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12974 };
12975
12976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12978 if (SWIG_arg_fail(1)) SWIG_fail;
12979 {
12980 arg2 = &temp2;
12981 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12982 }
12983 {
12984 arg3 = &temp3;
12985 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12986 }
12987 if (obj3) {
12988 {
12989 arg4 = (int)(SWIG_As_int(obj3));
12990 if (SWIG_arg_fail(4)) SWIG_fail;
12991 }
12992 }
12993 if (obj4) {
12994 {
12995 arg5 = (int)(SWIG_As_int(obj4));
12996 if (SWIG_arg_fail(5)) SWIG_fail;
12997 }
12998 }
12999 if (obj5) {
13000 {
13001 arg6 = (int)(SWIG_As_int(obj5));
13002 if (SWIG_arg_fail(6)) SWIG_fail;
13003 }
13004 }
13005 {
13006 PyThreadState* __tstate = wxPyBeginAllowThreads();
13007 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13008
13009 wxPyEndAllowThreads(__tstate);
13010 if (PyErr_Occurred()) SWIG_fail;
13011 }
13012 {
13013 wxImage * resultptr;
13014 resultptr = new wxImage((wxImage &)(result));
13015 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13016 }
13017 return resultobj;
13018 fail:
13019 return NULL;
13020 }
13021
13022
13023 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13024 PyObject *resultobj;
13025 wxImage *arg1 = (wxImage *) 0 ;
13026 SwigValueWrapper<wxImage > result;
13027 PyObject * obj0 = 0 ;
13028 char *kwnames[] = {
13029 (char *) "self", NULL
13030 };
13031
13032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13034 if (SWIG_arg_fail(1)) SWIG_fail;
13035 {
13036 PyThreadState* __tstate = wxPyBeginAllowThreads();
13037 result = (arg1)->Copy();
13038
13039 wxPyEndAllowThreads(__tstate);
13040 if (PyErr_Occurred()) SWIG_fail;
13041 }
13042 {
13043 wxImage * resultptr;
13044 resultptr = new wxImage((wxImage &)(result));
13045 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13046 }
13047 return resultobj;
13048 fail:
13049 return NULL;
13050 }
13051
13052
13053 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj;
13055 wxImage *arg1 = (wxImage *) 0 ;
13056 wxImage *arg2 = 0 ;
13057 int arg3 ;
13058 int arg4 ;
13059 PyObject * obj0 = 0 ;
13060 PyObject * obj1 = 0 ;
13061 PyObject * obj2 = 0 ;
13062 PyObject * obj3 = 0 ;
13063 char *kwnames[] = {
13064 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13065 };
13066
13067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13069 if (SWIG_arg_fail(1)) SWIG_fail;
13070 {
13071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13072 if (SWIG_arg_fail(2)) SWIG_fail;
13073 if (arg2 == NULL) {
13074 SWIG_null_ref("wxImage");
13075 }
13076 if (SWIG_arg_fail(2)) SWIG_fail;
13077 }
13078 {
13079 arg3 = (int)(SWIG_As_int(obj2));
13080 if (SWIG_arg_fail(3)) SWIG_fail;
13081 }
13082 {
13083 arg4 = (int)(SWIG_As_int(obj3));
13084 if (SWIG_arg_fail(4)) SWIG_fail;
13085 }
13086 {
13087 PyThreadState* __tstate = wxPyBeginAllowThreads();
13088 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13089
13090 wxPyEndAllowThreads(__tstate);
13091 if (PyErr_Occurred()) SWIG_fail;
13092 }
13093 Py_INCREF(Py_None); resultobj = Py_None;
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13101 PyObject *resultobj;
13102 wxImage *arg1 = (wxImage *) 0 ;
13103 PyObject *result;
13104 PyObject * obj0 = 0 ;
13105 char *kwnames[] = {
13106 (char *) "self", NULL
13107 };
13108
13109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13111 if (SWIG_arg_fail(1)) SWIG_fail;
13112 {
13113 PyThreadState* __tstate = wxPyBeginAllowThreads();
13114 result = (PyObject *)wxImage_GetData(arg1);
13115
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 resultobj = result;
13120 return resultobj;
13121 fail:
13122 return NULL;
13123 }
13124
13125
13126 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13127 PyObject *resultobj;
13128 wxImage *arg1 = (wxImage *) 0 ;
13129 buffer arg2 ;
13130 int arg3 ;
13131 PyObject * obj0 = 0 ;
13132 PyObject * obj1 = 0 ;
13133 char *kwnames[] = {
13134 (char *) "self",(char *) "data", NULL
13135 };
13136
13137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13139 if (SWIG_arg_fail(1)) SWIG_fail;
13140 {
13141 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13142 }
13143 {
13144 PyThreadState* __tstate = wxPyBeginAllowThreads();
13145 wxImage_SetData(arg1,arg2,arg3);
13146
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 Py_INCREF(Py_None); resultobj = Py_None;
13151 return resultobj;
13152 fail:
13153 return NULL;
13154 }
13155
13156
13157 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13158 PyObject *resultobj;
13159 wxImage *arg1 = (wxImage *) 0 ;
13160 PyObject *result;
13161 PyObject * obj0 = 0 ;
13162 char *kwnames[] = {
13163 (char *) "self", NULL
13164 };
13165
13166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13168 if (SWIG_arg_fail(1)) SWIG_fail;
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13172
13173 wxPyEndAllowThreads(__tstate);
13174 if (PyErr_Occurred()) SWIG_fail;
13175 }
13176 resultobj = result;
13177 return resultobj;
13178 fail:
13179 return NULL;
13180 }
13181
13182
13183 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13184 PyObject *resultobj;
13185 wxImage *arg1 = (wxImage *) 0 ;
13186 buffer arg2 ;
13187 int arg3 ;
13188 PyObject * obj0 = 0 ;
13189 PyObject * obj1 = 0 ;
13190 char *kwnames[] = {
13191 (char *) "self",(char *) "data", NULL
13192 };
13193
13194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13196 if (SWIG_arg_fail(1)) SWIG_fail;
13197 {
13198 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13199 }
13200 {
13201 PyThreadState* __tstate = wxPyBeginAllowThreads();
13202 wxImage_SetDataBuffer(arg1,arg2,arg3);
13203
13204 wxPyEndAllowThreads(__tstate);
13205 if (PyErr_Occurred()) SWIG_fail;
13206 }
13207 Py_INCREF(Py_None); resultobj = Py_None;
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj;
13216 wxImage *arg1 = (wxImage *) 0 ;
13217 PyObject *result;
13218 PyObject * obj0 = 0 ;
13219 char *kwnames[] = {
13220 (char *) "self", NULL
13221 };
13222
13223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13225 if (SWIG_arg_fail(1)) SWIG_fail;
13226 {
13227 PyThreadState* __tstate = wxPyBeginAllowThreads();
13228 result = (PyObject *)wxImage_GetAlphaData(arg1);
13229
13230 wxPyEndAllowThreads(__tstate);
13231 if (PyErr_Occurred()) SWIG_fail;
13232 }
13233 resultobj = result;
13234 return resultobj;
13235 fail:
13236 return NULL;
13237 }
13238
13239
13240 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13241 PyObject *resultobj;
13242 wxImage *arg1 = (wxImage *) 0 ;
13243 buffer arg2 ;
13244 int arg3 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 char *kwnames[] = {
13248 (char *) "self",(char *) "alpha", NULL
13249 };
13250
13251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13253 if (SWIG_arg_fail(1)) SWIG_fail;
13254 {
13255 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13256 }
13257 {
13258 PyThreadState* __tstate = wxPyBeginAllowThreads();
13259 wxImage_SetAlphaData(arg1,arg2,arg3);
13260
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 Py_INCREF(Py_None); resultobj = Py_None;
13265 return resultobj;
13266 fail:
13267 return NULL;
13268 }
13269
13270
13271 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13272 PyObject *resultobj;
13273 wxImage *arg1 = (wxImage *) 0 ;
13274 PyObject *result;
13275 PyObject * obj0 = 0 ;
13276 char *kwnames[] = {
13277 (char *) "self", NULL
13278 };
13279
13280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13282 if (SWIG_arg_fail(1)) SWIG_fail;
13283 {
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13286
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 resultobj = result;
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj;
13299 wxImage *arg1 = (wxImage *) 0 ;
13300 buffer arg2 ;
13301 int arg3 ;
13302 PyObject * obj0 = 0 ;
13303 PyObject * obj1 = 0 ;
13304 char *kwnames[] = {
13305 (char *) "self",(char *) "alpha", NULL
13306 };
13307
13308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13310 if (SWIG_arg_fail(1)) SWIG_fail;
13311 {
13312 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13313 }
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13317
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 Py_INCREF(Py_None); resultobj = Py_None;
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj;
13330 wxImage *arg1 = (wxImage *) 0 ;
13331 byte arg2 ;
13332 byte arg3 ;
13333 byte arg4 ;
13334 PyObject * obj0 = 0 ;
13335 PyObject * obj1 = 0 ;
13336 PyObject * obj2 = 0 ;
13337 PyObject * obj3 = 0 ;
13338 char *kwnames[] = {
13339 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13340 };
13341
13342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13344 if (SWIG_arg_fail(1)) SWIG_fail;
13345 {
13346 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13347 if (SWIG_arg_fail(2)) SWIG_fail;
13348 }
13349 {
13350 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13351 if (SWIG_arg_fail(3)) SWIG_fail;
13352 }
13353 {
13354 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13355 if (SWIG_arg_fail(4)) SWIG_fail;
13356 }
13357 {
13358 PyThreadState* __tstate = wxPyBeginAllowThreads();
13359 (arg1)->SetMaskColour(arg2,arg3,arg4);
13360
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 Py_INCREF(Py_None); resultobj = Py_None;
13365 return resultobj;
13366 fail:
13367 return NULL;
13368 }
13369
13370
13371 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj;
13373 wxImage *arg1 = (wxImage *) 0 ;
13374 byte *arg2 = (byte *) 0 ;
13375 byte *arg3 = (byte *) 0 ;
13376 byte *arg4 = (byte *) 0 ;
13377 byte temp2 ;
13378 int res2 = 0 ;
13379 byte temp3 ;
13380 int res3 = 0 ;
13381 byte temp4 ;
13382 int res4 = 0 ;
13383 PyObject * obj0 = 0 ;
13384 char *kwnames[] = {
13385 (char *) "self", NULL
13386 };
13387
13388 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13389 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13390 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13393 if (SWIG_arg_fail(1)) SWIG_fail;
13394 {
13395 PyThreadState* __tstate = wxPyBeginAllowThreads();
13396 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13397
13398 wxPyEndAllowThreads(__tstate);
13399 if (PyErr_Occurred()) SWIG_fail;
13400 }
13401 Py_INCREF(Py_None); resultobj = Py_None;
13402 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13403 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13404 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13405 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13406 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13407 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13408 return resultobj;
13409 fail:
13410 return NULL;
13411 }
13412
13413
13414 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13415 PyObject *resultobj;
13416 wxImage *arg1 = (wxImage *) 0 ;
13417 byte result;
13418 PyObject * obj0 = 0 ;
13419 char *kwnames[] = {
13420 (char *) "self", NULL
13421 };
13422
13423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13425 if (SWIG_arg_fail(1)) SWIG_fail;
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = (byte)(arg1)->GetMaskRed();
13429
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 {
13434 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13435 }
13436 return resultobj;
13437 fail:
13438 return NULL;
13439 }
13440
13441
13442 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13443 PyObject *resultobj;
13444 wxImage *arg1 = (wxImage *) 0 ;
13445 byte result;
13446 PyObject * obj0 = 0 ;
13447 char *kwnames[] = {
13448 (char *) "self", NULL
13449 };
13450
13451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13453 if (SWIG_arg_fail(1)) SWIG_fail;
13454 {
13455 PyThreadState* __tstate = wxPyBeginAllowThreads();
13456 result = (byte)(arg1)->GetMaskGreen();
13457
13458 wxPyEndAllowThreads(__tstate);
13459 if (PyErr_Occurred()) SWIG_fail;
13460 }
13461 {
13462 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13463 }
13464 return resultobj;
13465 fail:
13466 return NULL;
13467 }
13468
13469
13470 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13471 PyObject *resultobj;
13472 wxImage *arg1 = (wxImage *) 0 ;
13473 byte result;
13474 PyObject * obj0 = 0 ;
13475 char *kwnames[] = {
13476 (char *) "self", NULL
13477 };
13478
13479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13481 if (SWIG_arg_fail(1)) SWIG_fail;
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = (byte)(arg1)->GetMaskBlue();
13485
13486 wxPyEndAllowThreads(__tstate);
13487 if (PyErr_Occurred()) SWIG_fail;
13488 }
13489 {
13490 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13491 }
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13499 PyObject *resultobj;
13500 wxImage *arg1 = (wxImage *) 0 ;
13501 bool arg2 = (bool) true ;
13502 PyObject * obj0 = 0 ;
13503 PyObject * obj1 = 0 ;
13504 char *kwnames[] = {
13505 (char *) "self",(char *) "mask", NULL
13506 };
13507
13508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13510 if (SWIG_arg_fail(1)) SWIG_fail;
13511 if (obj1) {
13512 {
13513 arg2 = (bool)(SWIG_As_bool(obj1));
13514 if (SWIG_arg_fail(2)) SWIG_fail;
13515 }
13516 }
13517 {
13518 PyThreadState* __tstate = wxPyBeginAllowThreads();
13519 (arg1)->SetMask(arg2);
13520
13521 wxPyEndAllowThreads(__tstate);
13522 if (PyErr_Occurred()) SWIG_fail;
13523 }
13524 Py_INCREF(Py_None); resultobj = Py_None;
13525 return resultobj;
13526 fail:
13527 return NULL;
13528 }
13529
13530
13531 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13532 PyObject *resultobj;
13533 wxImage *arg1 = (wxImage *) 0 ;
13534 bool result;
13535 PyObject * obj0 = 0 ;
13536 char *kwnames[] = {
13537 (char *) "self", NULL
13538 };
13539
13540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13542 if (SWIG_arg_fail(1)) SWIG_fail;
13543 {
13544 PyThreadState* __tstate = wxPyBeginAllowThreads();
13545 result = (bool)(arg1)->HasMask();
13546
13547 wxPyEndAllowThreads(__tstate);
13548 if (PyErr_Occurred()) SWIG_fail;
13549 }
13550 {
13551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13552 }
13553 return resultobj;
13554 fail:
13555 return NULL;
13556 }
13557
13558
13559 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13560 PyObject *resultobj;
13561 wxImage *arg1 = (wxImage *) 0 ;
13562 double arg2 ;
13563 wxPoint *arg3 = 0 ;
13564 bool arg4 = (bool) true ;
13565 wxPoint *arg5 = (wxPoint *) NULL ;
13566 SwigValueWrapper<wxImage > result;
13567 wxPoint temp3 ;
13568 PyObject * obj0 = 0 ;
13569 PyObject * obj1 = 0 ;
13570 PyObject * obj2 = 0 ;
13571 PyObject * obj3 = 0 ;
13572 PyObject * obj4 = 0 ;
13573 char *kwnames[] = {
13574 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13575 };
13576
13577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13579 if (SWIG_arg_fail(1)) SWIG_fail;
13580 {
13581 arg2 = (double)(SWIG_As_double(obj1));
13582 if (SWIG_arg_fail(2)) SWIG_fail;
13583 }
13584 {
13585 arg3 = &temp3;
13586 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13587 }
13588 if (obj3) {
13589 {
13590 arg4 = (bool)(SWIG_As_bool(obj3));
13591 if (SWIG_arg_fail(4)) SWIG_fail;
13592 }
13593 }
13594 if (obj4) {
13595 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13596 if (SWIG_arg_fail(5)) SWIG_fail;
13597 }
13598 {
13599 PyThreadState* __tstate = wxPyBeginAllowThreads();
13600 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13601
13602 wxPyEndAllowThreads(__tstate);
13603 if (PyErr_Occurred()) SWIG_fail;
13604 }
13605 {
13606 wxImage * resultptr;
13607 resultptr = new wxImage((wxImage &)(result));
13608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13609 }
13610 return resultobj;
13611 fail:
13612 return NULL;
13613 }
13614
13615
13616 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13617 PyObject *resultobj;
13618 wxImage *arg1 = (wxImage *) 0 ;
13619 bool arg2 = (bool) true ;
13620 SwigValueWrapper<wxImage > result;
13621 PyObject * obj0 = 0 ;
13622 PyObject * obj1 = 0 ;
13623 char *kwnames[] = {
13624 (char *) "self",(char *) "clockwise", NULL
13625 };
13626
13627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13629 if (SWIG_arg_fail(1)) SWIG_fail;
13630 if (obj1) {
13631 {
13632 arg2 = (bool)(SWIG_As_bool(obj1));
13633 if (SWIG_arg_fail(2)) SWIG_fail;
13634 }
13635 }
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 result = (arg1)->Rotate90(arg2);
13639
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 {
13644 wxImage * resultptr;
13645 resultptr = new wxImage((wxImage &)(result));
13646 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13647 }
13648 return resultobj;
13649 fail:
13650 return NULL;
13651 }
13652
13653
13654 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13655 PyObject *resultobj;
13656 wxImage *arg1 = (wxImage *) 0 ;
13657 bool arg2 = (bool) true ;
13658 SwigValueWrapper<wxImage > result;
13659 PyObject * obj0 = 0 ;
13660 PyObject * obj1 = 0 ;
13661 char *kwnames[] = {
13662 (char *) "self",(char *) "horizontally", NULL
13663 };
13664
13665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13667 if (SWIG_arg_fail(1)) SWIG_fail;
13668 if (obj1) {
13669 {
13670 arg2 = (bool)(SWIG_As_bool(obj1));
13671 if (SWIG_arg_fail(2)) SWIG_fail;
13672 }
13673 }
13674 {
13675 PyThreadState* __tstate = wxPyBeginAllowThreads();
13676 result = (arg1)->Mirror(arg2);
13677
13678 wxPyEndAllowThreads(__tstate);
13679 if (PyErr_Occurred()) SWIG_fail;
13680 }
13681 {
13682 wxImage * resultptr;
13683 resultptr = new wxImage((wxImage &)(result));
13684 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13685 }
13686 return resultobj;
13687 fail:
13688 return NULL;
13689 }
13690
13691
13692 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13693 PyObject *resultobj;
13694 wxImage *arg1 = (wxImage *) 0 ;
13695 byte arg2 ;
13696 byte arg3 ;
13697 byte arg4 ;
13698 byte arg5 ;
13699 byte arg6 ;
13700 byte arg7 ;
13701 PyObject * obj0 = 0 ;
13702 PyObject * obj1 = 0 ;
13703 PyObject * obj2 = 0 ;
13704 PyObject * obj3 = 0 ;
13705 PyObject * obj4 = 0 ;
13706 PyObject * obj5 = 0 ;
13707 PyObject * obj6 = 0 ;
13708 char *kwnames[] = {
13709 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13710 };
13711
13712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13714 if (SWIG_arg_fail(1)) SWIG_fail;
13715 {
13716 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13717 if (SWIG_arg_fail(2)) SWIG_fail;
13718 }
13719 {
13720 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13721 if (SWIG_arg_fail(3)) SWIG_fail;
13722 }
13723 {
13724 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13725 if (SWIG_arg_fail(4)) SWIG_fail;
13726 }
13727 {
13728 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13729 if (SWIG_arg_fail(5)) SWIG_fail;
13730 }
13731 {
13732 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13733 if (SWIG_arg_fail(6)) SWIG_fail;
13734 }
13735 {
13736 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13737 if (SWIG_arg_fail(7)) SWIG_fail;
13738 }
13739 {
13740 PyThreadState* __tstate = wxPyBeginAllowThreads();
13741 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13742
13743 wxPyEndAllowThreads(__tstate);
13744 if (PyErr_Occurred()) SWIG_fail;
13745 }
13746 Py_INCREF(Py_None); resultobj = Py_None;
13747 return resultobj;
13748 fail:
13749 return NULL;
13750 }
13751
13752
13753 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13754 PyObject *resultobj;
13755 wxImage *arg1 = (wxImage *) 0 ;
13756 byte arg2 ;
13757 byte arg3 ;
13758 byte arg4 ;
13759 SwigValueWrapper<wxImage > result;
13760 PyObject * obj0 = 0 ;
13761 PyObject * obj1 = 0 ;
13762 PyObject * obj2 = 0 ;
13763 PyObject * obj3 = 0 ;
13764 char *kwnames[] = {
13765 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13766 };
13767
13768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13770 if (SWIG_arg_fail(1)) SWIG_fail;
13771 {
13772 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13773 if (SWIG_arg_fail(2)) SWIG_fail;
13774 }
13775 {
13776 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13777 if (SWIG_arg_fail(3)) SWIG_fail;
13778 }
13779 {
13780 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13781 if (SWIG_arg_fail(4)) SWIG_fail;
13782 }
13783 {
13784 PyThreadState* __tstate = wxPyBeginAllowThreads();
13785 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13786
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 {
13791 wxImage * resultptr;
13792 resultptr = new wxImage((wxImage &)(result));
13793 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13794 }
13795 return resultobj;
13796 fail:
13797 return NULL;
13798 }
13799
13800
13801 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13802 PyObject *resultobj;
13803 wxImage *arg1 = (wxImage *) 0 ;
13804 wxString *arg2 = 0 ;
13805 wxString *arg3 = 0 ;
13806 bool temp2 = false ;
13807 bool temp3 = false ;
13808 PyObject * obj0 = 0 ;
13809 PyObject * obj1 = 0 ;
13810 PyObject * obj2 = 0 ;
13811 char *kwnames[] = {
13812 (char *) "self",(char *) "name",(char *) "value", NULL
13813 };
13814
13815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13817 if (SWIG_arg_fail(1)) SWIG_fail;
13818 {
13819 arg2 = wxString_in_helper(obj1);
13820 if (arg2 == NULL) SWIG_fail;
13821 temp2 = true;
13822 }
13823 {
13824 arg3 = wxString_in_helper(obj2);
13825 if (arg3 == NULL) SWIG_fail;
13826 temp3 = true;
13827 }
13828 {
13829 PyThreadState* __tstate = wxPyBeginAllowThreads();
13830 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13831
13832 wxPyEndAllowThreads(__tstate);
13833 if (PyErr_Occurred()) SWIG_fail;
13834 }
13835 Py_INCREF(Py_None); resultobj = Py_None;
13836 {
13837 if (temp2)
13838 delete arg2;
13839 }
13840 {
13841 if (temp3)
13842 delete arg3;
13843 }
13844 return resultobj;
13845 fail:
13846 {
13847 if (temp2)
13848 delete arg2;
13849 }
13850 {
13851 if (temp3)
13852 delete arg3;
13853 }
13854 return NULL;
13855 }
13856
13857
13858 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj;
13860 wxImage *arg1 = (wxImage *) 0 ;
13861 wxString *arg2 = 0 ;
13862 int arg3 ;
13863 bool temp2 = false ;
13864 PyObject * obj0 = 0 ;
13865 PyObject * obj1 = 0 ;
13866 PyObject * obj2 = 0 ;
13867 char *kwnames[] = {
13868 (char *) "self",(char *) "name",(char *) "value", NULL
13869 };
13870
13871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13873 if (SWIG_arg_fail(1)) SWIG_fail;
13874 {
13875 arg2 = wxString_in_helper(obj1);
13876 if (arg2 == NULL) SWIG_fail;
13877 temp2 = true;
13878 }
13879 {
13880 arg3 = (int)(SWIG_As_int(obj2));
13881 if (SWIG_arg_fail(3)) SWIG_fail;
13882 }
13883 {
13884 PyThreadState* __tstate = wxPyBeginAllowThreads();
13885 (arg1)->SetOption((wxString const &)*arg2,arg3);
13886
13887 wxPyEndAllowThreads(__tstate);
13888 if (PyErr_Occurred()) SWIG_fail;
13889 }
13890 Py_INCREF(Py_None); resultobj = Py_None;
13891 {
13892 if (temp2)
13893 delete arg2;
13894 }
13895 return resultobj;
13896 fail:
13897 {
13898 if (temp2)
13899 delete arg2;
13900 }
13901 return NULL;
13902 }
13903
13904
13905 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13906 PyObject *resultobj;
13907 wxImage *arg1 = (wxImage *) 0 ;
13908 wxString *arg2 = 0 ;
13909 wxString result;
13910 bool temp2 = false ;
13911 PyObject * obj0 = 0 ;
13912 PyObject * obj1 = 0 ;
13913 char *kwnames[] = {
13914 (char *) "self",(char *) "name", NULL
13915 };
13916
13917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13919 if (SWIG_arg_fail(1)) SWIG_fail;
13920 {
13921 arg2 = wxString_in_helper(obj1);
13922 if (arg2 == NULL) SWIG_fail;
13923 temp2 = true;
13924 }
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13928
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 {
13933 #if wxUSE_UNICODE
13934 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13935 #else
13936 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13937 #endif
13938 }
13939 {
13940 if (temp2)
13941 delete arg2;
13942 }
13943 return resultobj;
13944 fail:
13945 {
13946 if (temp2)
13947 delete arg2;
13948 }
13949 return NULL;
13950 }
13951
13952
13953 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13954 PyObject *resultobj;
13955 wxImage *arg1 = (wxImage *) 0 ;
13956 wxString *arg2 = 0 ;
13957 int result;
13958 bool temp2 = false ;
13959 PyObject * obj0 = 0 ;
13960 PyObject * obj1 = 0 ;
13961 char *kwnames[] = {
13962 (char *) "self",(char *) "name", NULL
13963 };
13964
13965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13967 if (SWIG_arg_fail(1)) SWIG_fail;
13968 {
13969 arg2 = wxString_in_helper(obj1);
13970 if (arg2 == NULL) SWIG_fail;
13971 temp2 = true;
13972 }
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13976
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 {
13981 resultobj = SWIG_From_int((int)(result));
13982 }
13983 {
13984 if (temp2)
13985 delete arg2;
13986 }
13987 return resultobj;
13988 fail:
13989 {
13990 if (temp2)
13991 delete arg2;
13992 }
13993 return NULL;
13994 }
13995
13996
13997 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13998 PyObject *resultobj;
13999 wxImage *arg1 = (wxImage *) 0 ;
14000 wxString *arg2 = 0 ;
14001 bool result;
14002 bool temp2 = false ;
14003 PyObject * obj0 = 0 ;
14004 PyObject * obj1 = 0 ;
14005 char *kwnames[] = {
14006 (char *) "self",(char *) "name", NULL
14007 };
14008
14009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14011 if (SWIG_arg_fail(1)) SWIG_fail;
14012 {
14013 arg2 = wxString_in_helper(obj1);
14014 if (arg2 == NULL) SWIG_fail;
14015 temp2 = true;
14016 }
14017 {
14018 PyThreadState* __tstate = wxPyBeginAllowThreads();
14019 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14020
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 {
14025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14026 }
14027 {
14028 if (temp2)
14029 delete arg2;
14030 }
14031 return resultobj;
14032 fail:
14033 {
14034 if (temp2)
14035 delete arg2;
14036 }
14037 return NULL;
14038 }
14039
14040
14041 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj;
14043 wxImage *arg1 = (wxImage *) 0 ;
14044 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14045 unsigned long result;
14046 PyObject * obj0 = 0 ;
14047 PyObject * obj1 = 0 ;
14048 char *kwnames[] = {
14049 (char *) "self",(char *) "stopafter", NULL
14050 };
14051
14052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14054 if (SWIG_arg_fail(1)) SWIG_fail;
14055 if (obj1) {
14056 {
14057 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
14058 if (SWIG_arg_fail(2)) SWIG_fail;
14059 }
14060 }
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 result = (unsigned long)(arg1)->CountColours(arg2);
14064
14065 wxPyEndAllowThreads(__tstate);
14066 if (PyErr_Occurred()) SWIG_fail;
14067 }
14068 {
14069 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
14070 }
14071 return resultobj;
14072 fail:
14073 return NULL;
14074 }
14075
14076
14077 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14078 PyObject *resultobj;
14079 wxImage *arg1 = (wxImage *) 0 ;
14080 wxImageHistogram *arg2 = 0 ;
14081 unsigned long result;
14082 PyObject * obj0 = 0 ;
14083 PyObject * obj1 = 0 ;
14084 char *kwnames[] = {
14085 (char *) "self",(char *) "h", NULL
14086 };
14087
14088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14090 if (SWIG_arg_fail(1)) SWIG_fail;
14091 {
14092 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14093 if (SWIG_arg_fail(2)) SWIG_fail;
14094 if (arg2 == NULL) {
14095 SWIG_null_ref("wxImageHistogram");
14096 }
14097 if (SWIG_arg_fail(2)) SWIG_fail;
14098 }
14099 {
14100 PyThreadState* __tstate = wxPyBeginAllowThreads();
14101 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14102
14103 wxPyEndAllowThreads(__tstate);
14104 if (PyErr_Occurred()) SWIG_fail;
14105 }
14106 {
14107 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
14108 }
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14116 PyObject *resultobj;
14117 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14118 PyObject * obj0 = 0 ;
14119 char *kwnames[] = {
14120 (char *) "handler", NULL
14121 };
14122
14123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14125 if (SWIG_arg_fail(1)) SWIG_fail;
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 wxImage::AddHandler(arg1);
14129
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 Py_INCREF(Py_None); resultobj = Py_None;
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj;
14142 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14143 PyObject * obj0 = 0 ;
14144 char *kwnames[] = {
14145 (char *) "handler", NULL
14146 };
14147
14148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14150 if (SWIG_arg_fail(1)) SWIG_fail;
14151 {
14152 PyThreadState* __tstate = wxPyBeginAllowThreads();
14153 wxImage::InsertHandler(arg1);
14154
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 Py_INCREF(Py_None); resultobj = Py_None;
14159 return resultobj;
14160 fail:
14161 return NULL;
14162 }
14163
14164
14165 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14166 PyObject *resultobj;
14167 wxString *arg1 = 0 ;
14168 bool result;
14169 bool temp1 = false ;
14170 PyObject * obj0 = 0 ;
14171 char *kwnames[] = {
14172 (char *) "name", NULL
14173 };
14174
14175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14176 {
14177 arg1 = wxString_in_helper(obj0);
14178 if (arg1 == NULL) SWIG_fail;
14179 temp1 = true;
14180 }
14181 {
14182 PyThreadState* __tstate = wxPyBeginAllowThreads();
14183 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14184
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 {
14189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14190 }
14191 {
14192 if (temp1)
14193 delete arg1;
14194 }
14195 return resultobj;
14196 fail:
14197 {
14198 if (temp1)
14199 delete arg1;
14200 }
14201 return NULL;
14202 }
14203
14204
14205 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj;
14207 wxString result;
14208 char *kwnames[] = {
14209 NULL
14210 };
14211
14212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 result = wxImage::GetImageExtWildcard();
14216
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 {
14221 #if wxUSE_UNICODE
14222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14223 #else
14224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14225 #endif
14226 }
14227 return resultobj;
14228 fail:
14229 return NULL;
14230 }
14231
14232
14233 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14234 PyObject *resultobj;
14235 wxImage *arg1 = (wxImage *) 0 ;
14236 int arg2 = (int) -1 ;
14237 wxBitmap result;
14238 PyObject * obj0 = 0 ;
14239 PyObject * obj1 = 0 ;
14240 char *kwnames[] = {
14241 (char *) "self",(char *) "depth", NULL
14242 };
14243
14244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14246 if (SWIG_arg_fail(1)) SWIG_fail;
14247 if (obj1) {
14248 {
14249 arg2 = (int)(SWIG_As_int(obj1));
14250 if (SWIG_arg_fail(2)) SWIG_fail;
14251 }
14252 }
14253 {
14254 if (!wxPyCheckForApp()) SWIG_fail;
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = wxImage_ConvertToBitmap(arg1,arg2);
14257
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 {
14262 wxBitmap * resultptr;
14263 resultptr = new wxBitmap((wxBitmap &)(result));
14264 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14265 }
14266 return resultobj;
14267 fail:
14268 return NULL;
14269 }
14270
14271
14272 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14273 PyObject *resultobj;
14274 wxImage *arg1 = (wxImage *) 0 ;
14275 byte arg2 ;
14276 byte arg3 ;
14277 byte arg4 ;
14278 wxBitmap result;
14279 PyObject * obj0 = 0 ;
14280 PyObject * obj1 = 0 ;
14281 PyObject * obj2 = 0 ;
14282 PyObject * obj3 = 0 ;
14283 char *kwnames[] = {
14284 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14285 };
14286
14287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14289 if (SWIG_arg_fail(1)) SWIG_fail;
14290 {
14291 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
14292 if (SWIG_arg_fail(2)) SWIG_fail;
14293 }
14294 {
14295 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
14296 if (SWIG_arg_fail(3)) SWIG_fail;
14297 }
14298 {
14299 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
14300 if (SWIG_arg_fail(4)) SWIG_fail;
14301 }
14302 {
14303 if (!wxPyCheckForApp()) SWIG_fail;
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14306
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 {
14311 wxBitmap * resultptr;
14312 resultptr = new wxBitmap((wxBitmap &)(result));
14313 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14314 }
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj;
14323 wxImage *arg1 = (wxImage *) 0 ;
14324 double arg2 ;
14325 PyObject * obj0 = 0 ;
14326 PyObject * obj1 = 0 ;
14327 char *kwnames[] = {
14328 (char *) "self",(char *) "angle", NULL
14329 };
14330
14331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14333 if (SWIG_arg_fail(1)) SWIG_fail;
14334 {
14335 arg2 = (double)(SWIG_As_double(obj1));
14336 if (SWIG_arg_fail(2)) SWIG_fail;
14337 }
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 (arg1)->RotateHue(arg2);
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 Py_INCREF(Py_None); resultobj = Py_None;
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14353 PyObject *resultobj;
14354 wxImage_RGBValue arg1 ;
14355 wxImage_HSVValue result;
14356 PyObject * obj0 = 0 ;
14357 char *kwnames[] = {
14358 (char *) "rgb", NULL
14359 };
14360
14361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14362 {
14363 wxImage_RGBValue * argp;
14364 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14365 if (SWIG_arg_fail(1)) SWIG_fail;
14366 if (argp == NULL) {
14367 SWIG_null_ref("wxImage_RGBValue");
14368 }
14369 if (SWIG_arg_fail(1)) SWIG_fail;
14370 arg1 = *argp;
14371 }
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 result = wxImage::RGBtoHSV(arg1);
14375
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 {
14380 wxImage_HSVValue * resultptr;
14381 resultptr = new wxImage_HSVValue((wxImage_HSVValue &)(result));
14382 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14383 }
14384 return resultobj;
14385 fail:
14386 return NULL;
14387 }
14388
14389
14390 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14391 PyObject *resultobj;
14392 wxImage_HSVValue arg1 ;
14393 wxImage_RGBValue result;
14394 PyObject * obj0 = 0 ;
14395 char *kwnames[] = {
14396 (char *) "hsv", NULL
14397 };
14398
14399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14400 {
14401 wxImage_HSVValue * argp;
14402 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14403 if (SWIG_arg_fail(1)) SWIG_fail;
14404 if (argp == NULL) {
14405 SWIG_null_ref("wxImage_HSVValue");
14406 }
14407 if (SWIG_arg_fail(1)) SWIG_fail;
14408 arg1 = *argp;
14409 }
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 result = wxImage::HSVtoRGB(arg1);
14413
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 {
14418 wxImage_RGBValue * resultptr;
14419 resultptr = new wxImage_RGBValue((wxImage_RGBValue &)(result));
14420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14421 }
14422 return resultobj;
14423 fail:
14424 return NULL;
14425 }
14426
14427
14428 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14429 PyObject *obj;
14430 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14431 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14432 Py_INCREF(obj);
14433 return Py_BuildValue((char *)"");
14434 }
14435 static int _wrap_NullImage_set(PyObject *) {
14436 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14437 return 1;
14438 }
14439
14440
14441 static PyObject *_wrap_NullImage_get(void) {
14442 PyObject *pyobj;
14443
14444 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14445 return pyobj;
14446 }
14447
14448
14449 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14450 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14451 return 1;
14452 }
14453
14454
14455 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14456 PyObject *pyobj;
14457
14458 {
14459 #if wxUSE_UNICODE
14460 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14461 #else
14462 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14463 #endif
14464 }
14465 return pyobj;
14466 }
14467
14468
14469 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14470 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14471 return 1;
14472 }
14473
14474
14475 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14476 PyObject *pyobj;
14477
14478 {
14479 #if wxUSE_UNICODE
14480 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14481 #else
14482 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14483 #endif
14484 }
14485 return pyobj;
14486 }
14487
14488
14489 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14490 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14491 return 1;
14492 }
14493
14494
14495 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14496 PyObject *pyobj;
14497
14498 {
14499 #if wxUSE_UNICODE
14500 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14501 #else
14502 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14503 #endif
14504 }
14505 return pyobj;
14506 }
14507
14508
14509 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14510 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14511 return 1;
14512 }
14513
14514
14515 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14516 PyObject *pyobj;
14517
14518 {
14519 #if wxUSE_UNICODE
14520 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14521 #else
14522 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14523 #endif
14524 }
14525 return pyobj;
14526 }
14527
14528
14529 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14530 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14531 return 1;
14532 }
14533
14534
14535 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14536 PyObject *pyobj;
14537
14538 {
14539 #if wxUSE_UNICODE
14540 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14541 #else
14542 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14543 #endif
14544 }
14545 return pyobj;
14546 }
14547
14548
14549 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14550 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14551 return 1;
14552 }
14553
14554
14555 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14556 PyObject *pyobj;
14557
14558 {
14559 #if wxUSE_UNICODE
14560 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14561 #else
14562 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14563 #endif
14564 }
14565 return pyobj;
14566 }
14567
14568
14569 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14570 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14571 return 1;
14572 }
14573
14574
14575 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14576 PyObject *pyobj;
14577
14578 {
14579 #if wxUSE_UNICODE
14580 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14581 #else
14582 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14583 #endif
14584 }
14585 return pyobj;
14586 }
14587
14588
14589 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14590 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14591 return 1;
14592 }
14593
14594
14595 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14596 PyObject *pyobj;
14597
14598 {
14599 #if wxUSE_UNICODE
14600 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14601 #else
14602 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14603 #endif
14604 }
14605 return pyobj;
14606 }
14607
14608
14609 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14610 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14611 return 1;
14612 }
14613
14614
14615 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14616 PyObject *pyobj;
14617
14618 {
14619 #if wxUSE_UNICODE
14620 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14621 #else
14622 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14623 #endif
14624 }
14625 return pyobj;
14626 }
14627
14628
14629 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14630 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14631 return 1;
14632 }
14633
14634
14635 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14636 PyObject *pyobj;
14637
14638 {
14639 #if wxUSE_UNICODE
14640 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14641 #else
14642 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14643 #endif
14644 }
14645 return pyobj;
14646 }
14647
14648
14649 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14650 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14651 return 1;
14652 }
14653
14654
14655 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14656 PyObject *pyobj;
14657
14658 {
14659 #if wxUSE_UNICODE
14660 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14661 #else
14662 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14663 #endif
14664 }
14665 return pyobj;
14666 }
14667
14668
14669 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14670 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14671 return 1;
14672 }
14673
14674
14675 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14676 PyObject *pyobj;
14677
14678 {
14679 #if wxUSE_UNICODE
14680 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14681 #else
14682 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14683 #endif
14684 }
14685 return pyobj;
14686 }
14687
14688
14689 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14690 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14691 return 1;
14692 }
14693
14694
14695 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14696 PyObject *pyobj;
14697
14698 {
14699 #if wxUSE_UNICODE
14700 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14701 #else
14702 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14703 #endif
14704 }
14705 return pyobj;
14706 }
14707
14708
14709 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14710 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14711 return 1;
14712 }
14713
14714
14715 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14716 PyObject *pyobj;
14717
14718 {
14719 #if wxUSE_UNICODE
14720 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14721 #else
14722 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14723 #endif
14724 }
14725 return pyobj;
14726 }
14727
14728
14729 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14730 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14731 return 1;
14732 }
14733
14734
14735 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14736 PyObject *pyobj;
14737
14738 {
14739 #if wxUSE_UNICODE
14740 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14741 #else
14742 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14743 #endif
14744 }
14745 return pyobj;
14746 }
14747
14748
14749 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14750 PyObject *resultobj;
14751 wxBMPHandler *result;
14752 char *kwnames[] = {
14753 NULL
14754 };
14755
14756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14757 {
14758 PyThreadState* __tstate = wxPyBeginAllowThreads();
14759 result = (wxBMPHandler *)new wxBMPHandler();
14760
14761 wxPyEndAllowThreads(__tstate);
14762 if (PyErr_Occurred()) SWIG_fail;
14763 }
14764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14765 return resultobj;
14766 fail:
14767 return NULL;
14768 }
14769
14770
14771 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14772 PyObject *obj;
14773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14774 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14775 Py_INCREF(obj);
14776 return Py_BuildValue((char *)"");
14777 }
14778 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14779 PyObject *resultobj;
14780 wxICOHandler *result;
14781 char *kwnames[] = {
14782 NULL
14783 };
14784
14785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14786 {
14787 PyThreadState* __tstate = wxPyBeginAllowThreads();
14788 result = (wxICOHandler *)new wxICOHandler();
14789
14790 wxPyEndAllowThreads(__tstate);
14791 if (PyErr_Occurred()) SWIG_fail;
14792 }
14793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14794 return resultobj;
14795 fail:
14796 return NULL;
14797 }
14798
14799
14800 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14801 PyObject *obj;
14802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14803 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14804 Py_INCREF(obj);
14805 return Py_BuildValue((char *)"");
14806 }
14807 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14808 PyObject *resultobj;
14809 wxCURHandler *result;
14810 char *kwnames[] = {
14811 NULL
14812 };
14813
14814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14815 {
14816 PyThreadState* __tstate = wxPyBeginAllowThreads();
14817 result = (wxCURHandler *)new wxCURHandler();
14818
14819 wxPyEndAllowThreads(__tstate);
14820 if (PyErr_Occurred()) SWIG_fail;
14821 }
14822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14823 return resultobj;
14824 fail:
14825 return NULL;
14826 }
14827
14828
14829 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14830 PyObject *obj;
14831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14832 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14833 Py_INCREF(obj);
14834 return Py_BuildValue((char *)"");
14835 }
14836 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14837 PyObject *resultobj;
14838 wxANIHandler *result;
14839 char *kwnames[] = {
14840 NULL
14841 };
14842
14843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14844 {
14845 PyThreadState* __tstate = wxPyBeginAllowThreads();
14846 result = (wxANIHandler *)new wxANIHandler();
14847
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14852 return resultobj;
14853 fail:
14854 return NULL;
14855 }
14856
14857
14858 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14859 PyObject *obj;
14860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14861 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14862 Py_INCREF(obj);
14863 return Py_BuildValue((char *)"");
14864 }
14865 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14866 PyObject *resultobj;
14867 wxPNGHandler *result;
14868 char *kwnames[] = {
14869 NULL
14870 };
14871
14872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14873 {
14874 PyThreadState* __tstate = wxPyBeginAllowThreads();
14875 result = (wxPNGHandler *)new wxPNGHandler();
14876
14877 wxPyEndAllowThreads(__tstate);
14878 if (PyErr_Occurred()) SWIG_fail;
14879 }
14880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14881 return resultobj;
14882 fail:
14883 return NULL;
14884 }
14885
14886
14887 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14888 PyObject *obj;
14889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14890 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14891 Py_INCREF(obj);
14892 return Py_BuildValue((char *)"");
14893 }
14894 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj;
14896 wxGIFHandler *result;
14897 char *kwnames[] = {
14898 NULL
14899 };
14900
14901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14902 {
14903 PyThreadState* __tstate = wxPyBeginAllowThreads();
14904 result = (wxGIFHandler *)new wxGIFHandler();
14905
14906 wxPyEndAllowThreads(__tstate);
14907 if (PyErr_Occurred()) SWIG_fail;
14908 }
14909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14910 return resultobj;
14911 fail:
14912 return NULL;
14913 }
14914
14915
14916 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14917 PyObject *obj;
14918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14919 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14920 Py_INCREF(obj);
14921 return Py_BuildValue((char *)"");
14922 }
14923 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14924 PyObject *resultobj;
14925 wxPCXHandler *result;
14926 char *kwnames[] = {
14927 NULL
14928 };
14929
14930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14931 {
14932 PyThreadState* __tstate = wxPyBeginAllowThreads();
14933 result = (wxPCXHandler *)new wxPCXHandler();
14934
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14939 return resultobj;
14940 fail:
14941 return NULL;
14942 }
14943
14944
14945 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14946 PyObject *obj;
14947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14948 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14949 Py_INCREF(obj);
14950 return Py_BuildValue((char *)"");
14951 }
14952 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14953 PyObject *resultobj;
14954 wxJPEGHandler *result;
14955 char *kwnames[] = {
14956 NULL
14957 };
14958
14959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14960 {
14961 PyThreadState* __tstate = wxPyBeginAllowThreads();
14962 result = (wxJPEGHandler *)new wxJPEGHandler();
14963
14964 wxPyEndAllowThreads(__tstate);
14965 if (PyErr_Occurred()) SWIG_fail;
14966 }
14967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14968 return resultobj;
14969 fail:
14970 return NULL;
14971 }
14972
14973
14974 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14975 PyObject *obj;
14976 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14977 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14978 Py_INCREF(obj);
14979 return Py_BuildValue((char *)"");
14980 }
14981 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14982 PyObject *resultobj;
14983 wxPNMHandler *result;
14984 char *kwnames[] = {
14985 NULL
14986 };
14987
14988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 result = (wxPNMHandler *)new wxPNMHandler();
14992
14993 wxPyEndAllowThreads(__tstate);
14994 if (PyErr_Occurred()) SWIG_fail;
14995 }
14996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14997 return resultobj;
14998 fail:
14999 return NULL;
15000 }
15001
15002
15003 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15004 PyObject *obj;
15005 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15006 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15007 Py_INCREF(obj);
15008 return Py_BuildValue((char *)"");
15009 }
15010 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15011 PyObject *resultobj;
15012 wxXPMHandler *result;
15013 char *kwnames[] = {
15014 NULL
15015 };
15016
15017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15018 {
15019 PyThreadState* __tstate = wxPyBeginAllowThreads();
15020 result = (wxXPMHandler *)new wxXPMHandler();
15021
15022 wxPyEndAllowThreads(__tstate);
15023 if (PyErr_Occurred()) SWIG_fail;
15024 }
15025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15026 return resultobj;
15027 fail:
15028 return NULL;
15029 }
15030
15031
15032 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15033 PyObject *obj;
15034 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15035 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15036 Py_INCREF(obj);
15037 return Py_BuildValue((char *)"");
15038 }
15039 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15040 PyObject *resultobj;
15041 wxTIFFHandler *result;
15042 char *kwnames[] = {
15043 NULL
15044 };
15045
15046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15047 {
15048 PyThreadState* __tstate = wxPyBeginAllowThreads();
15049 result = (wxTIFFHandler *)new wxTIFFHandler();
15050
15051 wxPyEndAllowThreads(__tstate);
15052 if (PyErr_Occurred()) SWIG_fail;
15053 }
15054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15055 return resultobj;
15056 fail:
15057 return NULL;
15058 }
15059
15060
15061 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15062 PyObject *obj;
15063 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15064 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15065 Py_INCREF(obj);
15066 return Py_BuildValue((char *)"");
15067 }
15068 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15069 PyObject *resultobj;
15070 wxImage *arg1 = 0 ;
15071 wxImage *arg2 = 0 ;
15072 int arg3 = (int) 236 ;
15073 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15074 bool result;
15075 PyObject * obj0 = 0 ;
15076 PyObject * obj1 = 0 ;
15077 PyObject * obj2 = 0 ;
15078 PyObject * obj3 = 0 ;
15079 char *kwnames[] = {
15080 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15081 };
15082
15083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15084 {
15085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15086 if (SWIG_arg_fail(1)) SWIG_fail;
15087 if (arg1 == NULL) {
15088 SWIG_null_ref("wxImage");
15089 }
15090 if (SWIG_arg_fail(1)) SWIG_fail;
15091 }
15092 {
15093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15094 if (SWIG_arg_fail(2)) SWIG_fail;
15095 if (arg2 == NULL) {
15096 SWIG_null_ref("wxImage");
15097 }
15098 if (SWIG_arg_fail(2)) SWIG_fail;
15099 }
15100 if (obj2) {
15101 {
15102 arg3 = (int)(SWIG_As_int(obj2));
15103 if (SWIG_arg_fail(3)) SWIG_fail;
15104 }
15105 }
15106 if (obj3) {
15107 {
15108 arg4 = (int)(SWIG_As_int(obj3));
15109 if (SWIG_arg_fail(4)) SWIG_fail;
15110 }
15111 }
15112 {
15113 PyThreadState* __tstate = wxPyBeginAllowThreads();
15114 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15115
15116 wxPyEndAllowThreads(__tstate);
15117 if (PyErr_Occurred()) SWIG_fail;
15118 }
15119 {
15120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15121 }
15122 return resultobj;
15123 fail:
15124 return NULL;
15125 }
15126
15127
15128 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15129 PyObject *obj;
15130 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15131 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15132 Py_INCREF(obj);
15133 return Py_BuildValue((char *)"");
15134 }
15135 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj;
15137 wxEvtHandler *result;
15138 char *kwnames[] = {
15139 NULL
15140 };
15141
15142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15143 {
15144 PyThreadState* __tstate = wxPyBeginAllowThreads();
15145 result = (wxEvtHandler *)new wxEvtHandler();
15146
15147 wxPyEndAllowThreads(__tstate);
15148 if (PyErr_Occurred()) SWIG_fail;
15149 }
15150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15151 return resultobj;
15152 fail:
15153 return NULL;
15154 }
15155
15156
15157 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15158 PyObject *resultobj;
15159 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15160 wxEvtHandler *result;
15161 PyObject * obj0 = 0 ;
15162 char *kwnames[] = {
15163 (char *) "self", NULL
15164 };
15165
15166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15168 if (SWIG_arg_fail(1)) SWIG_fail;
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15172
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 {
15177 resultobj = wxPyMake_wxObject(result, 0);
15178 }
15179 return resultobj;
15180 fail:
15181 return NULL;
15182 }
15183
15184
15185 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15186 PyObject *resultobj;
15187 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15188 wxEvtHandler *result;
15189 PyObject * obj0 = 0 ;
15190 char *kwnames[] = {
15191 (char *) "self", NULL
15192 };
15193
15194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15196 if (SWIG_arg_fail(1)) SWIG_fail;
15197 {
15198 PyThreadState* __tstate = wxPyBeginAllowThreads();
15199 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15200
15201 wxPyEndAllowThreads(__tstate);
15202 if (PyErr_Occurred()) SWIG_fail;
15203 }
15204 {
15205 resultobj = wxPyMake_wxObject(result, 0);
15206 }
15207 return resultobj;
15208 fail:
15209 return NULL;
15210 }
15211
15212
15213 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15214 PyObject *resultobj;
15215 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15216 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15217 PyObject * obj0 = 0 ;
15218 PyObject * obj1 = 0 ;
15219 char *kwnames[] = {
15220 (char *) "self",(char *) "handler", NULL
15221 };
15222
15223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15225 if (SWIG_arg_fail(1)) SWIG_fail;
15226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15227 if (SWIG_arg_fail(2)) SWIG_fail;
15228 {
15229 PyThreadState* __tstate = wxPyBeginAllowThreads();
15230 (arg1)->SetNextHandler(arg2);
15231
15232 wxPyEndAllowThreads(__tstate);
15233 if (PyErr_Occurred()) SWIG_fail;
15234 }
15235 Py_INCREF(Py_None); resultobj = Py_None;
15236 return resultobj;
15237 fail:
15238 return NULL;
15239 }
15240
15241
15242 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15243 PyObject *resultobj;
15244 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15245 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15246 PyObject * obj0 = 0 ;
15247 PyObject * obj1 = 0 ;
15248 char *kwnames[] = {
15249 (char *) "self",(char *) "handler", NULL
15250 };
15251
15252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15254 if (SWIG_arg_fail(1)) SWIG_fail;
15255 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15256 if (SWIG_arg_fail(2)) SWIG_fail;
15257 {
15258 PyThreadState* __tstate = wxPyBeginAllowThreads();
15259 (arg1)->SetPreviousHandler(arg2);
15260
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 Py_INCREF(Py_None); resultobj = Py_None;
15265 return resultobj;
15266 fail:
15267 return NULL;
15268 }
15269
15270
15271 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15272 PyObject *resultobj;
15273 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15274 bool result;
15275 PyObject * obj0 = 0 ;
15276 char *kwnames[] = {
15277 (char *) "self", NULL
15278 };
15279
15280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15282 if (SWIG_arg_fail(1)) SWIG_fail;
15283 {
15284 PyThreadState* __tstate = wxPyBeginAllowThreads();
15285 result = (bool)(arg1)->GetEvtHandlerEnabled();
15286
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 {
15291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15292 }
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj;
15301 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15302 bool arg2 ;
15303 PyObject * obj0 = 0 ;
15304 PyObject * obj1 = 0 ;
15305 char *kwnames[] = {
15306 (char *) "self",(char *) "enabled", NULL
15307 };
15308
15309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15311 if (SWIG_arg_fail(1)) SWIG_fail;
15312 {
15313 arg2 = (bool)(SWIG_As_bool(obj1));
15314 if (SWIG_arg_fail(2)) SWIG_fail;
15315 }
15316 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 (arg1)->SetEvtHandlerEnabled(arg2);
15319
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 Py_INCREF(Py_None); resultobj = Py_None;
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15331 PyObject *resultobj;
15332 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15333 wxEvent *arg2 = 0 ;
15334 bool result;
15335 PyObject * obj0 = 0 ;
15336 PyObject * obj1 = 0 ;
15337 char *kwnames[] = {
15338 (char *) "self",(char *) "event", NULL
15339 };
15340
15341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15343 if (SWIG_arg_fail(1)) SWIG_fail;
15344 {
15345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15346 if (SWIG_arg_fail(2)) SWIG_fail;
15347 if (arg2 == NULL) {
15348 SWIG_null_ref("wxEvent");
15349 }
15350 if (SWIG_arg_fail(2)) SWIG_fail;
15351 }
15352 {
15353 PyThreadState* __tstate = wxPyBeginAllowThreads();
15354 result = (bool)(arg1)->ProcessEvent(*arg2);
15355
15356 wxPyEndAllowThreads(__tstate);
15357 if (PyErr_Occurred()) SWIG_fail;
15358 }
15359 {
15360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15361 }
15362 return resultobj;
15363 fail:
15364 return NULL;
15365 }
15366
15367
15368 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15369 PyObject *resultobj;
15370 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15371 wxEvent *arg2 = 0 ;
15372 PyObject * obj0 = 0 ;
15373 PyObject * obj1 = 0 ;
15374 char *kwnames[] = {
15375 (char *) "self",(char *) "event", NULL
15376 };
15377
15378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15380 if (SWIG_arg_fail(1)) SWIG_fail;
15381 {
15382 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15383 if (SWIG_arg_fail(2)) SWIG_fail;
15384 if (arg2 == NULL) {
15385 SWIG_null_ref("wxEvent");
15386 }
15387 if (SWIG_arg_fail(2)) SWIG_fail;
15388 }
15389 {
15390 PyThreadState* __tstate = wxPyBeginAllowThreads();
15391 (arg1)->AddPendingEvent(*arg2);
15392
15393 wxPyEndAllowThreads(__tstate);
15394 if (PyErr_Occurred()) SWIG_fail;
15395 }
15396 Py_INCREF(Py_None); resultobj = Py_None;
15397 return resultobj;
15398 fail:
15399 return NULL;
15400 }
15401
15402
15403 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15404 PyObject *resultobj;
15405 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15406 PyObject * obj0 = 0 ;
15407 char *kwnames[] = {
15408 (char *) "self", NULL
15409 };
15410
15411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15413 if (SWIG_arg_fail(1)) SWIG_fail;
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 (arg1)->ProcessPendingEvents();
15417
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 Py_INCREF(Py_None); resultobj = Py_None;
15422 return resultobj;
15423 fail:
15424 return NULL;
15425 }
15426
15427
15428 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15429 PyObject *resultobj;
15430 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15431 int arg2 ;
15432 int arg3 ;
15433 int arg4 ;
15434 PyObject *arg5 = (PyObject *) 0 ;
15435 PyObject * obj0 = 0 ;
15436 PyObject * obj1 = 0 ;
15437 PyObject * obj2 = 0 ;
15438 PyObject * obj3 = 0 ;
15439 PyObject * obj4 = 0 ;
15440 char *kwnames[] = {
15441 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15442 };
15443
15444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15446 if (SWIG_arg_fail(1)) SWIG_fail;
15447 {
15448 arg2 = (int)(SWIG_As_int(obj1));
15449 if (SWIG_arg_fail(2)) SWIG_fail;
15450 }
15451 {
15452 arg3 = (int)(SWIG_As_int(obj2));
15453 if (SWIG_arg_fail(3)) SWIG_fail;
15454 }
15455 {
15456 arg4 = (int)(SWIG_As_int(obj3));
15457 if (SWIG_arg_fail(4)) SWIG_fail;
15458 }
15459 arg5 = obj4;
15460 {
15461 PyThreadState* __tstate = wxPyBeginAllowThreads();
15462 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15463
15464 wxPyEndAllowThreads(__tstate);
15465 if (PyErr_Occurred()) SWIG_fail;
15466 }
15467 Py_INCREF(Py_None); resultobj = Py_None;
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15475 PyObject *resultobj;
15476 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15477 int arg2 ;
15478 int arg3 = (int) -1 ;
15479 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15480 bool result;
15481 PyObject * obj0 = 0 ;
15482 PyObject * obj1 = 0 ;
15483 PyObject * obj2 = 0 ;
15484 PyObject * obj3 = 0 ;
15485 char *kwnames[] = {
15486 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15487 };
15488
15489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15491 if (SWIG_arg_fail(1)) SWIG_fail;
15492 {
15493 arg2 = (int)(SWIG_As_int(obj1));
15494 if (SWIG_arg_fail(2)) SWIG_fail;
15495 }
15496 if (obj2) {
15497 {
15498 arg3 = (int)(SWIG_As_int(obj2));
15499 if (SWIG_arg_fail(3)) SWIG_fail;
15500 }
15501 }
15502 if (obj3) {
15503 {
15504 arg4 = (wxEventType)(SWIG_As_int(obj3));
15505 if (SWIG_arg_fail(4)) SWIG_fail;
15506 }
15507 }
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15511
15512 wxPyEndAllowThreads(__tstate);
15513 if (PyErr_Occurred()) SWIG_fail;
15514 }
15515 {
15516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15517 }
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15525 PyObject *resultobj;
15526 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15527 PyObject *arg2 = (PyObject *) 0 ;
15528 bool arg3 = (bool) true ;
15529 PyObject * obj0 = 0 ;
15530 PyObject * obj1 = 0 ;
15531 PyObject * obj2 = 0 ;
15532 char *kwnames[] = {
15533 (char *) "self",(char *) "_self",(char *) "incref", NULL
15534 };
15535
15536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15538 if (SWIG_arg_fail(1)) SWIG_fail;
15539 arg2 = obj1;
15540 if (obj2) {
15541 {
15542 arg3 = (bool)(SWIG_As_bool(obj2));
15543 if (SWIG_arg_fail(3)) SWIG_fail;
15544 }
15545 }
15546 {
15547 PyThreadState* __tstate = wxPyBeginAllowThreads();
15548 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15549
15550 wxPyEndAllowThreads(__tstate);
15551 if (PyErr_Occurred()) SWIG_fail;
15552 }
15553 Py_INCREF(Py_None); resultobj = Py_None;
15554 return resultobj;
15555 fail:
15556 return NULL;
15557 }
15558
15559
15560 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15561 PyObject *obj;
15562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15563 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15564 Py_INCREF(obj);
15565 return Py_BuildValue((char *)"");
15566 }
15567 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15568 PyObject *resultobj;
15569 wxEventType result;
15570 char *kwnames[] = {
15571 NULL
15572 };
15573
15574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 result = (wxEventType)wxNewEventType();
15578
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 {
15583 resultobj = SWIG_From_int((int)(result));
15584 }
15585 return resultobj;
15586 fail:
15587 return NULL;
15588 }
15589
15590
15591 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15592 PyObject *resultobj;
15593 wxEvent *arg1 = (wxEvent *) 0 ;
15594 PyObject * obj0 = 0 ;
15595 char *kwnames[] = {
15596 (char *) "self", NULL
15597 };
15598
15599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15601 if (SWIG_arg_fail(1)) SWIG_fail;
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 delete arg1;
15605
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 Py_INCREF(Py_None); resultobj = Py_None;
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj;
15618 wxEvent *arg1 = (wxEvent *) 0 ;
15619 wxEventType arg2 ;
15620 PyObject * obj0 = 0 ;
15621 PyObject * obj1 = 0 ;
15622 char *kwnames[] = {
15623 (char *) "self",(char *) "typ", NULL
15624 };
15625
15626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15628 if (SWIG_arg_fail(1)) SWIG_fail;
15629 {
15630 arg2 = (wxEventType)(SWIG_As_int(obj1));
15631 if (SWIG_arg_fail(2)) SWIG_fail;
15632 }
15633 {
15634 PyThreadState* __tstate = wxPyBeginAllowThreads();
15635 (arg1)->SetEventType(arg2);
15636
15637 wxPyEndAllowThreads(__tstate);
15638 if (PyErr_Occurred()) SWIG_fail;
15639 }
15640 Py_INCREF(Py_None); resultobj = Py_None;
15641 return resultobj;
15642 fail:
15643 return NULL;
15644 }
15645
15646
15647 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15648 PyObject *resultobj;
15649 wxEvent *arg1 = (wxEvent *) 0 ;
15650 wxEventType result;
15651 PyObject * obj0 = 0 ;
15652 char *kwnames[] = {
15653 (char *) "self", NULL
15654 };
15655
15656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15658 if (SWIG_arg_fail(1)) SWIG_fail;
15659 {
15660 PyThreadState* __tstate = wxPyBeginAllowThreads();
15661 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15662
15663 wxPyEndAllowThreads(__tstate);
15664 if (PyErr_Occurred()) SWIG_fail;
15665 }
15666 {
15667 resultobj = SWIG_From_int((int)(result));
15668 }
15669 return resultobj;
15670 fail:
15671 return NULL;
15672 }
15673
15674
15675 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15676 PyObject *resultobj;
15677 wxEvent *arg1 = (wxEvent *) 0 ;
15678 wxObject *result;
15679 PyObject * obj0 = 0 ;
15680 char *kwnames[] = {
15681 (char *) "self", NULL
15682 };
15683
15684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15686 if (SWIG_arg_fail(1)) SWIG_fail;
15687 {
15688 PyThreadState* __tstate = wxPyBeginAllowThreads();
15689 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15690
15691 wxPyEndAllowThreads(__tstate);
15692 if (PyErr_Occurred()) SWIG_fail;
15693 }
15694 {
15695 resultobj = wxPyMake_wxObject(result, 0);
15696 }
15697 return resultobj;
15698 fail:
15699 return NULL;
15700 }
15701
15702
15703 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15704 PyObject *resultobj;
15705 wxEvent *arg1 = (wxEvent *) 0 ;
15706 wxObject *arg2 = (wxObject *) 0 ;
15707 PyObject * obj0 = 0 ;
15708 PyObject * obj1 = 0 ;
15709 char *kwnames[] = {
15710 (char *) "self",(char *) "obj", NULL
15711 };
15712
15713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15715 if (SWIG_arg_fail(1)) SWIG_fail;
15716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15717 if (SWIG_arg_fail(2)) SWIG_fail;
15718 {
15719 PyThreadState* __tstate = wxPyBeginAllowThreads();
15720 (arg1)->SetEventObject(arg2);
15721
15722 wxPyEndAllowThreads(__tstate);
15723 if (PyErr_Occurred()) SWIG_fail;
15724 }
15725 Py_INCREF(Py_None); resultobj = Py_None;
15726 return resultobj;
15727 fail:
15728 return NULL;
15729 }
15730
15731
15732 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15733 PyObject *resultobj;
15734 wxEvent *arg1 = (wxEvent *) 0 ;
15735 long result;
15736 PyObject * obj0 = 0 ;
15737 char *kwnames[] = {
15738 (char *) "self", NULL
15739 };
15740
15741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15743 if (SWIG_arg_fail(1)) SWIG_fail;
15744 {
15745 PyThreadState* __tstate = wxPyBeginAllowThreads();
15746 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15747
15748 wxPyEndAllowThreads(__tstate);
15749 if (PyErr_Occurred()) SWIG_fail;
15750 }
15751 {
15752 resultobj = SWIG_From_long((long)(result));
15753 }
15754 return resultobj;
15755 fail:
15756 return NULL;
15757 }
15758
15759
15760 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15761 PyObject *resultobj;
15762 wxEvent *arg1 = (wxEvent *) 0 ;
15763 long arg2 = (long) 0 ;
15764 PyObject * obj0 = 0 ;
15765 PyObject * obj1 = 0 ;
15766 char *kwnames[] = {
15767 (char *) "self",(char *) "ts", NULL
15768 };
15769
15770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15772 if (SWIG_arg_fail(1)) SWIG_fail;
15773 if (obj1) {
15774 {
15775 arg2 = (long)(SWIG_As_long(obj1));
15776 if (SWIG_arg_fail(2)) SWIG_fail;
15777 }
15778 }
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 (arg1)->SetTimestamp(arg2);
15782
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 Py_INCREF(Py_None); resultobj = Py_None;
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15794 PyObject *resultobj;
15795 wxEvent *arg1 = (wxEvent *) 0 ;
15796 int result;
15797 PyObject * obj0 = 0 ;
15798 char *kwnames[] = {
15799 (char *) "self", NULL
15800 };
15801
15802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15804 if (SWIG_arg_fail(1)) SWIG_fail;
15805 {
15806 PyThreadState* __tstate = wxPyBeginAllowThreads();
15807 result = (int)((wxEvent const *)arg1)->GetId();
15808
15809 wxPyEndAllowThreads(__tstate);
15810 if (PyErr_Occurred()) SWIG_fail;
15811 }
15812 {
15813 resultobj = SWIG_From_int((int)(result));
15814 }
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15822 PyObject *resultobj;
15823 wxEvent *arg1 = (wxEvent *) 0 ;
15824 int arg2 ;
15825 PyObject * obj0 = 0 ;
15826 PyObject * obj1 = 0 ;
15827 char *kwnames[] = {
15828 (char *) "self",(char *) "Id", NULL
15829 };
15830
15831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15833 if (SWIG_arg_fail(1)) SWIG_fail;
15834 {
15835 arg2 = (int)(SWIG_As_int(obj1));
15836 if (SWIG_arg_fail(2)) SWIG_fail;
15837 }
15838 {
15839 PyThreadState* __tstate = wxPyBeginAllowThreads();
15840 (arg1)->SetId(arg2);
15841
15842 wxPyEndAllowThreads(__tstate);
15843 if (PyErr_Occurred()) SWIG_fail;
15844 }
15845 Py_INCREF(Py_None); resultobj = Py_None;
15846 return resultobj;
15847 fail:
15848 return NULL;
15849 }
15850
15851
15852 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15853 PyObject *resultobj;
15854 wxEvent *arg1 = (wxEvent *) 0 ;
15855 bool result;
15856 PyObject * obj0 = 0 ;
15857 char *kwnames[] = {
15858 (char *) "self", NULL
15859 };
15860
15861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15863 if (SWIG_arg_fail(1)) SWIG_fail;
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15867
15868 wxPyEndAllowThreads(__tstate);
15869 if (PyErr_Occurred()) SWIG_fail;
15870 }
15871 {
15872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15873 }
15874 return resultobj;
15875 fail:
15876 return NULL;
15877 }
15878
15879
15880 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15881 PyObject *resultobj;
15882 wxEvent *arg1 = (wxEvent *) 0 ;
15883 bool arg2 = (bool) true ;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 char *kwnames[] = {
15887 (char *) "self",(char *) "skip", NULL
15888 };
15889
15890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15892 if (SWIG_arg_fail(1)) SWIG_fail;
15893 if (obj1) {
15894 {
15895 arg2 = (bool)(SWIG_As_bool(obj1));
15896 if (SWIG_arg_fail(2)) SWIG_fail;
15897 }
15898 }
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 (arg1)->Skip(arg2);
15902
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 Py_INCREF(Py_None); resultobj = Py_None;
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj;
15915 wxEvent *arg1 = (wxEvent *) 0 ;
15916 bool result;
15917 PyObject * obj0 = 0 ;
15918 char *kwnames[] = {
15919 (char *) "self", NULL
15920 };
15921
15922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15924 if (SWIG_arg_fail(1)) SWIG_fail;
15925 {
15926 PyThreadState* __tstate = wxPyBeginAllowThreads();
15927 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15928
15929 wxPyEndAllowThreads(__tstate);
15930 if (PyErr_Occurred()) SWIG_fail;
15931 }
15932 {
15933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15934 }
15935 return resultobj;
15936 fail:
15937 return NULL;
15938 }
15939
15940
15941 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15942 PyObject *resultobj;
15943 wxEvent *arg1 = (wxEvent *) 0 ;
15944 bool result;
15945 PyObject * obj0 = 0 ;
15946 char *kwnames[] = {
15947 (char *) "self", NULL
15948 };
15949
15950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15952 if (SWIG_arg_fail(1)) SWIG_fail;
15953 {
15954 PyThreadState* __tstate = wxPyBeginAllowThreads();
15955 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15956
15957 wxPyEndAllowThreads(__tstate);
15958 if (PyErr_Occurred()) SWIG_fail;
15959 }
15960 {
15961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15962 }
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15970 PyObject *resultobj;
15971 wxEvent *arg1 = (wxEvent *) 0 ;
15972 int result;
15973 PyObject * obj0 = 0 ;
15974 char *kwnames[] = {
15975 (char *) "self", NULL
15976 };
15977
15978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15980 if (SWIG_arg_fail(1)) SWIG_fail;
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 result = (int)(arg1)->StopPropagation();
15984
15985 wxPyEndAllowThreads(__tstate);
15986 if (PyErr_Occurred()) SWIG_fail;
15987 }
15988 {
15989 resultobj = SWIG_From_int((int)(result));
15990 }
15991 return resultobj;
15992 fail:
15993 return NULL;
15994 }
15995
15996
15997 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15998 PyObject *resultobj;
15999 wxEvent *arg1 = (wxEvent *) 0 ;
16000 int arg2 ;
16001 PyObject * obj0 = 0 ;
16002 PyObject * obj1 = 0 ;
16003 char *kwnames[] = {
16004 (char *) "self",(char *) "propagationLevel", NULL
16005 };
16006
16007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16009 if (SWIG_arg_fail(1)) SWIG_fail;
16010 {
16011 arg2 = (int)(SWIG_As_int(obj1));
16012 if (SWIG_arg_fail(2)) SWIG_fail;
16013 }
16014 {
16015 PyThreadState* __tstate = wxPyBeginAllowThreads();
16016 (arg1)->ResumePropagation(arg2);
16017
16018 wxPyEndAllowThreads(__tstate);
16019 if (PyErr_Occurred()) SWIG_fail;
16020 }
16021 Py_INCREF(Py_None); resultobj = Py_None;
16022 return resultobj;
16023 fail:
16024 return NULL;
16025 }
16026
16027
16028 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16029 PyObject *resultobj;
16030 wxEvent *arg1 = (wxEvent *) 0 ;
16031 wxEvent *result;
16032 PyObject * obj0 = 0 ;
16033 char *kwnames[] = {
16034 (char *) "self", NULL
16035 };
16036
16037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16039 if (SWIG_arg_fail(1)) SWIG_fail;
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 result = (wxEvent *)(arg1)->Clone();
16043
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16055 PyObject *obj;
16056 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16057 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16058 Py_INCREF(obj);
16059 return Py_BuildValue((char *)"");
16060 }
16061 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16062 PyObject *resultobj;
16063 wxEvent *arg1 = 0 ;
16064 wxPropagationDisabler *result;
16065 PyObject * obj0 = 0 ;
16066 char *kwnames[] = {
16067 (char *) "event", NULL
16068 };
16069
16070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16071 {
16072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16073 if (SWIG_arg_fail(1)) SWIG_fail;
16074 if (arg1 == NULL) {
16075 SWIG_null_ref("wxEvent");
16076 }
16077 if (SWIG_arg_fail(1)) SWIG_fail;
16078 }
16079 {
16080 PyThreadState* __tstate = wxPyBeginAllowThreads();
16081 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16082
16083 wxPyEndAllowThreads(__tstate);
16084 if (PyErr_Occurred()) SWIG_fail;
16085 }
16086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16087 return resultobj;
16088 fail:
16089 return NULL;
16090 }
16091
16092
16093 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16094 PyObject *resultobj;
16095 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16096 PyObject * obj0 = 0 ;
16097 char *kwnames[] = {
16098 (char *) "self", NULL
16099 };
16100
16101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16103 if (SWIG_arg_fail(1)) SWIG_fail;
16104 {
16105 PyThreadState* __tstate = wxPyBeginAllowThreads();
16106 delete arg1;
16107
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 Py_INCREF(Py_None); resultobj = Py_None;
16112 return resultobj;
16113 fail:
16114 return NULL;
16115 }
16116
16117
16118 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16119 PyObject *obj;
16120 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16121 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16122 Py_INCREF(obj);
16123 return Py_BuildValue((char *)"");
16124 }
16125 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16126 PyObject *resultobj;
16127 wxEvent *arg1 = 0 ;
16128 wxPropagateOnce *result;
16129 PyObject * obj0 = 0 ;
16130 char *kwnames[] = {
16131 (char *) "event", NULL
16132 };
16133
16134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16135 {
16136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16137 if (SWIG_arg_fail(1)) SWIG_fail;
16138 if (arg1 == NULL) {
16139 SWIG_null_ref("wxEvent");
16140 }
16141 if (SWIG_arg_fail(1)) SWIG_fail;
16142 }
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16146
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16158 PyObject *resultobj;
16159 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16160 PyObject * obj0 = 0 ;
16161 char *kwnames[] = {
16162 (char *) "self", NULL
16163 };
16164
16165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16167 if (SWIG_arg_fail(1)) SWIG_fail;
16168 {
16169 PyThreadState* __tstate = wxPyBeginAllowThreads();
16170 delete arg1;
16171
16172 wxPyEndAllowThreads(__tstate);
16173 if (PyErr_Occurred()) SWIG_fail;
16174 }
16175 Py_INCREF(Py_None); resultobj = Py_None;
16176 return resultobj;
16177 fail:
16178 return NULL;
16179 }
16180
16181
16182 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16183 PyObject *obj;
16184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16185 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16186 Py_INCREF(obj);
16187 return Py_BuildValue((char *)"");
16188 }
16189 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16190 PyObject *resultobj;
16191 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16192 int arg2 = (int) 0 ;
16193 wxCommandEvent *result;
16194 PyObject * obj0 = 0 ;
16195 PyObject * obj1 = 0 ;
16196 char *kwnames[] = {
16197 (char *) "commandType",(char *) "winid", NULL
16198 };
16199
16200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16201 if (obj0) {
16202 {
16203 arg1 = (wxEventType)(SWIG_As_int(obj0));
16204 if (SWIG_arg_fail(1)) SWIG_fail;
16205 }
16206 }
16207 if (obj1) {
16208 {
16209 arg2 = (int)(SWIG_As_int(obj1));
16210 if (SWIG_arg_fail(2)) SWIG_fail;
16211 }
16212 }
16213 {
16214 PyThreadState* __tstate = wxPyBeginAllowThreads();
16215 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16216
16217 wxPyEndAllowThreads(__tstate);
16218 if (PyErr_Occurred()) SWIG_fail;
16219 }
16220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16221 return resultobj;
16222 fail:
16223 return NULL;
16224 }
16225
16226
16227 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16228 PyObject *resultobj;
16229 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16230 int result;
16231 PyObject * obj0 = 0 ;
16232 char *kwnames[] = {
16233 (char *) "self", NULL
16234 };
16235
16236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16238 if (SWIG_arg_fail(1)) SWIG_fail;
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16242
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 {
16247 resultobj = SWIG_From_int((int)(result));
16248 }
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj;
16257 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16258 wxString *arg2 = 0 ;
16259 bool temp2 = false ;
16260 PyObject * obj0 = 0 ;
16261 PyObject * obj1 = 0 ;
16262 char *kwnames[] = {
16263 (char *) "self",(char *) "s", NULL
16264 };
16265
16266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16268 if (SWIG_arg_fail(1)) SWIG_fail;
16269 {
16270 arg2 = wxString_in_helper(obj1);
16271 if (arg2 == NULL) SWIG_fail;
16272 temp2 = true;
16273 }
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 (arg1)->SetString((wxString const &)*arg2);
16277
16278 wxPyEndAllowThreads(__tstate);
16279 if (PyErr_Occurred()) SWIG_fail;
16280 }
16281 Py_INCREF(Py_None); resultobj = Py_None;
16282 {
16283 if (temp2)
16284 delete arg2;
16285 }
16286 return resultobj;
16287 fail:
16288 {
16289 if (temp2)
16290 delete arg2;
16291 }
16292 return NULL;
16293 }
16294
16295
16296 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16297 PyObject *resultobj;
16298 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16299 wxString result;
16300 PyObject * obj0 = 0 ;
16301 char *kwnames[] = {
16302 (char *) "self", NULL
16303 };
16304
16305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16307 if (SWIG_arg_fail(1)) SWIG_fail;
16308 {
16309 PyThreadState* __tstate = wxPyBeginAllowThreads();
16310 result = ((wxCommandEvent const *)arg1)->GetString();
16311
16312 wxPyEndAllowThreads(__tstate);
16313 if (PyErr_Occurred()) SWIG_fail;
16314 }
16315 {
16316 #if wxUSE_UNICODE
16317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16318 #else
16319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16320 #endif
16321 }
16322 return resultobj;
16323 fail:
16324 return NULL;
16325 }
16326
16327
16328 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16329 PyObject *resultobj;
16330 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16331 bool result;
16332 PyObject * obj0 = 0 ;
16333 char *kwnames[] = {
16334 (char *) "self", NULL
16335 };
16336
16337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16339 if (SWIG_arg_fail(1)) SWIG_fail;
16340 {
16341 PyThreadState* __tstate = wxPyBeginAllowThreads();
16342 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16343
16344 wxPyEndAllowThreads(__tstate);
16345 if (PyErr_Occurred()) SWIG_fail;
16346 }
16347 {
16348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16349 }
16350 return resultobj;
16351 fail:
16352 return NULL;
16353 }
16354
16355
16356 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16357 PyObject *resultobj;
16358 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16359 bool result;
16360 PyObject * obj0 = 0 ;
16361 char *kwnames[] = {
16362 (char *) "self", NULL
16363 };
16364
16365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16367 if (SWIG_arg_fail(1)) SWIG_fail;
16368 {
16369 PyThreadState* __tstate = wxPyBeginAllowThreads();
16370 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16371
16372 wxPyEndAllowThreads(__tstate);
16373 if (PyErr_Occurred()) SWIG_fail;
16374 }
16375 {
16376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16377 }
16378 return resultobj;
16379 fail:
16380 return NULL;
16381 }
16382
16383
16384 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16385 PyObject *resultobj;
16386 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16387 long arg2 ;
16388 PyObject * obj0 = 0 ;
16389 PyObject * obj1 = 0 ;
16390 char *kwnames[] = {
16391 (char *) "self",(char *) "extraLong", NULL
16392 };
16393
16394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16396 if (SWIG_arg_fail(1)) SWIG_fail;
16397 {
16398 arg2 = (long)(SWIG_As_long(obj1));
16399 if (SWIG_arg_fail(2)) SWIG_fail;
16400 }
16401 {
16402 PyThreadState* __tstate = wxPyBeginAllowThreads();
16403 (arg1)->SetExtraLong(arg2);
16404
16405 wxPyEndAllowThreads(__tstate);
16406 if (PyErr_Occurred()) SWIG_fail;
16407 }
16408 Py_INCREF(Py_None); resultobj = Py_None;
16409 return resultobj;
16410 fail:
16411 return NULL;
16412 }
16413
16414
16415 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16416 PyObject *resultobj;
16417 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16418 long result;
16419 PyObject * obj0 = 0 ;
16420 char *kwnames[] = {
16421 (char *) "self", NULL
16422 };
16423
16424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16426 if (SWIG_arg_fail(1)) SWIG_fail;
16427 {
16428 PyThreadState* __tstate = wxPyBeginAllowThreads();
16429 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16430
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 {
16435 resultobj = SWIG_From_long((long)(result));
16436 }
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj;
16445 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16446 int arg2 ;
16447 PyObject * obj0 = 0 ;
16448 PyObject * obj1 = 0 ;
16449 char *kwnames[] = {
16450 (char *) "self",(char *) "i", NULL
16451 };
16452
16453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16455 if (SWIG_arg_fail(1)) SWIG_fail;
16456 {
16457 arg2 = (int)(SWIG_As_int(obj1));
16458 if (SWIG_arg_fail(2)) SWIG_fail;
16459 }
16460 {
16461 PyThreadState* __tstate = wxPyBeginAllowThreads();
16462 (arg1)->SetInt(arg2);
16463
16464 wxPyEndAllowThreads(__tstate);
16465 if (PyErr_Occurred()) SWIG_fail;
16466 }
16467 Py_INCREF(Py_None); resultobj = Py_None;
16468 return resultobj;
16469 fail:
16470 return NULL;
16471 }
16472
16473
16474 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16475 PyObject *resultobj;
16476 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16477 long result;
16478 PyObject * obj0 = 0 ;
16479 char *kwnames[] = {
16480 (char *) "self", NULL
16481 };
16482
16483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16485 if (SWIG_arg_fail(1)) SWIG_fail;
16486 {
16487 PyThreadState* __tstate = wxPyBeginAllowThreads();
16488 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16489
16490 wxPyEndAllowThreads(__tstate);
16491 if (PyErr_Occurred()) SWIG_fail;
16492 }
16493 {
16494 resultobj = SWIG_From_long((long)(result));
16495 }
16496 return resultobj;
16497 fail:
16498 return NULL;
16499 }
16500
16501
16502 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16503 PyObject *resultobj;
16504 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16505 wxEvent *result;
16506 PyObject * obj0 = 0 ;
16507 char *kwnames[] = {
16508 (char *) "self", NULL
16509 };
16510
16511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16513 if (SWIG_arg_fail(1)) SWIG_fail;
16514 {
16515 PyThreadState* __tstate = wxPyBeginAllowThreads();
16516 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16517
16518 wxPyEndAllowThreads(__tstate);
16519 if (PyErr_Occurred()) SWIG_fail;
16520 }
16521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16522 return resultobj;
16523 fail:
16524 return NULL;
16525 }
16526
16527
16528 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16529 PyObject *obj;
16530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16531 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16532 Py_INCREF(obj);
16533 return Py_BuildValue((char *)"");
16534 }
16535 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj;
16537 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16538 int arg2 = (int) 0 ;
16539 wxNotifyEvent *result;
16540 PyObject * obj0 = 0 ;
16541 PyObject * obj1 = 0 ;
16542 char *kwnames[] = {
16543 (char *) "commandType",(char *) "winid", NULL
16544 };
16545
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16547 if (obj0) {
16548 {
16549 arg1 = (wxEventType)(SWIG_As_int(obj0));
16550 if (SWIG_arg_fail(1)) SWIG_fail;
16551 }
16552 }
16553 if (obj1) {
16554 {
16555 arg2 = (int)(SWIG_As_int(obj1));
16556 if (SWIG_arg_fail(2)) SWIG_fail;
16557 }
16558 }
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16562
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj;
16575 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16576 PyObject * obj0 = 0 ;
16577 char *kwnames[] = {
16578 (char *) "self", NULL
16579 };
16580
16581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16583 if (SWIG_arg_fail(1)) SWIG_fail;
16584 {
16585 PyThreadState* __tstate = wxPyBeginAllowThreads();
16586 (arg1)->Veto();
16587
16588 wxPyEndAllowThreads(__tstate);
16589 if (PyErr_Occurred()) SWIG_fail;
16590 }
16591 Py_INCREF(Py_None); resultobj = Py_None;
16592 return resultobj;
16593 fail:
16594 return NULL;
16595 }
16596
16597
16598 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16599 PyObject *resultobj;
16600 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16601 PyObject * obj0 = 0 ;
16602 char *kwnames[] = {
16603 (char *) "self", NULL
16604 };
16605
16606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16608 if (SWIG_arg_fail(1)) SWIG_fail;
16609 {
16610 PyThreadState* __tstate = wxPyBeginAllowThreads();
16611 (arg1)->Allow();
16612
16613 wxPyEndAllowThreads(__tstate);
16614 if (PyErr_Occurred()) SWIG_fail;
16615 }
16616 Py_INCREF(Py_None); resultobj = Py_None;
16617 return resultobj;
16618 fail:
16619 return NULL;
16620 }
16621
16622
16623 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16624 PyObject *resultobj;
16625 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16626 bool result;
16627 PyObject * obj0 = 0 ;
16628 char *kwnames[] = {
16629 (char *) "self", NULL
16630 };
16631
16632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16634 if (SWIG_arg_fail(1)) SWIG_fail;
16635 {
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 result = (bool)(arg1)->IsAllowed();
16638
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 {
16643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16644 }
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16652 PyObject *obj;
16653 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16654 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16655 Py_INCREF(obj);
16656 return Py_BuildValue((char *)"");
16657 }
16658 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16659 PyObject *resultobj;
16660 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16661 int arg2 = (int) 0 ;
16662 int arg3 = (int) 0 ;
16663 int arg4 = (int) 0 ;
16664 wxScrollEvent *result;
16665 PyObject * obj0 = 0 ;
16666 PyObject * obj1 = 0 ;
16667 PyObject * obj2 = 0 ;
16668 PyObject * obj3 = 0 ;
16669 char *kwnames[] = {
16670 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16671 };
16672
16673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16674 if (obj0) {
16675 {
16676 arg1 = (wxEventType)(SWIG_As_int(obj0));
16677 if (SWIG_arg_fail(1)) SWIG_fail;
16678 }
16679 }
16680 if (obj1) {
16681 {
16682 arg2 = (int)(SWIG_As_int(obj1));
16683 if (SWIG_arg_fail(2)) SWIG_fail;
16684 }
16685 }
16686 if (obj2) {
16687 {
16688 arg3 = (int)(SWIG_As_int(obj2));
16689 if (SWIG_arg_fail(3)) SWIG_fail;
16690 }
16691 }
16692 if (obj3) {
16693 {
16694 arg4 = (int)(SWIG_As_int(obj3));
16695 if (SWIG_arg_fail(4)) SWIG_fail;
16696 }
16697 }
16698 {
16699 PyThreadState* __tstate = wxPyBeginAllowThreads();
16700 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16701
16702 wxPyEndAllowThreads(__tstate);
16703 if (PyErr_Occurred()) SWIG_fail;
16704 }
16705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16706 return resultobj;
16707 fail:
16708 return NULL;
16709 }
16710
16711
16712 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16713 PyObject *resultobj;
16714 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16715 int result;
16716 PyObject * obj0 = 0 ;
16717 char *kwnames[] = {
16718 (char *) "self", NULL
16719 };
16720
16721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16723 if (SWIG_arg_fail(1)) SWIG_fail;
16724 {
16725 PyThreadState* __tstate = wxPyBeginAllowThreads();
16726 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16727
16728 wxPyEndAllowThreads(__tstate);
16729 if (PyErr_Occurred()) SWIG_fail;
16730 }
16731 {
16732 resultobj = SWIG_From_int((int)(result));
16733 }
16734 return resultobj;
16735 fail:
16736 return NULL;
16737 }
16738
16739
16740 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16741 PyObject *resultobj;
16742 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16743 int result;
16744 PyObject * obj0 = 0 ;
16745 char *kwnames[] = {
16746 (char *) "self", NULL
16747 };
16748
16749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16751 if (SWIG_arg_fail(1)) SWIG_fail;
16752 {
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16755
16756 wxPyEndAllowThreads(__tstate);
16757 if (PyErr_Occurred()) SWIG_fail;
16758 }
16759 {
16760 resultobj = SWIG_From_int((int)(result));
16761 }
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16769 PyObject *resultobj;
16770 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16771 int arg2 ;
16772 PyObject * obj0 = 0 ;
16773 PyObject * obj1 = 0 ;
16774 char *kwnames[] = {
16775 (char *) "self",(char *) "orient", NULL
16776 };
16777
16778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16780 if (SWIG_arg_fail(1)) SWIG_fail;
16781 {
16782 arg2 = (int)(SWIG_As_int(obj1));
16783 if (SWIG_arg_fail(2)) SWIG_fail;
16784 }
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 (arg1)->SetOrientation(arg2);
16788
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 Py_INCREF(Py_None); resultobj = Py_None;
16793 return resultobj;
16794 fail:
16795 return NULL;
16796 }
16797
16798
16799 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16800 PyObject *resultobj;
16801 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16802 int arg2 ;
16803 PyObject * obj0 = 0 ;
16804 PyObject * obj1 = 0 ;
16805 char *kwnames[] = {
16806 (char *) "self",(char *) "pos", NULL
16807 };
16808
16809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16811 if (SWIG_arg_fail(1)) SWIG_fail;
16812 {
16813 arg2 = (int)(SWIG_As_int(obj1));
16814 if (SWIG_arg_fail(2)) SWIG_fail;
16815 }
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 (arg1)->SetPosition(arg2);
16819
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 Py_INCREF(Py_None); resultobj = Py_None;
16824 return resultobj;
16825 fail:
16826 return NULL;
16827 }
16828
16829
16830 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16831 PyObject *obj;
16832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16833 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16834 Py_INCREF(obj);
16835 return Py_BuildValue((char *)"");
16836 }
16837 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj;
16839 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16840 int arg2 = (int) 0 ;
16841 int arg3 = (int) 0 ;
16842 wxScrollWinEvent *result;
16843 PyObject * obj0 = 0 ;
16844 PyObject * obj1 = 0 ;
16845 PyObject * obj2 = 0 ;
16846 char *kwnames[] = {
16847 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16848 };
16849
16850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16851 if (obj0) {
16852 {
16853 arg1 = (wxEventType)(SWIG_As_int(obj0));
16854 if (SWIG_arg_fail(1)) SWIG_fail;
16855 }
16856 }
16857 if (obj1) {
16858 {
16859 arg2 = (int)(SWIG_As_int(obj1));
16860 if (SWIG_arg_fail(2)) SWIG_fail;
16861 }
16862 }
16863 if (obj2) {
16864 {
16865 arg3 = (int)(SWIG_As_int(obj2));
16866 if (SWIG_arg_fail(3)) SWIG_fail;
16867 }
16868 }
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16872
16873 wxPyEndAllowThreads(__tstate);
16874 if (PyErr_Occurred()) SWIG_fail;
16875 }
16876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16877 return resultobj;
16878 fail:
16879 return NULL;
16880 }
16881
16882
16883 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16884 PyObject *resultobj;
16885 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16886 int result;
16887 PyObject * obj0 = 0 ;
16888 char *kwnames[] = {
16889 (char *) "self", NULL
16890 };
16891
16892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16894 if (SWIG_arg_fail(1)) SWIG_fail;
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16898
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 {
16903 resultobj = SWIG_From_int((int)(result));
16904 }
16905 return resultobj;
16906 fail:
16907 return NULL;
16908 }
16909
16910
16911 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16912 PyObject *resultobj;
16913 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16914 int result;
16915 PyObject * obj0 = 0 ;
16916 char *kwnames[] = {
16917 (char *) "self", NULL
16918 };
16919
16920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16922 if (SWIG_arg_fail(1)) SWIG_fail;
16923 {
16924 PyThreadState* __tstate = wxPyBeginAllowThreads();
16925 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16926
16927 wxPyEndAllowThreads(__tstate);
16928 if (PyErr_Occurred()) SWIG_fail;
16929 }
16930 {
16931 resultobj = SWIG_From_int((int)(result));
16932 }
16933 return resultobj;
16934 fail:
16935 return NULL;
16936 }
16937
16938
16939 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj;
16941 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16942 int arg2 ;
16943 PyObject * obj0 = 0 ;
16944 PyObject * obj1 = 0 ;
16945 char *kwnames[] = {
16946 (char *) "self",(char *) "orient", NULL
16947 };
16948
16949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16951 if (SWIG_arg_fail(1)) SWIG_fail;
16952 {
16953 arg2 = (int)(SWIG_As_int(obj1));
16954 if (SWIG_arg_fail(2)) SWIG_fail;
16955 }
16956 {
16957 PyThreadState* __tstate = wxPyBeginAllowThreads();
16958 (arg1)->SetOrientation(arg2);
16959
16960 wxPyEndAllowThreads(__tstate);
16961 if (PyErr_Occurred()) SWIG_fail;
16962 }
16963 Py_INCREF(Py_None); resultobj = Py_None;
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16971 PyObject *resultobj;
16972 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16973 int arg2 ;
16974 PyObject * obj0 = 0 ;
16975 PyObject * obj1 = 0 ;
16976 char *kwnames[] = {
16977 (char *) "self",(char *) "pos", NULL
16978 };
16979
16980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16982 if (SWIG_arg_fail(1)) SWIG_fail;
16983 {
16984 arg2 = (int)(SWIG_As_int(obj1));
16985 if (SWIG_arg_fail(2)) SWIG_fail;
16986 }
16987 {
16988 PyThreadState* __tstate = wxPyBeginAllowThreads();
16989 (arg1)->SetPosition(arg2);
16990
16991 wxPyEndAllowThreads(__tstate);
16992 if (PyErr_Occurred()) SWIG_fail;
16993 }
16994 Py_INCREF(Py_None); resultobj = Py_None;
16995 return resultobj;
16996 fail:
16997 return NULL;
16998 }
16999
17000
17001 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17002 PyObject *obj;
17003 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17004 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17005 Py_INCREF(obj);
17006 return Py_BuildValue((char *)"");
17007 }
17008 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17009 PyObject *resultobj;
17010 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17011 wxMouseEvent *result;
17012 PyObject * obj0 = 0 ;
17013 char *kwnames[] = {
17014 (char *) "mouseType", NULL
17015 };
17016
17017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17018 if (obj0) {
17019 {
17020 arg1 = (wxEventType)(SWIG_As_int(obj0));
17021 if (SWIG_arg_fail(1)) SWIG_fail;
17022 }
17023 }
17024 {
17025 PyThreadState* __tstate = wxPyBeginAllowThreads();
17026 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17027
17028 wxPyEndAllowThreads(__tstate);
17029 if (PyErr_Occurred()) SWIG_fail;
17030 }
17031 {
17032 resultobj = wxPyMake_wxObject(result, 1);
17033 }
17034 return resultobj;
17035 fail:
17036 return NULL;
17037 }
17038
17039
17040 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17041 PyObject *resultobj;
17042 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17043 bool result;
17044 PyObject * obj0 = 0 ;
17045 char *kwnames[] = {
17046 (char *) "self", NULL
17047 };
17048
17049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17051 if (SWIG_arg_fail(1)) SWIG_fail;
17052 {
17053 PyThreadState* __tstate = wxPyBeginAllowThreads();
17054 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17055
17056 wxPyEndAllowThreads(__tstate);
17057 if (PyErr_Occurred()) SWIG_fail;
17058 }
17059 {
17060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17061 }
17062 return resultobj;
17063 fail:
17064 return NULL;
17065 }
17066
17067
17068 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17069 PyObject *resultobj;
17070 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17071 int arg2 = (int) wxMOUSE_BTN_ANY ;
17072 bool result;
17073 PyObject * obj0 = 0 ;
17074 PyObject * obj1 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self",(char *) "but", NULL
17077 };
17078
17079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) 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 if (obj1) {
17083 {
17084 arg2 = (int)(SWIG_As_int(obj1));
17085 if (SWIG_arg_fail(2)) SWIG_fail;
17086 }
17087 }
17088 {
17089 PyThreadState* __tstate = wxPyBeginAllowThreads();
17090 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17091
17092 wxPyEndAllowThreads(__tstate);
17093 if (PyErr_Occurred()) SWIG_fail;
17094 }
17095 {
17096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17097 }
17098 return resultobj;
17099 fail:
17100 return NULL;
17101 }
17102
17103
17104 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17105 PyObject *resultobj;
17106 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17107 int arg2 = (int) wxMOUSE_BTN_ANY ;
17108 bool result;
17109 PyObject * obj0 = 0 ;
17110 PyObject * obj1 = 0 ;
17111 char *kwnames[] = {
17112 (char *) "self",(char *) "but", NULL
17113 };
17114
17115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17117 if (SWIG_arg_fail(1)) SWIG_fail;
17118 if (obj1) {
17119 {
17120 arg2 = (int)(SWIG_As_int(obj1));
17121 if (SWIG_arg_fail(2)) SWIG_fail;
17122 }
17123 }
17124 {
17125 PyThreadState* __tstate = wxPyBeginAllowThreads();
17126 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17127
17128 wxPyEndAllowThreads(__tstate);
17129 if (PyErr_Occurred()) SWIG_fail;
17130 }
17131 {
17132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17133 }
17134 return resultobj;
17135 fail:
17136 return NULL;
17137 }
17138
17139
17140 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj;
17142 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17143 int arg2 = (int) wxMOUSE_BTN_ANY ;
17144 bool result;
17145 PyObject * obj0 = 0 ;
17146 PyObject * obj1 = 0 ;
17147 char *kwnames[] = {
17148 (char *) "self",(char *) "but", NULL
17149 };
17150
17151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17153 if (SWIG_arg_fail(1)) SWIG_fail;
17154 if (obj1) {
17155 {
17156 arg2 = (int)(SWIG_As_int(obj1));
17157 if (SWIG_arg_fail(2)) SWIG_fail;
17158 }
17159 }
17160 {
17161 PyThreadState* __tstate = wxPyBeginAllowThreads();
17162 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17163
17164 wxPyEndAllowThreads(__tstate);
17165 if (PyErr_Occurred()) SWIG_fail;
17166 }
17167 {
17168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17169 }
17170 return resultobj;
17171 fail:
17172 return NULL;
17173 }
17174
17175
17176 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17177 PyObject *resultobj;
17178 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17179 int arg2 ;
17180 bool result;
17181 PyObject * obj0 = 0 ;
17182 PyObject * obj1 = 0 ;
17183 char *kwnames[] = {
17184 (char *) "self",(char *) "button", NULL
17185 };
17186
17187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17189 if (SWIG_arg_fail(1)) SWIG_fail;
17190 {
17191 arg2 = (int)(SWIG_As_int(obj1));
17192 if (SWIG_arg_fail(2)) SWIG_fail;
17193 }
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
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_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj;
17212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17213 int arg2 ;
17214 bool result;
17215 PyObject * obj0 = 0 ;
17216 PyObject * obj1 = 0 ;
17217 char *kwnames[] = {
17218 (char *) "self",(char *) "but", NULL
17219 };
17220
17221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17223 if (SWIG_arg_fail(1)) SWIG_fail;
17224 {
17225 arg2 = (int)(SWIG_As_int(obj1));
17226 if (SWIG_arg_fail(2)) SWIG_fail;
17227 }
17228 {
17229 PyThreadState* __tstate = wxPyBeginAllowThreads();
17230 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17231
17232 wxPyEndAllowThreads(__tstate);
17233 if (PyErr_Occurred()) SWIG_fail;
17234 }
17235 {
17236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17237 }
17238 return resultobj;
17239 fail:
17240 return NULL;
17241 }
17242
17243
17244 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17245 PyObject *resultobj;
17246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17247 int result;
17248 PyObject * obj0 = 0 ;
17249 char *kwnames[] = {
17250 (char *) "self", NULL
17251 };
17252
17253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17255 if (SWIG_arg_fail(1)) SWIG_fail;
17256 {
17257 PyThreadState* __tstate = wxPyBeginAllowThreads();
17258 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17259
17260 wxPyEndAllowThreads(__tstate);
17261 if (PyErr_Occurred()) SWIG_fail;
17262 }
17263 {
17264 resultobj = SWIG_From_int((int)(result));
17265 }
17266 return resultobj;
17267 fail:
17268 return NULL;
17269 }
17270
17271
17272 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17273 PyObject *resultobj;
17274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17275 bool result;
17276 PyObject * obj0 = 0 ;
17277 char *kwnames[] = {
17278 (char *) "self", NULL
17279 };
17280
17281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17283 if (SWIG_arg_fail(1)) SWIG_fail;
17284 {
17285 PyThreadState* __tstate = wxPyBeginAllowThreads();
17286 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17287
17288 wxPyEndAllowThreads(__tstate);
17289 if (PyErr_Occurred()) SWIG_fail;
17290 }
17291 {
17292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17293 }
17294 return resultobj;
17295 fail:
17296 return NULL;
17297 }
17298
17299
17300 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17301 PyObject *resultobj;
17302 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17303 bool result;
17304 PyObject * obj0 = 0 ;
17305 char *kwnames[] = {
17306 (char *) "self", NULL
17307 };
17308
17309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17311 if (SWIG_arg_fail(1)) SWIG_fail;
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17315
17316 wxPyEndAllowThreads(__tstate);
17317 if (PyErr_Occurred()) SWIG_fail;
17318 }
17319 {
17320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17321 }
17322 return resultobj;
17323 fail:
17324 return NULL;
17325 }
17326
17327
17328 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17329 PyObject *resultobj;
17330 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17331 bool result;
17332 PyObject * obj0 = 0 ;
17333 char *kwnames[] = {
17334 (char *) "self", NULL
17335 };
17336
17337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17339 if (SWIG_arg_fail(1)) SWIG_fail;
17340 {
17341 PyThreadState* __tstate = wxPyBeginAllowThreads();
17342 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17343
17344 wxPyEndAllowThreads(__tstate);
17345 if (PyErr_Occurred()) SWIG_fail;
17346 }
17347 {
17348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17349 }
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj;
17358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17359 bool result;
17360 PyObject * obj0 = 0 ;
17361 char *kwnames[] = {
17362 (char *) "self", NULL
17363 };
17364
17365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17367 if (SWIG_arg_fail(1)) SWIG_fail;
17368 {
17369 PyThreadState* __tstate = wxPyBeginAllowThreads();
17370 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17371
17372 wxPyEndAllowThreads(__tstate);
17373 if (PyErr_Occurred()) SWIG_fail;
17374 }
17375 {
17376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17377 }
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17385 PyObject *resultobj;
17386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17387 bool result;
17388 PyObject * obj0 = 0 ;
17389 char *kwnames[] = {
17390 (char *) "self", NULL
17391 };
17392
17393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17395 if (SWIG_arg_fail(1)) SWIG_fail;
17396 {
17397 PyThreadState* __tstate = wxPyBeginAllowThreads();
17398 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17399
17400 wxPyEndAllowThreads(__tstate);
17401 if (PyErr_Occurred()) SWIG_fail;
17402 }
17403 {
17404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17405 }
17406 return resultobj;
17407 fail:
17408 return NULL;
17409 }
17410
17411
17412 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17413 PyObject *resultobj;
17414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17415 bool result;
17416 PyObject * obj0 = 0 ;
17417 char *kwnames[] = {
17418 (char *) "self", NULL
17419 };
17420
17421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17423 if (SWIG_arg_fail(1)) SWIG_fail;
17424 {
17425 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17427
17428 wxPyEndAllowThreads(__tstate);
17429 if (PyErr_Occurred()) SWIG_fail;
17430 }
17431 {
17432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17433 }
17434 return resultobj;
17435 fail:
17436 return NULL;
17437 }
17438
17439
17440 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17441 PyObject *resultobj;
17442 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17443 bool result;
17444 PyObject * obj0 = 0 ;
17445 char *kwnames[] = {
17446 (char *) "self", NULL
17447 };
17448
17449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17451 if (SWIG_arg_fail(1)) SWIG_fail;
17452 {
17453 PyThreadState* __tstate = wxPyBeginAllowThreads();
17454 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17455
17456 wxPyEndAllowThreads(__tstate);
17457 if (PyErr_Occurred()) SWIG_fail;
17458 }
17459 {
17460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17461 }
17462 return resultobj;
17463 fail:
17464 return NULL;
17465 }
17466
17467
17468 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj;
17470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17471 bool result;
17472 PyObject * obj0 = 0 ;
17473 char *kwnames[] = {
17474 (char *) "self", NULL
17475 };
17476
17477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17479 if (SWIG_arg_fail(1)) SWIG_fail;
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17483
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 {
17488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17489 }
17490 return resultobj;
17491 fail:
17492 return NULL;
17493 }
17494
17495
17496 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17497 PyObject *resultobj;
17498 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17499 bool result;
17500 PyObject * obj0 = 0 ;
17501 char *kwnames[] = {
17502 (char *) "self", NULL
17503 };
17504
17505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17507 if (SWIG_arg_fail(1)) SWIG_fail;
17508 {
17509 PyThreadState* __tstate = wxPyBeginAllowThreads();
17510 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17511
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 {
17516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17517 }
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17525 PyObject *resultobj;
17526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17527 bool result;
17528 PyObject * obj0 = 0 ;
17529 char *kwnames[] = {
17530 (char *) "self", NULL
17531 };
17532
17533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17535 if (SWIG_arg_fail(1)) SWIG_fail;
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17539
17540 wxPyEndAllowThreads(__tstate);
17541 if (PyErr_Occurred()) SWIG_fail;
17542 }
17543 {
17544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17545 }
17546 return resultobj;
17547 fail:
17548 return NULL;
17549 }
17550
17551
17552 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17553 PyObject *resultobj;
17554 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17555 bool result;
17556 PyObject * obj0 = 0 ;
17557 char *kwnames[] = {
17558 (char *) "self", NULL
17559 };
17560
17561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17563 if (SWIG_arg_fail(1)) SWIG_fail;
17564 {
17565 PyThreadState* __tstate = wxPyBeginAllowThreads();
17566 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17567
17568 wxPyEndAllowThreads(__tstate);
17569 if (PyErr_Occurred()) SWIG_fail;
17570 }
17571 {
17572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17573 }
17574 return resultobj;
17575 fail:
17576 return NULL;
17577 }
17578
17579
17580 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17581 PyObject *resultobj;
17582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17583 bool result;
17584 PyObject * obj0 = 0 ;
17585 char *kwnames[] = {
17586 (char *) "self", NULL
17587 };
17588
17589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17591 if (SWIG_arg_fail(1)) SWIG_fail;
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17595
17596 wxPyEndAllowThreads(__tstate);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 }
17599 {
17600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17601 }
17602 return resultobj;
17603 fail:
17604 return NULL;
17605 }
17606
17607
17608 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17609 PyObject *resultobj;
17610 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17611 bool result;
17612 PyObject * obj0 = 0 ;
17613 char *kwnames[] = {
17614 (char *) "self", NULL
17615 };
17616
17617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17619 if (SWIG_arg_fail(1)) SWIG_fail;
17620 {
17621 PyThreadState* __tstate = wxPyBeginAllowThreads();
17622 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17623
17624 wxPyEndAllowThreads(__tstate);
17625 if (PyErr_Occurred()) SWIG_fail;
17626 }
17627 {
17628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17629 }
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17637 PyObject *resultobj;
17638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17639 bool result;
17640 PyObject * obj0 = 0 ;
17641 char *kwnames[] = {
17642 (char *) "self", NULL
17643 };
17644
17645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17647 if (SWIG_arg_fail(1)) SWIG_fail;
17648 {
17649 PyThreadState* __tstate = wxPyBeginAllowThreads();
17650 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17651
17652 wxPyEndAllowThreads(__tstate);
17653 if (PyErr_Occurred()) SWIG_fail;
17654 }
17655 {
17656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17657 }
17658 return resultobj;
17659 fail:
17660 return NULL;
17661 }
17662
17663
17664 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17665 PyObject *resultobj;
17666 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17667 bool result;
17668 PyObject * obj0 = 0 ;
17669 char *kwnames[] = {
17670 (char *) "self", NULL
17671 };
17672
17673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17675 if (SWIG_arg_fail(1)) SWIG_fail;
17676 {
17677 PyThreadState* __tstate = wxPyBeginAllowThreads();
17678 result = (bool)(arg1)->LeftIsDown();
17679
17680 wxPyEndAllowThreads(__tstate);
17681 if (PyErr_Occurred()) SWIG_fail;
17682 }
17683 {
17684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17685 }
17686 return resultobj;
17687 fail:
17688 return NULL;
17689 }
17690
17691
17692 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17693 PyObject *resultobj;
17694 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17695 bool result;
17696 PyObject * obj0 = 0 ;
17697 char *kwnames[] = {
17698 (char *) "self", NULL
17699 };
17700
17701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17703 if (SWIG_arg_fail(1)) SWIG_fail;
17704 {
17705 PyThreadState* __tstate = wxPyBeginAllowThreads();
17706 result = (bool)(arg1)->MiddleIsDown();
17707
17708 wxPyEndAllowThreads(__tstate);
17709 if (PyErr_Occurred()) SWIG_fail;
17710 }
17711 {
17712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj;
17722 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17723 bool result;
17724 PyObject * obj0 = 0 ;
17725 char *kwnames[] = {
17726 (char *) "self", NULL
17727 };
17728
17729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17731 if (SWIG_arg_fail(1)) SWIG_fail;
17732 {
17733 PyThreadState* __tstate = wxPyBeginAllowThreads();
17734 result = (bool)(arg1)->RightIsDown();
17735
17736 wxPyEndAllowThreads(__tstate);
17737 if (PyErr_Occurred()) SWIG_fail;
17738 }
17739 {
17740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17741 }
17742 return resultobj;
17743 fail:
17744 return NULL;
17745 }
17746
17747
17748 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17749 PyObject *resultobj;
17750 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17751 bool result;
17752 PyObject * obj0 = 0 ;
17753 char *kwnames[] = {
17754 (char *) "self", NULL
17755 };
17756
17757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17759 if (SWIG_arg_fail(1)) SWIG_fail;
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17763
17764 wxPyEndAllowThreads(__tstate);
17765 if (PyErr_Occurred()) SWIG_fail;
17766 }
17767 {
17768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17769 }
17770 return resultobj;
17771 fail:
17772 return NULL;
17773 }
17774
17775
17776 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17777 PyObject *resultobj;
17778 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17779 bool result;
17780 PyObject * obj0 = 0 ;
17781 char *kwnames[] = {
17782 (char *) "self", NULL
17783 };
17784
17785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17787 if (SWIG_arg_fail(1)) SWIG_fail;
17788 {
17789 PyThreadState* __tstate = wxPyBeginAllowThreads();
17790 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17791
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 {
17796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17797 }
17798 return resultobj;
17799 fail:
17800 return NULL;
17801 }
17802
17803
17804 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17805 PyObject *resultobj;
17806 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17807 bool result;
17808 PyObject * obj0 = 0 ;
17809 char *kwnames[] = {
17810 (char *) "self", NULL
17811 };
17812
17813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17815 if (SWIG_arg_fail(1)) SWIG_fail;
17816 {
17817 PyThreadState* __tstate = wxPyBeginAllowThreads();
17818 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17819
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 {
17824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17825 }
17826 return resultobj;
17827 fail:
17828 return NULL;
17829 }
17830
17831
17832 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17833 PyObject *resultobj;
17834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17835 bool result;
17836 PyObject * obj0 = 0 ;
17837 char *kwnames[] = {
17838 (char *) "self", NULL
17839 };
17840
17841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17843 if (SWIG_arg_fail(1)) SWIG_fail;
17844 {
17845 PyThreadState* __tstate = wxPyBeginAllowThreads();
17846 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17847
17848 wxPyEndAllowThreads(__tstate);
17849 if (PyErr_Occurred()) SWIG_fail;
17850 }
17851 {
17852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17853 }
17854 return resultobj;
17855 fail:
17856 return NULL;
17857 }
17858
17859
17860 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17861 PyObject *resultobj;
17862 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17863 wxPoint result;
17864 PyObject * obj0 = 0 ;
17865 char *kwnames[] = {
17866 (char *) "self", NULL
17867 };
17868
17869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17871 if (SWIG_arg_fail(1)) SWIG_fail;
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 result = (arg1)->GetPosition();
17875
17876 wxPyEndAllowThreads(__tstate);
17877 if (PyErr_Occurred()) SWIG_fail;
17878 }
17879 {
17880 wxPoint * resultptr;
17881 resultptr = new wxPoint((wxPoint &)(result));
17882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17883 }
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17891 PyObject *resultobj;
17892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17893 long *arg2 = (long *) 0 ;
17894 long *arg3 = (long *) 0 ;
17895 long temp2 ;
17896 int res2 = 0 ;
17897 long temp3 ;
17898 int res3 = 0 ;
17899 PyObject * obj0 = 0 ;
17900 char *kwnames[] = {
17901 (char *) "self", NULL
17902 };
17903
17904 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17905 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17908 if (SWIG_arg_fail(1)) SWIG_fail;
17909 {
17910 PyThreadState* __tstate = wxPyBeginAllowThreads();
17911 (arg1)->GetPosition(arg2,arg3);
17912
17913 wxPyEndAllowThreads(__tstate);
17914 if (PyErr_Occurred()) SWIG_fail;
17915 }
17916 Py_INCREF(Py_None); resultobj = Py_None;
17917 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17918 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17919 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17920 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17921 return resultobj;
17922 fail:
17923 return NULL;
17924 }
17925
17926
17927 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17928 PyObject *resultobj;
17929 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17930 wxDC *arg2 = 0 ;
17931 wxPoint result;
17932 PyObject * obj0 = 0 ;
17933 PyObject * obj1 = 0 ;
17934 char *kwnames[] = {
17935 (char *) "self",(char *) "dc", NULL
17936 };
17937
17938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17940 if (SWIG_arg_fail(1)) SWIG_fail;
17941 {
17942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17943 if (SWIG_arg_fail(2)) SWIG_fail;
17944 if (arg2 == NULL) {
17945 SWIG_null_ref("wxDC");
17946 }
17947 if (SWIG_arg_fail(2)) SWIG_fail;
17948 }
17949 {
17950 PyThreadState* __tstate = wxPyBeginAllowThreads();
17951 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17952
17953 wxPyEndAllowThreads(__tstate);
17954 if (PyErr_Occurred()) SWIG_fail;
17955 }
17956 {
17957 wxPoint * resultptr;
17958 resultptr = new wxPoint((wxPoint &)(result));
17959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17960 }
17961 return resultobj;
17962 fail:
17963 return NULL;
17964 }
17965
17966
17967 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17968 PyObject *resultobj;
17969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17970 int result;
17971 PyObject * obj0 = 0 ;
17972 char *kwnames[] = {
17973 (char *) "self", NULL
17974 };
17975
17976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17978 if (SWIG_arg_fail(1)) SWIG_fail;
17979 {
17980 PyThreadState* __tstate = wxPyBeginAllowThreads();
17981 result = (int)((wxMouseEvent const *)arg1)->GetX();
17982
17983 wxPyEndAllowThreads(__tstate);
17984 if (PyErr_Occurred()) SWIG_fail;
17985 }
17986 {
17987 resultobj = SWIG_From_int((int)(result));
17988 }
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj;
17997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17998 int result;
17999 PyObject * obj0 = 0 ;
18000 char *kwnames[] = {
18001 (char *) "self", NULL
18002 };
18003
18004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18006 if (SWIG_arg_fail(1)) SWIG_fail;
18007 {
18008 PyThreadState* __tstate = wxPyBeginAllowThreads();
18009 result = (int)((wxMouseEvent const *)arg1)->GetY();
18010
18011 wxPyEndAllowThreads(__tstate);
18012 if (PyErr_Occurred()) SWIG_fail;
18013 }
18014 {
18015 resultobj = SWIG_From_int((int)(result));
18016 }
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj;
18025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18026 int result;
18027 PyObject * obj0 = 0 ;
18028 char *kwnames[] = {
18029 (char *) "self", NULL
18030 };
18031
18032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18034 if (SWIG_arg_fail(1)) SWIG_fail;
18035 {
18036 PyThreadState* __tstate = wxPyBeginAllowThreads();
18037 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18038
18039 wxPyEndAllowThreads(__tstate);
18040 if (PyErr_Occurred()) SWIG_fail;
18041 }
18042 {
18043 resultobj = SWIG_From_int((int)(result));
18044 }
18045 return resultobj;
18046 fail:
18047 return NULL;
18048 }
18049
18050
18051 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18052 PyObject *resultobj;
18053 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18054 int result;
18055 PyObject * obj0 = 0 ;
18056 char *kwnames[] = {
18057 (char *) "self", NULL
18058 };
18059
18060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18062 if (SWIG_arg_fail(1)) SWIG_fail;
18063 {
18064 PyThreadState* __tstate = wxPyBeginAllowThreads();
18065 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18066
18067 wxPyEndAllowThreads(__tstate);
18068 if (PyErr_Occurred()) SWIG_fail;
18069 }
18070 {
18071 resultobj = SWIG_From_int((int)(result));
18072 }
18073 return resultobj;
18074 fail:
18075 return NULL;
18076 }
18077
18078
18079 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18080 PyObject *resultobj;
18081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18082 int result;
18083 PyObject * obj0 = 0 ;
18084 char *kwnames[] = {
18085 (char *) "self", NULL
18086 };
18087
18088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18090 if (SWIG_arg_fail(1)) SWIG_fail;
18091 {
18092 PyThreadState* __tstate = wxPyBeginAllowThreads();
18093 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18094
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 {
18099 resultobj = SWIG_From_int((int)(result));
18100 }
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18108 PyObject *resultobj;
18109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18110 bool result;
18111 PyObject * obj0 = 0 ;
18112 char *kwnames[] = {
18113 (char *) "self", NULL
18114 };
18115
18116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18118 if (SWIG_arg_fail(1)) SWIG_fail;
18119 {
18120 PyThreadState* __tstate = wxPyBeginAllowThreads();
18121 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18122
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 {
18127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18128 }
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj;
18137 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18138 int arg2 ;
18139 PyObject * obj0 = 0 ;
18140 PyObject * obj1 = 0 ;
18141 char *kwnames[] = {
18142 (char *) "self",(char *) "m_x", NULL
18143 };
18144
18145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18147 if (SWIG_arg_fail(1)) SWIG_fail;
18148 {
18149 arg2 = (int)(SWIG_As_int(obj1));
18150 if (SWIG_arg_fail(2)) SWIG_fail;
18151 }
18152 if (arg1) (arg1)->m_x = arg2;
18153
18154 Py_INCREF(Py_None); resultobj = Py_None;
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18162 PyObject *resultobj;
18163 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18164 int result;
18165 PyObject * obj0 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "self", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(1)) SWIG_fail;
18173 result = (int) ((arg1)->m_x);
18174
18175 {
18176 resultobj = SWIG_From_int((int)(result));
18177 }
18178 return resultobj;
18179 fail:
18180 return NULL;
18181 }
18182
18183
18184 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18185 PyObject *resultobj;
18186 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18187 int arg2 ;
18188 PyObject * obj0 = 0 ;
18189 PyObject * obj1 = 0 ;
18190 char *kwnames[] = {
18191 (char *) "self",(char *) "m_y", NULL
18192 };
18193
18194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18196 if (SWIG_arg_fail(1)) SWIG_fail;
18197 {
18198 arg2 = (int)(SWIG_As_int(obj1));
18199 if (SWIG_arg_fail(2)) SWIG_fail;
18200 }
18201 if (arg1) (arg1)->m_y = arg2;
18202
18203 Py_INCREF(Py_None); resultobj = Py_None;
18204 return resultobj;
18205 fail:
18206 return NULL;
18207 }
18208
18209
18210 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18211 PyObject *resultobj;
18212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18213 int result;
18214 PyObject * obj0 = 0 ;
18215 char *kwnames[] = {
18216 (char *) "self", NULL
18217 };
18218
18219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18221 if (SWIG_arg_fail(1)) SWIG_fail;
18222 result = (int) ((arg1)->m_y);
18223
18224 {
18225 resultobj = SWIG_From_int((int)(result));
18226 }
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18234 PyObject *resultobj;
18235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18236 bool arg2 ;
18237 PyObject * obj0 = 0 ;
18238 PyObject * obj1 = 0 ;
18239 char *kwnames[] = {
18240 (char *) "self",(char *) "m_leftDown", NULL
18241 };
18242
18243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18245 if (SWIG_arg_fail(1)) SWIG_fail;
18246 {
18247 arg2 = (bool)(SWIG_As_bool(obj1));
18248 if (SWIG_arg_fail(2)) SWIG_fail;
18249 }
18250 if (arg1) (arg1)->m_leftDown = arg2;
18251
18252 Py_INCREF(Py_None); resultobj = Py_None;
18253 return resultobj;
18254 fail:
18255 return NULL;
18256 }
18257
18258
18259 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18260 PyObject *resultobj;
18261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18262 bool result;
18263 PyObject * obj0 = 0 ;
18264 char *kwnames[] = {
18265 (char *) "self", NULL
18266 };
18267
18268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18270 if (SWIG_arg_fail(1)) SWIG_fail;
18271 result = (bool) ((arg1)->m_leftDown);
18272
18273 {
18274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18275 }
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18283 PyObject *resultobj;
18284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18285 bool arg2 ;
18286 PyObject * obj0 = 0 ;
18287 PyObject * obj1 = 0 ;
18288 char *kwnames[] = {
18289 (char *) "self",(char *) "m_middleDown", NULL
18290 };
18291
18292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18294 if (SWIG_arg_fail(1)) SWIG_fail;
18295 {
18296 arg2 = (bool)(SWIG_As_bool(obj1));
18297 if (SWIG_arg_fail(2)) SWIG_fail;
18298 }
18299 if (arg1) (arg1)->m_middleDown = arg2;
18300
18301 Py_INCREF(Py_None); resultobj = Py_None;
18302 return resultobj;
18303 fail:
18304 return NULL;
18305 }
18306
18307
18308 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18309 PyObject *resultobj;
18310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18311 bool result;
18312 PyObject * obj0 = 0 ;
18313 char *kwnames[] = {
18314 (char *) "self", NULL
18315 };
18316
18317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18319 if (SWIG_arg_fail(1)) SWIG_fail;
18320 result = (bool) ((arg1)->m_middleDown);
18321
18322 {
18323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18324 }
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj;
18333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18334 bool arg2 ;
18335 PyObject * obj0 = 0 ;
18336 PyObject * obj1 = 0 ;
18337 char *kwnames[] = {
18338 (char *) "self",(char *) "m_rightDown", NULL
18339 };
18340
18341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18343 if (SWIG_arg_fail(1)) SWIG_fail;
18344 {
18345 arg2 = (bool)(SWIG_As_bool(obj1));
18346 if (SWIG_arg_fail(2)) SWIG_fail;
18347 }
18348 if (arg1) (arg1)->m_rightDown = arg2;
18349
18350 Py_INCREF(Py_None); resultobj = Py_None;
18351 return resultobj;
18352 fail:
18353 return NULL;
18354 }
18355
18356
18357 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18358 PyObject *resultobj;
18359 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18360 bool result;
18361 PyObject * obj0 = 0 ;
18362 char *kwnames[] = {
18363 (char *) "self", NULL
18364 };
18365
18366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18368 if (SWIG_arg_fail(1)) SWIG_fail;
18369 result = (bool) ((arg1)->m_rightDown);
18370
18371 {
18372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18373 }
18374 return resultobj;
18375 fail:
18376 return NULL;
18377 }
18378
18379
18380 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj;
18382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18383 bool arg2 ;
18384 PyObject * obj0 = 0 ;
18385 PyObject * obj1 = 0 ;
18386 char *kwnames[] = {
18387 (char *) "self",(char *) "m_controlDown", NULL
18388 };
18389
18390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18392 if (SWIG_arg_fail(1)) SWIG_fail;
18393 {
18394 arg2 = (bool)(SWIG_As_bool(obj1));
18395 if (SWIG_arg_fail(2)) SWIG_fail;
18396 }
18397 if (arg1) (arg1)->m_controlDown = arg2;
18398
18399 Py_INCREF(Py_None); resultobj = Py_None;
18400 return resultobj;
18401 fail:
18402 return NULL;
18403 }
18404
18405
18406 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj;
18408 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18409 bool result;
18410 PyObject * obj0 = 0 ;
18411 char *kwnames[] = {
18412 (char *) "self", NULL
18413 };
18414
18415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18417 if (SWIG_arg_fail(1)) SWIG_fail;
18418 result = (bool) ((arg1)->m_controlDown);
18419
18420 {
18421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18422 }
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj;
18431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18432 bool arg2 ;
18433 PyObject * obj0 = 0 ;
18434 PyObject * obj1 = 0 ;
18435 char *kwnames[] = {
18436 (char *) "self",(char *) "m_shiftDown", NULL
18437 };
18438
18439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18441 if (SWIG_arg_fail(1)) SWIG_fail;
18442 {
18443 arg2 = (bool)(SWIG_As_bool(obj1));
18444 if (SWIG_arg_fail(2)) SWIG_fail;
18445 }
18446 if (arg1) (arg1)->m_shiftDown = arg2;
18447
18448 Py_INCREF(Py_None); resultobj = Py_None;
18449 return resultobj;
18450 fail:
18451 return NULL;
18452 }
18453
18454
18455 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18456 PyObject *resultobj;
18457 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18458 bool result;
18459 PyObject * obj0 = 0 ;
18460 char *kwnames[] = {
18461 (char *) "self", NULL
18462 };
18463
18464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18466 if (SWIG_arg_fail(1)) SWIG_fail;
18467 result = (bool) ((arg1)->m_shiftDown);
18468
18469 {
18470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18471 }
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj;
18480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18481 bool arg2 ;
18482 PyObject * obj0 = 0 ;
18483 PyObject * obj1 = 0 ;
18484 char *kwnames[] = {
18485 (char *) "self",(char *) "m_altDown", NULL
18486 };
18487
18488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18490 if (SWIG_arg_fail(1)) SWIG_fail;
18491 {
18492 arg2 = (bool)(SWIG_As_bool(obj1));
18493 if (SWIG_arg_fail(2)) SWIG_fail;
18494 }
18495 if (arg1) (arg1)->m_altDown = arg2;
18496
18497 Py_INCREF(Py_None); resultobj = Py_None;
18498 return resultobj;
18499 fail:
18500 return NULL;
18501 }
18502
18503
18504 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18505 PyObject *resultobj;
18506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18507 bool result;
18508 PyObject * obj0 = 0 ;
18509 char *kwnames[] = {
18510 (char *) "self", NULL
18511 };
18512
18513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18515 if (SWIG_arg_fail(1)) SWIG_fail;
18516 result = (bool) ((arg1)->m_altDown);
18517
18518 {
18519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18520 }
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj;
18529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18530 bool arg2 ;
18531 PyObject * obj0 = 0 ;
18532 PyObject * obj1 = 0 ;
18533 char *kwnames[] = {
18534 (char *) "self",(char *) "m_metaDown", NULL
18535 };
18536
18537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18539 if (SWIG_arg_fail(1)) SWIG_fail;
18540 {
18541 arg2 = (bool)(SWIG_As_bool(obj1));
18542 if (SWIG_arg_fail(2)) SWIG_fail;
18543 }
18544 if (arg1) (arg1)->m_metaDown = arg2;
18545
18546 Py_INCREF(Py_None); resultobj = Py_None;
18547 return resultobj;
18548 fail:
18549 return NULL;
18550 }
18551
18552
18553 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18554 PyObject *resultobj;
18555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18556 bool result;
18557 PyObject * obj0 = 0 ;
18558 char *kwnames[] = {
18559 (char *) "self", NULL
18560 };
18561
18562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18564 if (SWIG_arg_fail(1)) SWIG_fail;
18565 result = (bool) ((arg1)->m_metaDown);
18566
18567 {
18568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18569 }
18570 return resultobj;
18571 fail:
18572 return NULL;
18573 }
18574
18575
18576 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18577 PyObject *resultobj;
18578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18579 int arg2 ;
18580 PyObject * obj0 = 0 ;
18581 PyObject * obj1 = 0 ;
18582 char *kwnames[] = {
18583 (char *) "self",(char *) "m_wheelRotation", NULL
18584 };
18585
18586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18588 if (SWIG_arg_fail(1)) SWIG_fail;
18589 {
18590 arg2 = (int)(SWIG_As_int(obj1));
18591 if (SWIG_arg_fail(2)) SWIG_fail;
18592 }
18593 if (arg1) (arg1)->m_wheelRotation = arg2;
18594
18595 Py_INCREF(Py_None); resultobj = Py_None;
18596 return resultobj;
18597 fail:
18598 return NULL;
18599 }
18600
18601
18602 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18603 PyObject *resultobj;
18604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18605 int result;
18606 PyObject * obj0 = 0 ;
18607 char *kwnames[] = {
18608 (char *) "self", NULL
18609 };
18610
18611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18613 if (SWIG_arg_fail(1)) SWIG_fail;
18614 result = (int) ((arg1)->m_wheelRotation);
18615
18616 {
18617 resultobj = SWIG_From_int((int)(result));
18618 }
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18626 PyObject *resultobj;
18627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18628 int arg2 ;
18629 PyObject * obj0 = 0 ;
18630 PyObject * obj1 = 0 ;
18631 char *kwnames[] = {
18632 (char *) "self",(char *) "m_wheelDelta", NULL
18633 };
18634
18635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18637 if (SWIG_arg_fail(1)) SWIG_fail;
18638 {
18639 arg2 = (int)(SWIG_As_int(obj1));
18640 if (SWIG_arg_fail(2)) SWIG_fail;
18641 }
18642 if (arg1) (arg1)->m_wheelDelta = arg2;
18643
18644 Py_INCREF(Py_None); resultobj = Py_None;
18645 return resultobj;
18646 fail:
18647 return NULL;
18648 }
18649
18650
18651 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18652 PyObject *resultobj;
18653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18654 int result;
18655 PyObject * obj0 = 0 ;
18656 char *kwnames[] = {
18657 (char *) "self", NULL
18658 };
18659
18660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18662 if (SWIG_arg_fail(1)) SWIG_fail;
18663 result = (int) ((arg1)->m_wheelDelta);
18664
18665 {
18666 resultobj = SWIG_From_int((int)(result));
18667 }
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj;
18676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18677 int arg2 ;
18678 PyObject * obj0 = 0 ;
18679 PyObject * obj1 = 0 ;
18680 char *kwnames[] = {
18681 (char *) "self",(char *) "m_linesPerAction", NULL
18682 };
18683
18684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18686 if (SWIG_arg_fail(1)) SWIG_fail;
18687 {
18688 arg2 = (int)(SWIG_As_int(obj1));
18689 if (SWIG_arg_fail(2)) SWIG_fail;
18690 }
18691 if (arg1) (arg1)->m_linesPerAction = arg2;
18692
18693 Py_INCREF(Py_None); resultobj = Py_None;
18694 return resultobj;
18695 fail:
18696 return NULL;
18697 }
18698
18699
18700 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18701 PyObject *resultobj;
18702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18703 int result;
18704 PyObject * obj0 = 0 ;
18705 char *kwnames[] = {
18706 (char *) "self", NULL
18707 };
18708
18709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18711 if (SWIG_arg_fail(1)) SWIG_fail;
18712 result = (int) ((arg1)->m_linesPerAction);
18713
18714 {
18715 resultobj = SWIG_From_int((int)(result));
18716 }
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18724 PyObject *obj;
18725 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18726 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18727 Py_INCREF(obj);
18728 return Py_BuildValue((char *)"");
18729 }
18730 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18731 PyObject *resultobj;
18732 int arg1 = (int) 0 ;
18733 int arg2 = (int) 0 ;
18734 wxSetCursorEvent *result;
18735 PyObject * obj0 = 0 ;
18736 PyObject * obj1 = 0 ;
18737 char *kwnames[] = {
18738 (char *) "x",(char *) "y", NULL
18739 };
18740
18741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18742 if (obj0) {
18743 {
18744 arg1 = (int)(SWIG_As_int(obj0));
18745 if (SWIG_arg_fail(1)) SWIG_fail;
18746 }
18747 }
18748 if (obj1) {
18749 {
18750 arg2 = (int)(SWIG_As_int(obj1));
18751 if (SWIG_arg_fail(2)) SWIG_fail;
18752 }
18753 }
18754 {
18755 PyThreadState* __tstate = wxPyBeginAllowThreads();
18756 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18757
18758 wxPyEndAllowThreads(__tstate);
18759 if (PyErr_Occurred()) SWIG_fail;
18760 }
18761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18762 return resultobj;
18763 fail:
18764 return NULL;
18765 }
18766
18767
18768 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18769 PyObject *resultobj;
18770 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18771 int result;
18772 PyObject * obj0 = 0 ;
18773 char *kwnames[] = {
18774 (char *) "self", NULL
18775 };
18776
18777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18779 if (SWIG_arg_fail(1)) SWIG_fail;
18780 {
18781 PyThreadState* __tstate = wxPyBeginAllowThreads();
18782 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18783
18784 wxPyEndAllowThreads(__tstate);
18785 if (PyErr_Occurred()) SWIG_fail;
18786 }
18787 {
18788 resultobj = SWIG_From_int((int)(result));
18789 }
18790 return resultobj;
18791 fail:
18792 return NULL;
18793 }
18794
18795
18796 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18797 PyObject *resultobj;
18798 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18799 int result;
18800 PyObject * obj0 = 0 ;
18801 char *kwnames[] = {
18802 (char *) "self", NULL
18803 };
18804
18805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18807 if (SWIG_arg_fail(1)) SWIG_fail;
18808 {
18809 PyThreadState* __tstate = wxPyBeginAllowThreads();
18810 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18811
18812 wxPyEndAllowThreads(__tstate);
18813 if (PyErr_Occurred()) SWIG_fail;
18814 }
18815 {
18816 resultobj = SWIG_From_int((int)(result));
18817 }
18818 return resultobj;
18819 fail:
18820 return NULL;
18821 }
18822
18823
18824 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18825 PyObject *resultobj;
18826 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18827 wxCursor *arg2 = 0 ;
18828 PyObject * obj0 = 0 ;
18829 PyObject * obj1 = 0 ;
18830 char *kwnames[] = {
18831 (char *) "self",(char *) "cursor", NULL
18832 };
18833
18834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18836 if (SWIG_arg_fail(1)) SWIG_fail;
18837 {
18838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18839 if (SWIG_arg_fail(2)) SWIG_fail;
18840 if (arg2 == NULL) {
18841 SWIG_null_ref("wxCursor");
18842 }
18843 if (SWIG_arg_fail(2)) SWIG_fail;
18844 }
18845 {
18846 PyThreadState* __tstate = wxPyBeginAllowThreads();
18847 (arg1)->SetCursor((wxCursor const &)*arg2);
18848
18849 wxPyEndAllowThreads(__tstate);
18850 if (PyErr_Occurred()) SWIG_fail;
18851 }
18852 Py_INCREF(Py_None); resultobj = Py_None;
18853 return resultobj;
18854 fail:
18855 return NULL;
18856 }
18857
18858
18859 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18860 PyObject *resultobj;
18861 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18862 wxCursor *result;
18863 PyObject * obj0 = 0 ;
18864 char *kwnames[] = {
18865 (char *) "self", NULL
18866 };
18867
18868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18870 if (SWIG_arg_fail(1)) SWIG_fail;
18871 {
18872 PyThreadState* __tstate = wxPyBeginAllowThreads();
18873 {
18874 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18875 result = (wxCursor *) &_result_ref;
18876 }
18877
18878 wxPyEndAllowThreads(__tstate);
18879 if (PyErr_Occurred()) SWIG_fail;
18880 }
18881 {
18882 wxCursor* resultptr = new wxCursor(*result);
18883 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18884 }
18885 return resultobj;
18886 fail:
18887 return NULL;
18888 }
18889
18890
18891 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18892 PyObject *resultobj;
18893 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18894 bool result;
18895 PyObject * obj0 = 0 ;
18896 char *kwnames[] = {
18897 (char *) "self", NULL
18898 };
18899
18900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18902 if (SWIG_arg_fail(1)) SWIG_fail;
18903 {
18904 PyThreadState* __tstate = wxPyBeginAllowThreads();
18905 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18906
18907 wxPyEndAllowThreads(__tstate);
18908 if (PyErr_Occurred()) SWIG_fail;
18909 }
18910 {
18911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18912 }
18913 return resultobj;
18914 fail:
18915 return NULL;
18916 }
18917
18918
18919 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18920 PyObject *obj;
18921 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18922 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18923 Py_INCREF(obj);
18924 return Py_BuildValue((char *)"");
18925 }
18926 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj;
18928 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18929 wxKeyEvent *result;
18930 PyObject * obj0 = 0 ;
18931 char *kwnames[] = {
18932 (char *) "eventType", NULL
18933 };
18934
18935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18936 if (obj0) {
18937 {
18938 arg1 = (wxEventType)(SWIG_As_int(obj0));
18939 if (SWIG_arg_fail(1)) SWIG_fail;
18940 }
18941 }
18942 {
18943 PyThreadState* __tstate = wxPyBeginAllowThreads();
18944 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18945
18946 wxPyEndAllowThreads(__tstate);
18947 if (PyErr_Occurred()) SWIG_fail;
18948 }
18949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18950 return resultobj;
18951 fail:
18952 return NULL;
18953 }
18954
18955
18956 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18957 PyObject *resultobj;
18958 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18959 bool result;
18960 PyObject * obj0 = 0 ;
18961 char *kwnames[] = {
18962 (char *) "self", NULL
18963 };
18964
18965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18967 if (SWIG_arg_fail(1)) SWIG_fail;
18968 {
18969 PyThreadState* __tstate = wxPyBeginAllowThreads();
18970 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18971
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 {
18976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18977 }
18978 return resultobj;
18979 fail:
18980 return NULL;
18981 }
18982
18983
18984 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18985 PyObject *resultobj;
18986 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18987 bool result;
18988 PyObject * obj0 = 0 ;
18989 char *kwnames[] = {
18990 (char *) "self", NULL
18991 };
18992
18993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18995 if (SWIG_arg_fail(1)) SWIG_fail;
18996 {
18997 PyThreadState* __tstate = wxPyBeginAllowThreads();
18998 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18999
19000 wxPyEndAllowThreads(__tstate);
19001 if (PyErr_Occurred()) SWIG_fail;
19002 }
19003 {
19004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19005 }
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj;
19014 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19015 bool result;
19016 PyObject * obj0 = 0 ;
19017 char *kwnames[] = {
19018 (char *) "self", NULL
19019 };
19020
19021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19023 if (SWIG_arg_fail(1)) SWIG_fail;
19024 {
19025 PyThreadState* __tstate = wxPyBeginAllowThreads();
19026 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19027
19028 wxPyEndAllowThreads(__tstate);
19029 if (PyErr_Occurred()) SWIG_fail;
19030 }
19031 {
19032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19033 }
19034 return resultobj;
19035 fail:
19036 return NULL;
19037 }
19038
19039
19040 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19041 PyObject *resultobj;
19042 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19043 bool result;
19044 PyObject * obj0 = 0 ;
19045 char *kwnames[] = {
19046 (char *) "self", NULL
19047 };
19048
19049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19051 if (SWIG_arg_fail(1)) SWIG_fail;
19052 {
19053 PyThreadState* __tstate = wxPyBeginAllowThreads();
19054 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19055
19056 wxPyEndAllowThreads(__tstate);
19057 if (PyErr_Occurred()) SWIG_fail;
19058 }
19059 {
19060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19061 }
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj;
19070 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19071 bool result;
19072 PyObject * obj0 = 0 ;
19073 char *kwnames[] = {
19074 (char *) "self", NULL
19075 };
19076
19077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19079 if (SWIG_arg_fail(1)) SWIG_fail;
19080 {
19081 PyThreadState* __tstate = wxPyBeginAllowThreads();
19082 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19083
19084 wxPyEndAllowThreads(__tstate);
19085 if (PyErr_Occurred()) SWIG_fail;
19086 }
19087 {
19088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19089 }
19090 return resultobj;
19091 fail:
19092 return NULL;
19093 }
19094
19095
19096 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19097 PyObject *resultobj;
19098 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19099 bool result;
19100 PyObject * obj0 = 0 ;
19101 char *kwnames[] = {
19102 (char *) "self", NULL
19103 };
19104
19105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19107 if (SWIG_arg_fail(1)) SWIG_fail;
19108 {
19109 PyThreadState* __tstate = wxPyBeginAllowThreads();
19110 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19111
19112 wxPyEndAllowThreads(__tstate);
19113 if (PyErr_Occurred()) SWIG_fail;
19114 }
19115 {
19116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19117 }
19118 return resultobj;
19119 fail:
19120 return NULL;
19121 }
19122
19123
19124 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19125 PyObject *resultobj;
19126 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19127 int result;
19128 PyObject * obj0 = 0 ;
19129 char *kwnames[] = {
19130 (char *) "self", NULL
19131 };
19132
19133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19135 if (SWIG_arg_fail(1)) SWIG_fail;
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19139
19140 wxPyEndAllowThreads(__tstate);
19141 if (PyErr_Occurred()) SWIG_fail;
19142 }
19143 {
19144 resultobj = SWIG_From_int((int)(result));
19145 }
19146 return resultobj;
19147 fail:
19148 return NULL;
19149 }
19150
19151
19152 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19153 PyObject *resultobj;
19154 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19155 int result;
19156 PyObject * obj0 = 0 ;
19157 char *kwnames[] = {
19158 (char *) "self", NULL
19159 };
19160
19161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19163 if (SWIG_arg_fail(1)) SWIG_fail;
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19167
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 {
19172 resultobj = SWIG_From_int((int)(result));
19173 }
19174 return resultobj;
19175 fail:
19176 return NULL;
19177 }
19178
19179
19180 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19181 PyObject *resultobj;
19182 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19183 unsigned int result;
19184 PyObject * obj0 = 0 ;
19185 char *kwnames[] = {
19186 (char *) "self", NULL
19187 };
19188
19189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19191 if (SWIG_arg_fail(1)) SWIG_fail;
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19195
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 {
19200 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19201 }
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj;
19210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19211 unsigned int result;
19212 PyObject * obj0 = 0 ;
19213 char *kwnames[] = {
19214 (char *) "self", NULL
19215 };
19216
19217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19219 if (SWIG_arg_fail(1)) SWIG_fail;
19220 {
19221 PyThreadState* __tstate = wxPyBeginAllowThreads();
19222 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19223
19224 wxPyEndAllowThreads(__tstate);
19225 if (PyErr_Occurred()) SWIG_fail;
19226 }
19227 {
19228 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19229 }
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19237 PyObject *resultobj;
19238 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19239 wxPoint result;
19240 PyObject * obj0 = 0 ;
19241 char *kwnames[] = {
19242 (char *) "self", NULL
19243 };
19244
19245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19247 if (SWIG_arg_fail(1)) SWIG_fail;
19248 {
19249 PyThreadState* __tstate = wxPyBeginAllowThreads();
19250 result = (arg1)->GetPosition();
19251
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 {
19256 wxPoint * resultptr;
19257 resultptr = new wxPoint((wxPoint &)(result));
19258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19259 }
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19267 PyObject *resultobj;
19268 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19269 long *arg2 = (long *) 0 ;
19270 long *arg3 = (long *) 0 ;
19271 long temp2 ;
19272 int res2 = 0 ;
19273 long temp3 ;
19274 int res3 = 0 ;
19275 PyObject * obj0 = 0 ;
19276 char *kwnames[] = {
19277 (char *) "self", NULL
19278 };
19279
19280 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19281 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19284 if (SWIG_arg_fail(1)) SWIG_fail;
19285 {
19286 PyThreadState* __tstate = wxPyBeginAllowThreads();
19287 (arg1)->GetPosition(arg2,arg3);
19288
19289 wxPyEndAllowThreads(__tstate);
19290 if (PyErr_Occurred()) SWIG_fail;
19291 }
19292 Py_INCREF(Py_None); resultobj = Py_None;
19293 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19294 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19295 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19296 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19297 return resultobj;
19298 fail:
19299 return NULL;
19300 }
19301
19302
19303 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19304 PyObject *resultobj;
19305 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19306 int result;
19307 PyObject * obj0 = 0 ;
19308 char *kwnames[] = {
19309 (char *) "self", NULL
19310 };
19311
19312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19314 if (SWIG_arg_fail(1)) SWIG_fail;
19315 {
19316 PyThreadState* __tstate = wxPyBeginAllowThreads();
19317 result = (int)((wxKeyEvent const *)arg1)->GetX();
19318
19319 wxPyEndAllowThreads(__tstate);
19320 if (PyErr_Occurred()) SWIG_fail;
19321 }
19322 {
19323 resultobj = SWIG_From_int((int)(result));
19324 }
19325 return resultobj;
19326 fail:
19327 return NULL;
19328 }
19329
19330
19331 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19332 PyObject *resultobj;
19333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19334 int result;
19335 PyObject * obj0 = 0 ;
19336 char *kwnames[] = {
19337 (char *) "self", NULL
19338 };
19339
19340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19342 if (SWIG_arg_fail(1)) SWIG_fail;
19343 {
19344 PyThreadState* __tstate = wxPyBeginAllowThreads();
19345 result = (int)((wxKeyEvent const *)arg1)->GetY();
19346
19347 wxPyEndAllowThreads(__tstate);
19348 if (PyErr_Occurred()) SWIG_fail;
19349 }
19350 {
19351 resultobj = SWIG_From_int((int)(result));
19352 }
19353 return resultobj;
19354 fail:
19355 return NULL;
19356 }
19357
19358
19359 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19360 PyObject *resultobj;
19361 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19362 int arg2 ;
19363 PyObject * obj0 = 0 ;
19364 PyObject * obj1 = 0 ;
19365 char *kwnames[] = {
19366 (char *) "self",(char *) "m_x", NULL
19367 };
19368
19369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19371 if (SWIG_arg_fail(1)) SWIG_fail;
19372 {
19373 arg2 = (int)(SWIG_As_int(obj1));
19374 if (SWIG_arg_fail(2)) SWIG_fail;
19375 }
19376 if (arg1) (arg1)->m_x = arg2;
19377
19378 Py_INCREF(Py_None); resultobj = Py_None;
19379 return resultobj;
19380 fail:
19381 return NULL;
19382 }
19383
19384
19385 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19386 PyObject *resultobj;
19387 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19388 int result;
19389 PyObject * obj0 = 0 ;
19390 char *kwnames[] = {
19391 (char *) "self", NULL
19392 };
19393
19394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19396 if (SWIG_arg_fail(1)) SWIG_fail;
19397 result = (int) ((arg1)->m_x);
19398
19399 {
19400 resultobj = SWIG_From_int((int)(result));
19401 }
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19409 PyObject *resultobj;
19410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19411 int arg2 ;
19412 PyObject * obj0 = 0 ;
19413 PyObject * obj1 = 0 ;
19414 char *kwnames[] = {
19415 (char *) "self",(char *) "m_y", NULL
19416 };
19417
19418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19420 if (SWIG_arg_fail(1)) SWIG_fail;
19421 {
19422 arg2 = (int)(SWIG_As_int(obj1));
19423 if (SWIG_arg_fail(2)) SWIG_fail;
19424 }
19425 if (arg1) (arg1)->m_y = arg2;
19426
19427 Py_INCREF(Py_None); resultobj = Py_None;
19428 return resultobj;
19429 fail:
19430 return NULL;
19431 }
19432
19433
19434 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19435 PyObject *resultobj;
19436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19437 int result;
19438 PyObject * obj0 = 0 ;
19439 char *kwnames[] = {
19440 (char *) "self", NULL
19441 };
19442
19443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19445 if (SWIG_arg_fail(1)) SWIG_fail;
19446 result = (int) ((arg1)->m_y);
19447
19448 {
19449 resultobj = SWIG_From_int((int)(result));
19450 }
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj;
19459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19460 long arg2 ;
19461 PyObject * obj0 = 0 ;
19462 PyObject * obj1 = 0 ;
19463 char *kwnames[] = {
19464 (char *) "self",(char *) "m_keyCode", NULL
19465 };
19466
19467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19469 if (SWIG_arg_fail(1)) SWIG_fail;
19470 {
19471 arg2 = (long)(SWIG_As_long(obj1));
19472 if (SWIG_arg_fail(2)) SWIG_fail;
19473 }
19474 if (arg1) (arg1)->m_keyCode = arg2;
19475
19476 Py_INCREF(Py_None); resultobj = Py_None;
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19484 PyObject *resultobj;
19485 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19486 long result;
19487 PyObject * obj0 = 0 ;
19488 char *kwnames[] = {
19489 (char *) "self", NULL
19490 };
19491
19492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19494 if (SWIG_arg_fail(1)) SWIG_fail;
19495 result = (long) ((arg1)->m_keyCode);
19496
19497 {
19498 resultobj = SWIG_From_long((long)(result));
19499 }
19500 return resultobj;
19501 fail:
19502 return NULL;
19503 }
19504
19505
19506 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19507 PyObject *resultobj;
19508 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19509 bool arg2 ;
19510 PyObject * obj0 = 0 ;
19511 PyObject * obj1 = 0 ;
19512 char *kwnames[] = {
19513 (char *) "self",(char *) "m_controlDown", NULL
19514 };
19515
19516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19518 if (SWIG_arg_fail(1)) SWIG_fail;
19519 {
19520 arg2 = (bool)(SWIG_As_bool(obj1));
19521 if (SWIG_arg_fail(2)) SWIG_fail;
19522 }
19523 if (arg1) (arg1)->m_controlDown = arg2;
19524
19525 Py_INCREF(Py_None); resultobj = Py_None;
19526 return resultobj;
19527 fail:
19528 return NULL;
19529 }
19530
19531
19532 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19533 PyObject *resultobj;
19534 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19535 bool result;
19536 PyObject * obj0 = 0 ;
19537 char *kwnames[] = {
19538 (char *) "self", NULL
19539 };
19540
19541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19543 if (SWIG_arg_fail(1)) SWIG_fail;
19544 result = (bool) ((arg1)->m_controlDown);
19545
19546 {
19547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19548 }
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj;
19557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19558 bool arg2 ;
19559 PyObject * obj0 = 0 ;
19560 PyObject * obj1 = 0 ;
19561 char *kwnames[] = {
19562 (char *) "self",(char *) "m_shiftDown", NULL
19563 };
19564
19565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19567 if (SWIG_arg_fail(1)) SWIG_fail;
19568 {
19569 arg2 = (bool)(SWIG_As_bool(obj1));
19570 if (SWIG_arg_fail(2)) SWIG_fail;
19571 }
19572 if (arg1) (arg1)->m_shiftDown = arg2;
19573
19574 Py_INCREF(Py_None); resultobj = Py_None;
19575 return resultobj;
19576 fail:
19577 return NULL;
19578 }
19579
19580
19581 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj;
19583 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19584 bool result;
19585 PyObject * obj0 = 0 ;
19586 char *kwnames[] = {
19587 (char *) "self", NULL
19588 };
19589
19590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19592 if (SWIG_arg_fail(1)) SWIG_fail;
19593 result = (bool) ((arg1)->m_shiftDown);
19594
19595 {
19596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19597 }
19598 return resultobj;
19599 fail:
19600 return NULL;
19601 }
19602
19603
19604 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19605 PyObject *resultobj;
19606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19607 bool arg2 ;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 char *kwnames[] = {
19611 (char *) "self",(char *) "m_altDown", NULL
19612 };
19613
19614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19616 if (SWIG_arg_fail(1)) SWIG_fail;
19617 {
19618 arg2 = (bool)(SWIG_As_bool(obj1));
19619 if (SWIG_arg_fail(2)) SWIG_fail;
19620 }
19621 if (arg1) (arg1)->m_altDown = arg2;
19622
19623 Py_INCREF(Py_None); resultobj = Py_None;
19624 return resultobj;
19625 fail:
19626 return NULL;
19627 }
19628
19629
19630 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19631 PyObject *resultobj;
19632 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19633 bool result;
19634 PyObject * obj0 = 0 ;
19635 char *kwnames[] = {
19636 (char *) "self", NULL
19637 };
19638
19639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19641 if (SWIG_arg_fail(1)) SWIG_fail;
19642 result = (bool) ((arg1)->m_altDown);
19643
19644 {
19645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19646 }
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj;
19655 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19656 bool arg2 ;
19657 PyObject * obj0 = 0 ;
19658 PyObject * obj1 = 0 ;
19659 char *kwnames[] = {
19660 (char *) "self",(char *) "m_metaDown", NULL
19661 };
19662
19663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19665 if (SWIG_arg_fail(1)) SWIG_fail;
19666 {
19667 arg2 = (bool)(SWIG_As_bool(obj1));
19668 if (SWIG_arg_fail(2)) SWIG_fail;
19669 }
19670 if (arg1) (arg1)->m_metaDown = arg2;
19671
19672 Py_INCREF(Py_None); resultobj = Py_None;
19673 return resultobj;
19674 fail:
19675 return NULL;
19676 }
19677
19678
19679 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19680 PyObject *resultobj;
19681 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19682 bool result;
19683 PyObject * obj0 = 0 ;
19684 char *kwnames[] = {
19685 (char *) "self", NULL
19686 };
19687
19688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19690 if (SWIG_arg_fail(1)) SWIG_fail;
19691 result = (bool) ((arg1)->m_metaDown);
19692
19693 {
19694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19695 }
19696 return resultobj;
19697 fail:
19698 return NULL;
19699 }
19700
19701
19702 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19703 PyObject *resultobj;
19704 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19705 bool arg2 ;
19706 PyObject * obj0 = 0 ;
19707 PyObject * obj1 = 0 ;
19708 char *kwnames[] = {
19709 (char *) "self",(char *) "m_scanCode", NULL
19710 };
19711
19712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19714 if (SWIG_arg_fail(1)) SWIG_fail;
19715 {
19716 arg2 = (bool)(SWIG_As_bool(obj1));
19717 if (SWIG_arg_fail(2)) SWIG_fail;
19718 }
19719 if (arg1) (arg1)->m_scanCode = arg2;
19720
19721 Py_INCREF(Py_None); resultobj = Py_None;
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19729 PyObject *resultobj;
19730 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19731 bool result;
19732 PyObject * obj0 = 0 ;
19733 char *kwnames[] = {
19734 (char *) "self", NULL
19735 };
19736
19737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19739 if (SWIG_arg_fail(1)) SWIG_fail;
19740 result = (bool) ((arg1)->m_scanCode);
19741
19742 {
19743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19744 }
19745 return resultobj;
19746 fail:
19747 return NULL;
19748 }
19749
19750
19751 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19752 PyObject *resultobj;
19753 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19754 unsigned int arg2 ;
19755 PyObject * obj0 = 0 ;
19756 PyObject * obj1 = 0 ;
19757 char *kwnames[] = {
19758 (char *) "self",(char *) "m_rawCode", NULL
19759 };
19760
19761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19763 if (SWIG_arg_fail(1)) SWIG_fail;
19764 {
19765 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19766 if (SWIG_arg_fail(2)) SWIG_fail;
19767 }
19768 if (arg1) (arg1)->m_rawCode = arg2;
19769
19770 Py_INCREF(Py_None); resultobj = Py_None;
19771 return resultobj;
19772 fail:
19773 return NULL;
19774 }
19775
19776
19777 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19778 PyObject *resultobj;
19779 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19780 unsigned int result;
19781 PyObject * obj0 = 0 ;
19782 char *kwnames[] = {
19783 (char *) "self", NULL
19784 };
19785
19786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19788 if (SWIG_arg_fail(1)) SWIG_fail;
19789 result = (unsigned int) ((arg1)->m_rawCode);
19790
19791 {
19792 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19793 }
19794 return resultobj;
19795 fail:
19796 return NULL;
19797 }
19798
19799
19800 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19801 PyObject *resultobj;
19802 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19803 unsigned int arg2 ;
19804 PyObject * obj0 = 0 ;
19805 PyObject * obj1 = 0 ;
19806 char *kwnames[] = {
19807 (char *) "self",(char *) "m_rawFlags", NULL
19808 };
19809
19810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19812 if (SWIG_arg_fail(1)) SWIG_fail;
19813 {
19814 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19815 if (SWIG_arg_fail(2)) SWIG_fail;
19816 }
19817 if (arg1) (arg1)->m_rawFlags = arg2;
19818
19819 Py_INCREF(Py_None); resultobj = Py_None;
19820 return resultobj;
19821 fail:
19822 return NULL;
19823 }
19824
19825
19826 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19827 PyObject *resultobj;
19828 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19829 unsigned int result;
19830 PyObject * obj0 = 0 ;
19831 char *kwnames[] = {
19832 (char *) "self", NULL
19833 };
19834
19835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19837 if (SWIG_arg_fail(1)) SWIG_fail;
19838 result = (unsigned int) ((arg1)->m_rawFlags);
19839
19840 {
19841 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19842 }
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19850 PyObject *obj;
19851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19852 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19853 Py_INCREF(obj);
19854 return Py_BuildValue((char *)"");
19855 }
19856 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19857 PyObject *resultobj;
19858 wxSize const &arg1_defvalue = wxDefaultSize ;
19859 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19860 int arg2 = (int) 0 ;
19861 wxSizeEvent *result;
19862 wxSize temp1 ;
19863 PyObject * obj0 = 0 ;
19864 PyObject * obj1 = 0 ;
19865 char *kwnames[] = {
19866 (char *) "sz",(char *) "winid", NULL
19867 };
19868
19869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19870 if (obj0) {
19871 {
19872 arg1 = &temp1;
19873 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19874 }
19875 }
19876 if (obj1) {
19877 {
19878 arg2 = (int)(SWIG_As_int(obj1));
19879 if (SWIG_arg_fail(2)) SWIG_fail;
19880 }
19881 }
19882 {
19883 PyThreadState* __tstate = wxPyBeginAllowThreads();
19884 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19885
19886 wxPyEndAllowThreads(__tstate);
19887 if (PyErr_Occurred()) SWIG_fail;
19888 }
19889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19890 return resultobj;
19891 fail:
19892 return NULL;
19893 }
19894
19895
19896 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19897 PyObject *resultobj;
19898 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19899 wxSize result;
19900 PyObject * obj0 = 0 ;
19901 char *kwnames[] = {
19902 (char *) "self", NULL
19903 };
19904
19905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19907 if (SWIG_arg_fail(1)) SWIG_fail;
19908 {
19909 PyThreadState* __tstate = wxPyBeginAllowThreads();
19910 result = ((wxSizeEvent const *)arg1)->GetSize();
19911
19912 wxPyEndAllowThreads(__tstate);
19913 if (PyErr_Occurred()) SWIG_fail;
19914 }
19915 {
19916 wxSize * resultptr;
19917 resultptr = new wxSize((wxSize &)(result));
19918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19919 }
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19927 PyObject *resultobj;
19928 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19929 wxRect result;
19930 PyObject * obj0 = 0 ;
19931 char *kwnames[] = {
19932 (char *) "self", NULL
19933 };
19934
19935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19937 if (SWIG_arg_fail(1)) SWIG_fail;
19938 {
19939 PyThreadState* __tstate = wxPyBeginAllowThreads();
19940 result = ((wxSizeEvent const *)arg1)->GetRect();
19941
19942 wxPyEndAllowThreads(__tstate);
19943 if (PyErr_Occurred()) SWIG_fail;
19944 }
19945 {
19946 wxRect * resultptr;
19947 resultptr = new wxRect((wxRect &)(result));
19948 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19949 }
19950 return resultobj;
19951 fail:
19952 return NULL;
19953 }
19954
19955
19956 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19957 PyObject *resultobj;
19958 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19959 wxRect arg2 ;
19960 PyObject * obj0 = 0 ;
19961 PyObject * obj1 = 0 ;
19962 char *kwnames[] = {
19963 (char *) "self",(char *) "rect", NULL
19964 };
19965
19966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19968 if (SWIG_arg_fail(1)) SWIG_fail;
19969 {
19970 wxRect * argp;
19971 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19972 if (SWIG_arg_fail(2)) SWIG_fail;
19973 if (argp == NULL) {
19974 SWIG_null_ref("wxRect");
19975 }
19976 if (SWIG_arg_fail(2)) SWIG_fail;
19977 arg2 = *argp;
19978 }
19979 {
19980 PyThreadState* __tstate = wxPyBeginAllowThreads();
19981 (arg1)->SetRect(arg2);
19982
19983 wxPyEndAllowThreads(__tstate);
19984 if (PyErr_Occurred()) SWIG_fail;
19985 }
19986 Py_INCREF(Py_None); resultobj = Py_None;
19987 return resultobj;
19988 fail:
19989 return NULL;
19990 }
19991
19992
19993 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19994 PyObject *resultobj;
19995 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19996 wxSize arg2 ;
19997 PyObject * obj0 = 0 ;
19998 PyObject * obj1 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "self",(char *) "size", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 {
20007 wxSize * argp;
20008 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20009 if (SWIG_arg_fail(2)) SWIG_fail;
20010 if (argp == NULL) {
20011 SWIG_null_ref("wxSize");
20012 }
20013 if (SWIG_arg_fail(2)) SWIG_fail;
20014 arg2 = *argp;
20015 }
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 wxSizeEvent_SetSize(arg1,arg2);
20019
20020 wxPyEndAllowThreads(__tstate);
20021 if (PyErr_Occurred()) SWIG_fail;
20022 }
20023 Py_INCREF(Py_None); resultobj = Py_None;
20024 return resultobj;
20025 fail:
20026 return NULL;
20027 }
20028
20029
20030 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20031 PyObject *resultobj;
20032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20033 wxSize *arg2 = (wxSize *) 0 ;
20034 PyObject * obj0 = 0 ;
20035 PyObject * obj1 = 0 ;
20036 char *kwnames[] = {
20037 (char *) "self",(char *) "m_size", NULL
20038 };
20039
20040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20042 if (SWIG_arg_fail(1)) SWIG_fail;
20043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20044 if (SWIG_arg_fail(2)) SWIG_fail;
20045 if (arg1) (arg1)->m_size = *arg2;
20046
20047 Py_INCREF(Py_None); resultobj = Py_None;
20048 return resultobj;
20049 fail:
20050 return NULL;
20051 }
20052
20053
20054 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20055 PyObject *resultobj;
20056 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20057 wxSize *result;
20058 PyObject * obj0 = 0 ;
20059 char *kwnames[] = {
20060 (char *) "self", NULL
20061 };
20062
20063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20065 if (SWIG_arg_fail(1)) SWIG_fail;
20066 result = (wxSize *)& ((arg1)->m_size);
20067
20068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20069 return resultobj;
20070 fail:
20071 return NULL;
20072 }
20073
20074
20075 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20076 PyObject *resultobj;
20077 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20078 wxRect *arg2 = (wxRect *) 0 ;
20079 PyObject * obj0 = 0 ;
20080 PyObject * obj1 = 0 ;
20081 char *kwnames[] = {
20082 (char *) "self",(char *) "m_rect", NULL
20083 };
20084
20085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20087 if (SWIG_arg_fail(1)) SWIG_fail;
20088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20089 if (SWIG_arg_fail(2)) SWIG_fail;
20090 if (arg1) (arg1)->m_rect = *arg2;
20091
20092 Py_INCREF(Py_None); resultobj = Py_None;
20093 return resultobj;
20094 fail:
20095 return NULL;
20096 }
20097
20098
20099 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20100 PyObject *resultobj;
20101 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20102 wxRect *result;
20103 PyObject * obj0 = 0 ;
20104 char *kwnames[] = {
20105 (char *) "self", NULL
20106 };
20107
20108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20110 if (SWIG_arg_fail(1)) SWIG_fail;
20111 result = (wxRect *)& ((arg1)->m_rect);
20112
20113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20114 return resultobj;
20115 fail:
20116 return NULL;
20117 }
20118
20119
20120 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20121 PyObject *obj;
20122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20123 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20124 Py_INCREF(obj);
20125 return Py_BuildValue((char *)"");
20126 }
20127 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20128 PyObject *resultobj;
20129 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20130 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20131 int arg2 = (int) 0 ;
20132 wxMoveEvent *result;
20133 wxPoint temp1 ;
20134 PyObject * obj0 = 0 ;
20135 PyObject * obj1 = 0 ;
20136 char *kwnames[] = {
20137 (char *) "pos",(char *) "winid", NULL
20138 };
20139
20140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20141 if (obj0) {
20142 {
20143 arg1 = &temp1;
20144 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20145 }
20146 }
20147 if (obj1) {
20148 {
20149 arg2 = (int)(SWIG_As_int(obj1));
20150 if (SWIG_arg_fail(2)) SWIG_fail;
20151 }
20152 }
20153 {
20154 PyThreadState* __tstate = wxPyBeginAllowThreads();
20155 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20156
20157 wxPyEndAllowThreads(__tstate);
20158 if (PyErr_Occurred()) SWIG_fail;
20159 }
20160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20161 return resultobj;
20162 fail:
20163 return NULL;
20164 }
20165
20166
20167 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20168 PyObject *resultobj;
20169 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20170 wxPoint result;
20171 PyObject * obj0 = 0 ;
20172 char *kwnames[] = {
20173 (char *) "self", NULL
20174 };
20175
20176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20178 if (SWIG_arg_fail(1)) SWIG_fail;
20179 {
20180 PyThreadState* __tstate = wxPyBeginAllowThreads();
20181 result = ((wxMoveEvent const *)arg1)->GetPosition();
20182
20183 wxPyEndAllowThreads(__tstate);
20184 if (PyErr_Occurred()) SWIG_fail;
20185 }
20186 {
20187 wxPoint * resultptr;
20188 resultptr = new wxPoint((wxPoint &)(result));
20189 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20190 }
20191 return resultobj;
20192 fail:
20193 return NULL;
20194 }
20195
20196
20197 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20198 PyObject *resultobj;
20199 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20200 wxRect result;
20201 PyObject * obj0 = 0 ;
20202 char *kwnames[] = {
20203 (char *) "self", NULL
20204 };
20205
20206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20208 if (SWIG_arg_fail(1)) SWIG_fail;
20209 {
20210 PyThreadState* __tstate = wxPyBeginAllowThreads();
20211 result = ((wxMoveEvent const *)arg1)->GetRect();
20212
20213 wxPyEndAllowThreads(__tstate);
20214 if (PyErr_Occurred()) SWIG_fail;
20215 }
20216 {
20217 wxRect * resultptr;
20218 resultptr = new wxRect((wxRect &)(result));
20219 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20220 }
20221 return resultobj;
20222 fail:
20223 return NULL;
20224 }
20225
20226
20227 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20228 PyObject *resultobj;
20229 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20230 wxRect *arg2 = 0 ;
20231 wxRect temp2 ;
20232 PyObject * obj0 = 0 ;
20233 PyObject * obj1 = 0 ;
20234 char *kwnames[] = {
20235 (char *) "self",(char *) "rect", NULL
20236 };
20237
20238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20240 if (SWIG_arg_fail(1)) SWIG_fail;
20241 {
20242 arg2 = &temp2;
20243 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20244 }
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 (arg1)->SetRect((wxRect const &)*arg2);
20248
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 Py_INCREF(Py_None); resultobj = Py_None;
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20260 PyObject *resultobj;
20261 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20262 wxPoint *arg2 = 0 ;
20263 wxPoint temp2 ;
20264 PyObject * obj0 = 0 ;
20265 PyObject * obj1 = 0 ;
20266 char *kwnames[] = {
20267 (char *) "self",(char *) "pos", NULL
20268 };
20269
20270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20272 if (SWIG_arg_fail(1)) SWIG_fail;
20273 {
20274 arg2 = &temp2;
20275 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20276 }
20277 {
20278 PyThreadState* __tstate = wxPyBeginAllowThreads();
20279 (arg1)->SetPosition((wxPoint const &)*arg2);
20280
20281 wxPyEndAllowThreads(__tstate);
20282 if (PyErr_Occurred()) SWIG_fail;
20283 }
20284 Py_INCREF(Py_None); resultobj = Py_None;
20285 return resultobj;
20286 fail:
20287 return NULL;
20288 }
20289
20290
20291 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20292 PyObject *obj;
20293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20294 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20295 Py_INCREF(obj);
20296 return Py_BuildValue((char *)"");
20297 }
20298 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 int arg1 = (int) 0 ;
20301 wxPaintEvent *result;
20302 PyObject * obj0 = 0 ;
20303 char *kwnames[] = {
20304 (char *) "Id", NULL
20305 };
20306
20307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20308 if (obj0) {
20309 {
20310 arg1 = (int)(SWIG_As_int(obj0));
20311 if (SWIG_arg_fail(1)) SWIG_fail;
20312 }
20313 }
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20317
20318 wxPyEndAllowThreads(__tstate);
20319 if (PyErr_Occurred()) SWIG_fail;
20320 }
20321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20322 return resultobj;
20323 fail:
20324 return NULL;
20325 }
20326
20327
20328 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20329 PyObject *obj;
20330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20331 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20332 Py_INCREF(obj);
20333 return Py_BuildValue((char *)"");
20334 }
20335 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20336 PyObject *resultobj;
20337 int arg1 = (int) 0 ;
20338 wxNcPaintEvent *result;
20339 PyObject * obj0 = 0 ;
20340 char *kwnames[] = {
20341 (char *) "winid", NULL
20342 };
20343
20344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20345 if (obj0) {
20346 {
20347 arg1 = (int)(SWIG_As_int(obj0));
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 }
20350 }
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20366 PyObject *obj;
20367 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20368 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20369 Py_INCREF(obj);
20370 return Py_BuildValue((char *)"");
20371 }
20372 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20373 PyObject *resultobj;
20374 int arg1 = (int) 0 ;
20375 wxDC *arg2 = (wxDC *) NULL ;
20376 wxEraseEvent *result;
20377 PyObject * obj0 = 0 ;
20378 PyObject * obj1 = 0 ;
20379 char *kwnames[] = {
20380 (char *) "Id",(char *) "dc", NULL
20381 };
20382
20383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20384 if (obj0) {
20385 {
20386 arg1 = (int)(SWIG_As_int(obj0));
20387 if (SWIG_arg_fail(1)) SWIG_fail;
20388 }
20389 }
20390 if (obj1) {
20391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20392 if (SWIG_arg_fail(2)) SWIG_fail;
20393 }
20394 {
20395 PyThreadState* __tstate = wxPyBeginAllowThreads();
20396 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20397
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20409 PyObject *resultobj;
20410 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20411 wxDC *result;
20412 PyObject * obj0 = 0 ;
20413 char *kwnames[] = {
20414 (char *) "self", NULL
20415 };
20416
20417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20419 if (SWIG_arg_fail(1)) SWIG_fail;
20420 {
20421 PyThreadState* __tstate = wxPyBeginAllowThreads();
20422 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20423
20424 wxPyEndAllowThreads(__tstate);
20425 if (PyErr_Occurred()) SWIG_fail;
20426 }
20427 {
20428 resultobj = wxPyMake_wxObject(result, 0);
20429 }
20430 return resultobj;
20431 fail:
20432 return NULL;
20433 }
20434
20435
20436 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20437 PyObject *obj;
20438 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20439 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20440 Py_INCREF(obj);
20441 return Py_BuildValue((char *)"");
20442 }
20443 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20444 PyObject *resultobj;
20445 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20446 int arg2 = (int) 0 ;
20447 wxFocusEvent *result;
20448 PyObject * obj0 = 0 ;
20449 PyObject * obj1 = 0 ;
20450 char *kwnames[] = {
20451 (char *) "type",(char *) "winid", NULL
20452 };
20453
20454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20455 if (obj0) {
20456 {
20457 arg1 = (wxEventType)(SWIG_As_int(obj0));
20458 if (SWIG_arg_fail(1)) SWIG_fail;
20459 }
20460 }
20461 if (obj1) {
20462 {
20463 arg2 = (int)(SWIG_As_int(obj1));
20464 if (SWIG_arg_fail(2)) SWIG_fail;
20465 }
20466 }
20467 {
20468 PyThreadState* __tstate = wxPyBeginAllowThreads();
20469 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20470
20471 wxPyEndAllowThreads(__tstate);
20472 if (PyErr_Occurred()) SWIG_fail;
20473 }
20474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20475 return resultobj;
20476 fail:
20477 return NULL;
20478 }
20479
20480
20481 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20482 PyObject *resultobj;
20483 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20484 wxWindow *result;
20485 PyObject * obj0 = 0 ;
20486 char *kwnames[] = {
20487 (char *) "self", NULL
20488 };
20489
20490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20492 if (SWIG_arg_fail(1)) SWIG_fail;
20493 {
20494 PyThreadState* __tstate = wxPyBeginAllowThreads();
20495 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20496
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 {
20501 resultobj = wxPyMake_wxObject(result, 0);
20502 }
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20510 PyObject *resultobj;
20511 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20512 wxWindow *arg2 = (wxWindow *) 0 ;
20513 PyObject * obj0 = 0 ;
20514 PyObject * obj1 = 0 ;
20515 char *kwnames[] = {
20516 (char *) "self",(char *) "win", NULL
20517 };
20518
20519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20521 if (SWIG_arg_fail(1)) SWIG_fail;
20522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20523 if (SWIG_arg_fail(2)) SWIG_fail;
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 (arg1)->SetWindow(arg2);
20527
20528 wxPyEndAllowThreads(__tstate);
20529 if (PyErr_Occurred()) SWIG_fail;
20530 }
20531 Py_INCREF(Py_None); resultobj = Py_None;
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20539 PyObject *obj;
20540 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20541 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20542 Py_INCREF(obj);
20543 return Py_BuildValue((char *)"");
20544 }
20545 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20546 PyObject *resultobj;
20547 wxWindow *arg1 = (wxWindow *) NULL ;
20548 wxChildFocusEvent *result;
20549 PyObject * obj0 = 0 ;
20550 char *kwnames[] = {
20551 (char *) "win", NULL
20552 };
20553
20554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20555 if (obj0) {
20556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20557 if (SWIG_arg_fail(1)) SWIG_fail;
20558 }
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj;
20575 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20576 wxWindow *result;
20577 PyObject * obj0 = 0 ;
20578 char *kwnames[] = {
20579 (char *) "self", NULL
20580 };
20581
20582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20584 if (SWIG_arg_fail(1)) SWIG_fail;
20585 {
20586 PyThreadState* __tstate = wxPyBeginAllowThreads();
20587 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20588
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = wxPyMake_wxObject(result, 0);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20602 PyObject *obj;
20603 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20604 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20605 Py_INCREF(obj);
20606 return Py_BuildValue((char *)"");
20607 }
20608 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20609 PyObject *resultobj;
20610 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20611 bool arg2 = (bool) true ;
20612 int arg3 = (int) 0 ;
20613 wxActivateEvent *result;
20614 PyObject * obj0 = 0 ;
20615 PyObject * obj1 = 0 ;
20616 PyObject * obj2 = 0 ;
20617 char *kwnames[] = {
20618 (char *) "type",(char *) "active",(char *) "Id", NULL
20619 };
20620
20621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20622 if (obj0) {
20623 {
20624 arg1 = (wxEventType)(SWIG_As_int(obj0));
20625 if (SWIG_arg_fail(1)) SWIG_fail;
20626 }
20627 }
20628 if (obj1) {
20629 {
20630 arg2 = (bool)(SWIG_As_bool(obj1));
20631 if (SWIG_arg_fail(2)) SWIG_fail;
20632 }
20633 }
20634 if (obj2) {
20635 {
20636 arg3 = (int)(SWIG_As_int(obj2));
20637 if (SWIG_arg_fail(3)) SWIG_fail;
20638 }
20639 }
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20643
20644 wxPyEndAllowThreads(__tstate);
20645 if (PyErr_Occurred()) SWIG_fail;
20646 }
20647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20648 return resultobj;
20649 fail:
20650 return NULL;
20651 }
20652
20653
20654 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20655 PyObject *resultobj;
20656 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20657 bool result;
20658 PyObject * obj0 = 0 ;
20659 char *kwnames[] = {
20660 (char *) "self", NULL
20661 };
20662
20663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20665 if (SWIG_arg_fail(1)) SWIG_fail;
20666 {
20667 PyThreadState* __tstate = wxPyBeginAllowThreads();
20668 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20669
20670 wxPyEndAllowThreads(__tstate);
20671 if (PyErr_Occurred()) SWIG_fail;
20672 }
20673 {
20674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20675 }
20676 return resultobj;
20677 fail:
20678 return NULL;
20679 }
20680
20681
20682 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20683 PyObject *obj;
20684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20685 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20686 Py_INCREF(obj);
20687 return Py_BuildValue((char *)"");
20688 }
20689 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20690 PyObject *resultobj;
20691 int arg1 = (int) 0 ;
20692 wxInitDialogEvent *result;
20693 PyObject * obj0 = 0 ;
20694 char *kwnames[] = {
20695 (char *) "Id", NULL
20696 };
20697
20698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20699 if (obj0) {
20700 {
20701 arg1 = (int)(SWIG_As_int(obj0));
20702 if (SWIG_arg_fail(1)) SWIG_fail;
20703 }
20704 }
20705 {
20706 PyThreadState* __tstate = wxPyBeginAllowThreads();
20707 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20708
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20720 PyObject *obj;
20721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20722 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20723 Py_INCREF(obj);
20724 return Py_BuildValue((char *)"");
20725 }
20726 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20727 PyObject *resultobj;
20728 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20729 int arg2 = (int) 0 ;
20730 wxMenu *arg3 = (wxMenu *) NULL ;
20731 wxMenuEvent *result;
20732 PyObject * obj0 = 0 ;
20733 PyObject * obj1 = 0 ;
20734 PyObject * obj2 = 0 ;
20735 char *kwnames[] = {
20736 (char *) "type",(char *) "winid",(char *) "menu", NULL
20737 };
20738
20739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20740 if (obj0) {
20741 {
20742 arg1 = (wxEventType)(SWIG_As_int(obj0));
20743 if (SWIG_arg_fail(1)) SWIG_fail;
20744 }
20745 }
20746 if (obj1) {
20747 {
20748 arg2 = (int)(SWIG_As_int(obj1));
20749 if (SWIG_arg_fail(2)) SWIG_fail;
20750 }
20751 }
20752 if (obj2) {
20753 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20754 if (SWIG_arg_fail(3)) SWIG_fail;
20755 }
20756 {
20757 PyThreadState* __tstate = wxPyBeginAllowThreads();
20758 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20759
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20764 return resultobj;
20765 fail:
20766 return NULL;
20767 }
20768
20769
20770 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20771 PyObject *resultobj;
20772 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20773 int result;
20774 PyObject * obj0 = 0 ;
20775 char *kwnames[] = {
20776 (char *) "self", NULL
20777 };
20778
20779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20781 if (SWIG_arg_fail(1)) SWIG_fail;
20782 {
20783 PyThreadState* __tstate = wxPyBeginAllowThreads();
20784 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20785
20786 wxPyEndAllowThreads(__tstate);
20787 if (PyErr_Occurred()) SWIG_fail;
20788 }
20789 {
20790 resultobj = SWIG_From_int((int)(result));
20791 }
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20799 PyObject *resultobj;
20800 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20801 bool result;
20802 PyObject * obj0 = 0 ;
20803 char *kwnames[] = {
20804 (char *) "self", NULL
20805 };
20806
20807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20809 if (SWIG_arg_fail(1)) SWIG_fail;
20810 {
20811 PyThreadState* __tstate = wxPyBeginAllowThreads();
20812 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20813
20814 wxPyEndAllowThreads(__tstate);
20815 if (PyErr_Occurred()) SWIG_fail;
20816 }
20817 {
20818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20819 }
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj;
20828 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20829 wxMenu *result;
20830 PyObject * obj0 = 0 ;
20831 char *kwnames[] = {
20832 (char *) "self", NULL
20833 };
20834
20835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20837 if (SWIG_arg_fail(1)) SWIG_fail;
20838 {
20839 PyThreadState* __tstate = wxPyBeginAllowThreads();
20840 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20841
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 {
20846 resultobj = wxPyMake_wxObject(result, 0);
20847 }
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20855 PyObject *obj;
20856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20857 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20858 Py_INCREF(obj);
20859 return Py_BuildValue((char *)"");
20860 }
20861 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20862 PyObject *resultobj;
20863 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20864 int arg2 = (int) 0 ;
20865 wxCloseEvent *result;
20866 PyObject * obj0 = 0 ;
20867 PyObject * obj1 = 0 ;
20868 char *kwnames[] = {
20869 (char *) "type",(char *) "winid", NULL
20870 };
20871
20872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20873 if (obj0) {
20874 {
20875 arg1 = (wxEventType)(SWIG_As_int(obj0));
20876 if (SWIG_arg_fail(1)) SWIG_fail;
20877 }
20878 }
20879 if (obj1) {
20880 {
20881 arg2 = (int)(SWIG_As_int(obj1));
20882 if (SWIG_arg_fail(2)) SWIG_fail;
20883 }
20884 }
20885 {
20886 PyThreadState* __tstate = wxPyBeginAllowThreads();
20887 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20888
20889 wxPyEndAllowThreads(__tstate);
20890 if (PyErr_Occurred()) SWIG_fail;
20891 }
20892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20893 return resultobj;
20894 fail:
20895 return NULL;
20896 }
20897
20898
20899 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20900 PyObject *resultobj;
20901 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20902 bool arg2 ;
20903 PyObject * obj0 = 0 ;
20904 PyObject * obj1 = 0 ;
20905 char *kwnames[] = {
20906 (char *) "self",(char *) "logOff", NULL
20907 };
20908
20909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20911 if (SWIG_arg_fail(1)) SWIG_fail;
20912 {
20913 arg2 = (bool)(SWIG_As_bool(obj1));
20914 if (SWIG_arg_fail(2)) SWIG_fail;
20915 }
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 (arg1)->SetLoggingOff(arg2);
20919
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 Py_INCREF(Py_None); resultobj = Py_None;
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20931 PyObject *resultobj;
20932 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20933 bool result;
20934 PyObject * obj0 = 0 ;
20935 char *kwnames[] = {
20936 (char *) "self", NULL
20937 };
20938
20939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20941 if (SWIG_arg_fail(1)) SWIG_fail;
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20945
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 {
20950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20951 }
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20959 PyObject *resultobj;
20960 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20961 bool arg2 = (bool) true ;
20962 PyObject * obj0 = 0 ;
20963 PyObject * obj1 = 0 ;
20964 char *kwnames[] = {
20965 (char *) "self",(char *) "veto", NULL
20966 };
20967
20968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20970 if (SWIG_arg_fail(1)) SWIG_fail;
20971 if (obj1) {
20972 {
20973 arg2 = (bool)(SWIG_As_bool(obj1));
20974 if (SWIG_arg_fail(2)) SWIG_fail;
20975 }
20976 }
20977 {
20978 PyThreadState* __tstate = wxPyBeginAllowThreads();
20979 (arg1)->Veto(arg2);
20980
20981 wxPyEndAllowThreads(__tstate);
20982 if (PyErr_Occurred()) SWIG_fail;
20983 }
20984 Py_INCREF(Py_None); resultobj = Py_None;
20985 return resultobj;
20986 fail:
20987 return NULL;
20988 }
20989
20990
20991 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20992 PyObject *resultobj;
20993 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20994 bool result;
20995 PyObject * obj0 = 0 ;
20996 char *kwnames[] = {
20997 (char *) "self", NULL
20998 };
20999
21000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21002 if (SWIG_arg_fail(1)) SWIG_fail;
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21006
21007 wxPyEndAllowThreads(__tstate);
21008 if (PyErr_Occurred()) SWIG_fail;
21009 }
21010 {
21011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21012 }
21013 return resultobj;
21014 fail:
21015 return NULL;
21016 }
21017
21018
21019 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21020 PyObject *resultobj;
21021 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21022 bool arg2 ;
21023 PyObject * obj0 = 0 ;
21024 PyObject * obj1 = 0 ;
21025 char *kwnames[] = {
21026 (char *) "self",(char *) "canVeto", NULL
21027 };
21028
21029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21031 if (SWIG_arg_fail(1)) SWIG_fail;
21032 {
21033 arg2 = (bool)(SWIG_As_bool(obj1));
21034 if (SWIG_arg_fail(2)) SWIG_fail;
21035 }
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 (arg1)->SetCanVeto(arg2);
21039
21040 wxPyEndAllowThreads(__tstate);
21041 if (PyErr_Occurred()) SWIG_fail;
21042 }
21043 Py_INCREF(Py_None); resultobj = Py_None;
21044 return resultobj;
21045 fail:
21046 return NULL;
21047 }
21048
21049
21050 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21051 PyObject *resultobj;
21052 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21053 bool result;
21054 PyObject * obj0 = 0 ;
21055 char *kwnames[] = {
21056 (char *) "self", NULL
21057 };
21058
21059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21061 if (SWIG_arg_fail(1)) SWIG_fail;
21062 {
21063 PyThreadState* __tstate = wxPyBeginAllowThreads();
21064 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21065
21066 wxPyEndAllowThreads(__tstate);
21067 if (PyErr_Occurred()) SWIG_fail;
21068 }
21069 {
21070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21071 }
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21079 PyObject *obj;
21080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21081 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21082 Py_INCREF(obj);
21083 return Py_BuildValue((char *)"");
21084 }
21085 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21086 PyObject *resultobj;
21087 int arg1 = (int) 0 ;
21088 bool arg2 = (bool) false ;
21089 wxShowEvent *result;
21090 PyObject * obj0 = 0 ;
21091 PyObject * obj1 = 0 ;
21092 char *kwnames[] = {
21093 (char *) "winid",(char *) "show", NULL
21094 };
21095
21096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21097 if (obj0) {
21098 {
21099 arg1 = (int)(SWIG_As_int(obj0));
21100 if (SWIG_arg_fail(1)) SWIG_fail;
21101 }
21102 }
21103 if (obj1) {
21104 {
21105 arg2 = (bool)(SWIG_As_bool(obj1));
21106 if (SWIG_arg_fail(2)) SWIG_fail;
21107 }
21108 }
21109 {
21110 PyThreadState* __tstate = wxPyBeginAllowThreads();
21111 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21112
21113 wxPyEndAllowThreads(__tstate);
21114 if (PyErr_Occurred()) SWIG_fail;
21115 }
21116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21117 return resultobj;
21118 fail:
21119 return NULL;
21120 }
21121
21122
21123 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21124 PyObject *resultobj;
21125 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21126 bool arg2 ;
21127 PyObject * obj0 = 0 ;
21128 PyObject * obj1 = 0 ;
21129 char *kwnames[] = {
21130 (char *) "self",(char *) "show", NULL
21131 };
21132
21133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21135 if (SWIG_arg_fail(1)) SWIG_fail;
21136 {
21137 arg2 = (bool)(SWIG_As_bool(obj1));
21138 if (SWIG_arg_fail(2)) SWIG_fail;
21139 }
21140 {
21141 PyThreadState* __tstate = wxPyBeginAllowThreads();
21142 (arg1)->SetShow(arg2);
21143
21144 wxPyEndAllowThreads(__tstate);
21145 if (PyErr_Occurred()) SWIG_fail;
21146 }
21147 Py_INCREF(Py_None); resultobj = Py_None;
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21155 PyObject *resultobj;
21156 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21157 bool result;
21158 PyObject * obj0 = 0 ;
21159 char *kwnames[] = {
21160 (char *) "self", NULL
21161 };
21162
21163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21165 if (SWIG_arg_fail(1)) SWIG_fail;
21166 {
21167 PyThreadState* __tstate = wxPyBeginAllowThreads();
21168 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21169
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 {
21174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21175 }
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21183 PyObject *obj;
21184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21185 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21186 Py_INCREF(obj);
21187 return Py_BuildValue((char *)"");
21188 }
21189 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21190 PyObject *resultobj;
21191 int arg1 = (int) 0 ;
21192 bool arg2 = (bool) true ;
21193 wxIconizeEvent *result;
21194 PyObject * obj0 = 0 ;
21195 PyObject * obj1 = 0 ;
21196 char *kwnames[] = {
21197 (char *) "id",(char *) "iconized", NULL
21198 };
21199
21200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21201 if (obj0) {
21202 {
21203 arg1 = (int)(SWIG_As_int(obj0));
21204 if (SWIG_arg_fail(1)) SWIG_fail;
21205 }
21206 }
21207 if (obj1) {
21208 {
21209 arg2 = (bool)(SWIG_As_bool(obj1));
21210 if (SWIG_arg_fail(2)) SWIG_fail;
21211 }
21212 }
21213 {
21214 PyThreadState* __tstate = wxPyBeginAllowThreads();
21215 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21216
21217 wxPyEndAllowThreads(__tstate);
21218 if (PyErr_Occurred()) SWIG_fail;
21219 }
21220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21228 PyObject *resultobj;
21229 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21230 bool result;
21231 PyObject * obj0 = 0 ;
21232 char *kwnames[] = {
21233 (char *) "self", NULL
21234 };
21235
21236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21238 if (SWIG_arg_fail(1)) SWIG_fail;
21239 {
21240 PyThreadState* __tstate = wxPyBeginAllowThreads();
21241 result = (bool)(arg1)->Iconized();
21242
21243 wxPyEndAllowThreads(__tstate);
21244 if (PyErr_Occurred()) SWIG_fail;
21245 }
21246 {
21247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21248 }
21249 return resultobj;
21250 fail:
21251 return NULL;
21252 }
21253
21254
21255 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21256 PyObject *obj;
21257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21258 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21259 Py_INCREF(obj);
21260 return Py_BuildValue((char *)"");
21261 }
21262 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21263 PyObject *resultobj;
21264 int arg1 = (int) 0 ;
21265 wxMaximizeEvent *result;
21266 PyObject * obj0 = 0 ;
21267 char *kwnames[] = {
21268 (char *) "id", NULL
21269 };
21270
21271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21272 if (obj0) {
21273 {
21274 arg1 = (int)(SWIG_As_int(obj0));
21275 if (SWIG_arg_fail(1)) SWIG_fail;
21276 }
21277 }
21278 {
21279 PyThreadState* __tstate = wxPyBeginAllowThreads();
21280 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21281
21282 wxPyEndAllowThreads(__tstate);
21283 if (PyErr_Occurred()) SWIG_fail;
21284 }
21285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21286 return resultobj;
21287 fail:
21288 return NULL;
21289 }
21290
21291
21292 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21293 PyObject *obj;
21294 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21295 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21296 Py_INCREF(obj);
21297 return Py_BuildValue((char *)"");
21298 }
21299 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21300 PyObject *resultobj;
21301 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21302 wxPoint result;
21303 PyObject * obj0 = 0 ;
21304 char *kwnames[] = {
21305 (char *) "self", NULL
21306 };
21307
21308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21310 if (SWIG_arg_fail(1)) SWIG_fail;
21311 {
21312 PyThreadState* __tstate = wxPyBeginAllowThreads();
21313 result = (arg1)->GetPosition();
21314
21315 wxPyEndAllowThreads(__tstate);
21316 if (PyErr_Occurred()) SWIG_fail;
21317 }
21318 {
21319 wxPoint * resultptr;
21320 resultptr = new wxPoint((wxPoint &)(result));
21321 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21322 }
21323 return resultobj;
21324 fail:
21325 return NULL;
21326 }
21327
21328
21329 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21330 PyObject *resultobj;
21331 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21332 int result;
21333 PyObject * obj0 = 0 ;
21334 char *kwnames[] = {
21335 (char *) "self", NULL
21336 };
21337
21338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21340 if (SWIG_arg_fail(1)) SWIG_fail;
21341 {
21342 PyThreadState* __tstate = wxPyBeginAllowThreads();
21343 result = (int)(arg1)->GetNumberOfFiles();
21344
21345 wxPyEndAllowThreads(__tstate);
21346 if (PyErr_Occurred()) SWIG_fail;
21347 }
21348 {
21349 resultobj = SWIG_From_int((int)(result));
21350 }
21351 return resultobj;
21352 fail:
21353 return NULL;
21354 }
21355
21356
21357 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21358 PyObject *resultobj;
21359 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21360 PyObject *result;
21361 PyObject * obj0 = 0 ;
21362 char *kwnames[] = {
21363 (char *) "self", NULL
21364 };
21365
21366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21368 if (SWIG_arg_fail(1)) SWIG_fail;
21369 {
21370 PyThreadState* __tstate = wxPyBeginAllowThreads();
21371 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21372
21373 wxPyEndAllowThreads(__tstate);
21374 if (PyErr_Occurred()) SWIG_fail;
21375 }
21376 resultobj = result;
21377 return resultobj;
21378 fail:
21379 return NULL;
21380 }
21381
21382
21383 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21384 PyObject *obj;
21385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21386 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21387 Py_INCREF(obj);
21388 return Py_BuildValue((char *)"");
21389 }
21390 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21391 PyObject *resultobj;
21392 int arg1 = (int) 0 ;
21393 wxUpdateUIEvent *result;
21394 PyObject * obj0 = 0 ;
21395 char *kwnames[] = {
21396 (char *) "commandId", NULL
21397 };
21398
21399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21400 if (obj0) {
21401 {
21402 arg1 = (int)(SWIG_As_int(obj0));
21403 if (SWIG_arg_fail(1)) SWIG_fail;
21404 }
21405 }
21406 {
21407 PyThreadState* __tstate = wxPyBeginAllowThreads();
21408 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21409
21410 wxPyEndAllowThreads(__tstate);
21411 if (PyErr_Occurred()) SWIG_fail;
21412 }
21413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21414 return resultobj;
21415 fail:
21416 return NULL;
21417 }
21418
21419
21420 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21421 PyObject *resultobj;
21422 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21423 bool result;
21424 PyObject * obj0 = 0 ;
21425 char *kwnames[] = {
21426 (char *) "self", NULL
21427 };
21428
21429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21431 if (SWIG_arg_fail(1)) SWIG_fail;
21432 {
21433 PyThreadState* __tstate = wxPyBeginAllowThreads();
21434 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21435
21436 wxPyEndAllowThreads(__tstate);
21437 if (PyErr_Occurred()) SWIG_fail;
21438 }
21439 {
21440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21441 }
21442 return resultobj;
21443 fail:
21444 return NULL;
21445 }
21446
21447
21448 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21449 PyObject *resultobj;
21450 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21451 bool result;
21452 PyObject * obj0 = 0 ;
21453 char *kwnames[] = {
21454 (char *) "self", NULL
21455 };
21456
21457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21459 if (SWIG_arg_fail(1)) SWIG_fail;
21460 {
21461 PyThreadState* __tstate = wxPyBeginAllowThreads();
21462 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21463
21464 wxPyEndAllowThreads(__tstate);
21465 if (PyErr_Occurred()) SWIG_fail;
21466 }
21467 {
21468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21469 }
21470 return resultobj;
21471 fail:
21472 return NULL;
21473 }
21474
21475
21476 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21477 PyObject *resultobj;
21478 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21479 wxString result;
21480 PyObject * obj0 = 0 ;
21481 char *kwnames[] = {
21482 (char *) "self", NULL
21483 };
21484
21485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21487 if (SWIG_arg_fail(1)) SWIG_fail;
21488 {
21489 PyThreadState* __tstate = wxPyBeginAllowThreads();
21490 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21491
21492 wxPyEndAllowThreads(__tstate);
21493 if (PyErr_Occurred()) SWIG_fail;
21494 }
21495 {
21496 #if wxUSE_UNICODE
21497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21498 #else
21499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21500 #endif
21501 }
21502 return resultobj;
21503 fail:
21504 return NULL;
21505 }
21506
21507
21508 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21509 PyObject *resultobj;
21510 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21511 bool result;
21512 PyObject * obj0 = 0 ;
21513 char *kwnames[] = {
21514 (char *) "self", NULL
21515 };
21516
21517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21519 if (SWIG_arg_fail(1)) SWIG_fail;
21520 {
21521 PyThreadState* __tstate = wxPyBeginAllowThreads();
21522 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21523
21524 wxPyEndAllowThreads(__tstate);
21525 if (PyErr_Occurred()) SWIG_fail;
21526 }
21527 {
21528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21529 }
21530 return resultobj;
21531 fail:
21532 return NULL;
21533 }
21534
21535
21536 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21537 PyObject *resultobj;
21538 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21539 bool result;
21540 PyObject * obj0 = 0 ;
21541 char *kwnames[] = {
21542 (char *) "self", NULL
21543 };
21544
21545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21547 if (SWIG_arg_fail(1)) SWIG_fail;
21548 {
21549 PyThreadState* __tstate = wxPyBeginAllowThreads();
21550 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21551
21552 wxPyEndAllowThreads(__tstate);
21553 if (PyErr_Occurred()) SWIG_fail;
21554 }
21555 {
21556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21557 }
21558 return resultobj;
21559 fail:
21560 return NULL;
21561 }
21562
21563
21564 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21565 PyObject *resultobj;
21566 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21567 bool result;
21568 PyObject * obj0 = 0 ;
21569 char *kwnames[] = {
21570 (char *) "self", NULL
21571 };
21572
21573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21575 if (SWIG_arg_fail(1)) SWIG_fail;
21576 {
21577 PyThreadState* __tstate = wxPyBeginAllowThreads();
21578 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21579
21580 wxPyEndAllowThreads(__tstate);
21581 if (PyErr_Occurred()) SWIG_fail;
21582 }
21583 {
21584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21585 }
21586 return resultobj;
21587 fail:
21588 return NULL;
21589 }
21590
21591
21592 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21593 PyObject *resultobj;
21594 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21595 bool arg2 ;
21596 PyObject * obj0 = 0 ;
21597 PyObject * obj1 = 0 ;
21598 char *kwnames[] = {
21599 (char *) "self",(char *) "check", NULL
21600 };
21601
21602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21604 if (SWIG_arg_fail(1)) SWIG_fail;
21605 {
21606 arg2 = (bool)(SWIG_As_bool(obj1));
21607 if (SWIG_arg_fail(2)) SWIG_fail;
21608 }
21609 {
21610 PyThreadState* __tstate = wxPyBeginAllowThreads();
21611 (arg1)->Check(arg2);
21612
21613 wxPyEndAllowThreads(__tstate);
21614 if (PyErr_Occurred()) SWIG_fail;
21615 }
21616 Py_INCREF(Py_None); resultobj = Py_None;
21617 return resultobj;
21618 fail:
21619 return NULL;
21620 }
21621
21622
21623 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21624 PyObject *resultobj;
21625 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21626 bool arg2 ;
21627 PyObject * obj0 = 0 ;
21628 PyObject * obj1 = 0 ;
21629 char *kwnames[] = {
21630 (char *) "self",(char *) "enable", NULL
21631 };
21632
21633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21635 if (SWIG_arg_fail(1)) SWIG_fail;
21636 {
21637 arg2 = (bool)(SWIG_As_bool(obj1));
21638 if (SWIG_arg_fail(2)) SWIG_fail;
21639 }
21640 {
21641 PyThreadState* __tstate = wxPyBeginAllowThreads();
21642 (arg1)->Enable(arg2);
21643
21644 wxPyEndAllowThreads(__tstate);
21645 if (PyErr_Occurred()) SWIG_fail;
21646 }
21647 Py_INCREF(Py_None); resultobj = Py_None;
21648 return resultobj;
21649 fail:
21650 return NULL;
21651 }
21652
21653
21654 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21655 PyObject *resultobj;
21656 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21657 wxString *arg2 = 0 ;
21658 bool temp2 = false ;
21659 PyObject * obj0 = 0 ;
21660 PyObject * obj1 = 0 ;
21661 char *kwnames[] = {
21662 (char *) "self",(char *) "text", NULL
21663 };
21664
21665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21667 if (SWIG_arg_fail(1)) SWIG_fail;
21668 {
21669 arg2 = wxString_in_helper(obj1);
21670 if (arg2 == NULL) SWIG_fail;
21671 temp2 = true;
21672 }
21673 {
21674 PyThreadState* __tstate = wxPyBeginAllowThreads();
21675 (arg1)->SetText((wxString const &)*arg2);
21676
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 Py_INCREF(Py_None); resultobj = Py_None;
21681 {
21682 if (temp2)
21683 delete arg2;
21684 }
21685 return resultobj;
21686 fail:
21687 {
21688 if (temp2)
21689 delete arg2;
21690 }
21691 return NULL;
21692 }
21693
21694
21695 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21696 PyObject *resultobj;
21697 long arg1 ;
21698 PyObject * obj0 = 0 ;
21699 char *kwnames[] = {
21700 (char *) "updateInterval", NULL
21701 };
21702
21703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21704 {
21705 arg1 = (long)(SWIG_As_long(obj0));
21706 if (SWIG_arg_fail(1)) SWIG_fail;
21707 }
21708 {
21709 PyThreadState* __tstate = wxPyBeginAllowThreads();
21710 wxUpdateUIEvent::SetUpdateInterval(arg1);
21711
21712 wxPyEndAllowThreads(__tstate);
21713 if (PyErr_Occurred()) SWIG_fail;
21714 }
21715 Py_INCREF(Py_None); resultobj = Py_None;
21716 return resultobj;
21717 fail:
21718 return NULL;
21719 }
21720
21721
21722 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21723 PyObject *resultobj;
21724 long result;
21725 char *kwnames[] = {
21726 NULL
21727 };
21728
21729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21730 {
21731 PyThreadState* __tstate = wxPyBeginAllowThreads();
21732 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21733
21734 wxPyEndAllowThreads(__tstate);
21735 if (PyErr_Occurred()) SWIG_fail;
21736 }
21737 {
21738 resultobj = SWIG_From_long((long)(result));
21739 }
21740 return resultobj;
21741 fail:
21742 return NULL;
21743 }
21744
21745
21746 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21747 PyObject *resultobj;
21748 wxWindow *arg1 = (wxWindow *) 0 ;
21749 bool result;
21750 PyObject * obj0 = 0 ;
21751 char *kwnames[] = {
21752 (char *) "win", NULL
21753 };
21754
21755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21757 if (SWIG_arg_fail(1)) SWIG_fail;
21758 {
21759 PyThreadState* __tstate = wxPyBeginAllowThreads();
21760 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21761
21762 wxPyEndAllowThreads(__tstate);
21763 if (PyErr_Occurred()) SWIG_fail;
21764 }
21765 {
21766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21767 }
21768 return resultobj;
21769 fail:
21770 return NULL;
21771 }
21772
21773
21774 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21775 PyObject *resultobj;
21776 char *kwnames[] = {
21777 NULL
21778 };
21779
21780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21781 {
21782 PyThreadState* __tstate = wxPyBeginAllowThreads();
21783 wxUpdateUIEvent::ResetUpdateTime();
21784
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 Py_INCREF(Py_None); resultobj = Py_None;
21789 return resultobj;
21790 fail:
21791 return NULL;
21792 }
21793
21794
21795 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21796 PyObject *resultobj;
21797 wxUpdateUIMode arg1 ;
21798 PyObject * obj0 = 0 ;
21799 char *kwnames[] = {
21800 (char *) "mode", NULL
21801 };
21802
21803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21804 {
21805 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21806 if (SWIG_arg_fail(1)) SWIG_fail;
21807 }
21808 {
21809 PyThreadState* __tstate = wxPyBeginAllowThreads();
21810 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21811
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 Py_INCREF(Py_None); resultobj = Py_None;
21816 return resultobj;
21817 fail:
21818 return NULL;
21819 }
21820
21821
21822 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj;
21824 wxUpdateUIMode result;
21825 char *kwnames[] = {
21826 NULL
21827 };
21828
21829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21830 {
21831 PyThreadState* __tstate = wxPyBeginAllowThreads();
21832 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21833
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 resultobj = SWIG_From_int((result));
21838 return resultobj;
21839 fail:
21840 return NULL;
21841 }
21842
21843
21844 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21845 PyObject *obj;
21846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21847 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21848 Py_INCREF(obj);
21849 return Py_BuildValue((char *)"");
21850 }
21851 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21852 PyObject *resultobj;
21853 wxSysColourChangedEvent *result;
21854 char *kwnames[] = {
21855 NULL
21856 };
21857
21858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21859 {
21860 PyThreadState* __tstate = wxPyBeginAllowThreads();
21861 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21862
21863 wxPyEndAllowThreads(__tstate);
21864 if (PyErr_Occurred()) SWIG_fail;
21865 }
21866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21867 return resultobj;
21868 fail:
21869 return NULL;
21870 }
21871
21872
21873 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21874 PyObject *obj;
21875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21876 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21877 Py_INCREF(obj);
21878 return Py_BuildValue((char *)"");
21879 }
21880 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21881 PyObject *resultobj;
21882 int arg1 = (int) 0 ;
21883 wxWindow *arg2 = (wxWindow *) NULL ;
21884 wxMouseCaptureChangedEvent *result;
21885 PyObject * obj0 = 0 ;
21886 PyObject * obj1 = 0 ;
21887 char *kwnames[] = {
21888 (char *) "winid",(char *) "gainedCapture", NULL
21889 };
21890
21891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21892 if (obj0) {
21893 {
21894 arg1 = (int)(SWIG_As_int(obj0));
21895 if (SWIG_arg_fail(1)) SWIG_fail;
21896 }
21897 }
21898 if (obj1) {
21899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21900 if (SWIG_arg_fail(2)) SWIG_fail;
21901 }
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21905
21906 wxPyEndAllowThreads(__tstate);
21907 if (PyErr_Occurred()) SWIG_fail;
21908 }
21909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj;
21918 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21919 wxWindow *result;
21920 PyObject * obj0 = 0 ;
21921 char *kwnames[] = {
21922 (char *) "self", NULL
21923 };
21924
21925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21927 if (SWIG_arg_fail(1)) SWIG_fail;
21928 {
21929 PyThreadState* __tstate = wxPyBeginAllowThreads();
21930 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21931
21932 wxPyEndAllowThreads(__tstate);
21933 if (PyErr_Occurred()) SWIG_fail;
21934 }
21935 {
21936 resultobj = wxPyMake_wxObject(result, 0);
21937 }
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21945 PyObject *obj;
21946 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21947 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21948 Py_INCREF(obj);
21949 return Py_BuildValue((char *)"");
21950 }
21951 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21952 PyObject *resultobj;
21953 wxDisplayChangedEvent *result;
21954 char *kwnames[] = {
21955 NULL
21956 };
21957
21958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21959 {
21960 PyThreadState* __tstate = wxPyBeginAllowThreads();
21961 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21962
21963 wxPyEndAllowThreads(__tstate);
21964 if (PyErr_Occurred()) SWIG_fail;
21965 }
21966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21974 PyObject *obj;
21975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21976 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21977 Py_INCREF(obj);
21978 return Py_BuildValue((char *)"");
21979 }
21980 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21981 PyObject *resultobj;
21982 int arg1 = (int) 0 ;
21983 wxPaletteChangedEvent *result;
21984 PyObject * obj0 = 0 ;
21985 char *kwnames[] = {
21986 (char *) "id", NULL
21987 };
21988
21989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21990 if (obj0) {
21991 {
21992 arg1 = (int)(SWIG_As_int(obj0));
21993 if (SWIG_arg_fail(1)) SWIG_fail;
21994 }
21995 }
21996 {
21997 PyThreadState* __tstate = wxPyBeginAllowThreads();
21998 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21999
22000 wxPyEndAllowThreads(__tstate);
22001 if (PyErr_Occurred()) SWIG_fail;
22002 }
22003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22004 return resultobj;
22005 fail:
22006 return NULL;
22007 }
22008
22009
22010 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22011 PyObject *resultobj;
22012 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22013 wxWindow *arg2 = (wxWindow *) 0 ;
22014 PyObject * obj0 = 0 ;
22015 PyObject * obj1 = 0 ;
22016 char *kwnames[] = {
22017 (char *) "self",(char *) "win", NULL
22018 };
22019
22020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22022 if (SWIG_arg_fail(1)) SWIG_fail;
22023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22024 if (SWIG_arg_fail(2)) SWIG_fail;
22025 {
22026 PyThreadState* __tstate = wxPyBeginAllowThreads();
22027 (arg1)->SetChangedWindow(arg2);
22028
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 Py_INCREF(Py_None); resultobj = Py_None;
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22040 PyObject *resultobj;
22041 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22042 wxWindow *result;
22043 PyObject * obj0 = 0 ;
22044 char *kwnames[] = {
22045 (char *) "self", NULL
22046 };
22047
22048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22050 if (SWIG_arg_fail(1)) SWIG_fail;
22051 {
22052 PyThreadState* __tstate = wxPyBeginAllowThreads();
22053 result = (wxWindow *)(arg1)->GetChangedWindow();
22054
22055 wxPyEndAllowThreads(__tstate);
22056 if (PyErr_Occurred()) SWIG_fail;
22057 }
22058 {
22059 resultobj = wxPyMake_wxObject(result, 0);
22060 }
22061 return resultobj;
22062 fail:
22063 return NULL;
22064 }
22065
22066
22067 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22068 PyObject *obj;
22069 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22070 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22071 Py_INCREF(obj);
22072 return Py_BuildValue((char *)"");
22073 }
22074 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22075 PyObject *resultobj;
22076 int arg1 = (int) 0 ;
22077 wxQueryNewPaletteEvent *result;
22078 PyObject * obj0 = 0 ;
22079 char *kwnames[] = {
22080 (char *) "winid", NULL
22081 };
22082
22083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22084 if (obj0) {
22085 {
22086 arg1 = (int)(SWIG_As_int(obj0));
22087 if (SWIG_arg_fail(1)) SWIG_fail;
22088 }
22089 }
22090 {
22091 PyThreadState* __tstate = wxPyBeginAllowThreads();
22092 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22093
22094 wxPyEndAllowThreads(__tstate);
22095 if (PyErr_Occurred()) SWIG_fail;
22096 }
22097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22098 return resultobj;
22099 fail:
22100 return NULL;
22101 }
22102
22103
22104 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22105 PyObject *resultobj;
22106 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22107 bool arg2 ;
22108 PyObject * obj0 = 0 ;
22109 PyObject * obj1 = 0 ;
22110 char *kwnames[] = {
22111 (char *) "self",(char *) "realized", NULL
22112 };
22113
22114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22116 if (SWIG_arg_fail(1)) SWIG_fail;
22117 {
22118 arg2 = (bool)(SWIG_As_bool(obj1));
22119 if (SWIG_arg_fail(2)) SWIG_fail;
22120 }
22121 {
22122 PyThreadState* __tstate = wxPyBeginAllowThreads();
22123 (arg1)->SetPaletteRealized(arg2);
22124
22125 wxPyEndAllowThreads(__tstate);
22126 if (PyErr_Occurred()) SWIG_fail;
22127 }
22128 Py_INCREF(Py_None); resultobj = Py_None;
22129 return resultobj;
22130 fail:
22131 return NULL;
22132 }
22133
22134
22135 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22136 PyObject *resultobj;
22137 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22138 bool result;
22139 PyObject * obj0 = 0 ;
22140 char *kwnames[] = {
22141 (char *) "self", NULL
22142 };
22143
22144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22146 if (SWIG_arg_fail(1)) SWIG_fail;
22147 {
22148 PyThreadState* __tstate = wxPyBeginAllowThreads();
22149 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22150
22151 wxPyEndAllowThreads(__tstate);
22152 if (PyErr_Occurred()) SWIG_fail;
22153 }
22154 {
22155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22156 }
22157 return resultobj;
22158 fail:
22159 return NULL;
22160 }
22161
22162
22163 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22164 PyObject *obj;
22165 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22166 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22167 Py_INCREF(obj);
22168 return Py_BuildValue((char *)"");
22169 }
22170 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22171 PyObject *resultobj;
22172 wxNavigationKeyEvent *result;
22173 char *kwnames[] = {
22174 NULL
22175 };
22176
22177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22178 {
22179 PyThreadState* __tstate = wxPyBeginAllowThreads();
22180 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22181
22182 wxPyEndAllowThreads(__tstate);
22183 if (PyErr_Occurred()) SWIG_fail;
22184 }
22185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22186 return resultobj;
22187 fail:
22188 return NULL;
22189 }
22190
22191
22192 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22193 PyObject *resultobj;
22194 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22195 bool result;
22196 PyObject * obj0 = 0 ;
22197 char *kwnames[] = {
22198 (char *) "self", NULL
22199 };
22200
22201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22203 if (SWIG_arg_fail(1)) SWIG_fail;
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22207
22208 wxPyEndAllowThreads(__tstate);
22209 if (PyErr_Occurred()) SWIG_fail;
22210 }
22211 {
22212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22213 }
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22221 PyObject *resultobj;
22222 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22223 bool arg2 ;
22224 PyObject * obj0 = 0 ;
22225 PyObject * obj1 = 0 ;
22226 char *kwnames[] = {
22227 (char *) "self",(char *) "forward", NULL
22228 };
22229
22230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22232 if (SWIG_arg_fail(1)) SWIG_fail;
22233 {
22234 arg2 = (bool)(SWIG_As_bool(obj1));
22235 if (SWIG_arg_fail(2)) SWIG_fail;
22236 }
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 (arg1)->SetDirection(arg2);
22240
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 Py_INCREF(Py_None); resultobj = Py_None;
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj;
22253 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22254 bool result;
22255 PyObject * obj0 = 0 ;
22256 char *kwnames[] = {
22257 (char *) "self", NULL
22258 };
22259
22260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22262 if (SWIG_arg_fail(1)) SWIG_fail;
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 {
22271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22272 }
22273 return resultobj;
22274 fail:
22275 return NULL;
22276 }
22277
22278
22279 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22280 PyObject *resultobj;
22281 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22282 bool arg2 ;
22283 PyObject * obj0 = 0 ;
22284 PyObject * obj1 = 0 ;
22285 char *kwnames[] = {
22286 (char *) "self",(char *) "ischange", NULL
22287 };
22288
22289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22291 if (SWIG_arg_fail(1)) SWIG_fail;
22292 {
22293 arg2 = (bool)(SWIG_As_bool(obj1));
22294 if (SWIG_arg_fail(2)) SWIG_fail;
22295 }
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 (arg1)->SetWindowChange(arg2);
22299
22300 wxPyEndAllowThreads(__tstate);
22301 if (PyErr_Occurred()) SWIG_fail;
22302 }
22303 Py_INCREF(Py_None); resultobj = Py_None;
22304 return resultobj;
22305 fail:
22306 return NULL;
22307 }
22308
22309
22310 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22311 PyObject *resultobj;
22312 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22313 bool result;
22314 PyObject * obj0 = 0 ;
22315 char *kwnames[] = {
22316 (char *) "self", NULL
22317 };
22318
22319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22321 if (SWIG_arg_fail(1)) SWIG_fail;
22322 {
22323 PyThreadState* __tstate = wxPyBeginAllowThreads();
22324 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22325
22326 wxPyEndAllowThreads(__tstate);
22327 if (PyErr_Occurred()) SWIG_fail;
22328 }
22329 {
22330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22331 }
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22339 PyObject *resultobj;
22340 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22341 bool arg2 ;
22342 PyObject * obj0 = 0 ;
22343 PyObject * obj1 = 0 ;
22344 char *kwnames[] = {
22345 (char *) "self",(char *) "bIs", NULL
22346 };
22347
22348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22350 if (SWIG_arg_fail(1)) SWIG_fail;
22351 {
22352 arg2 = (bool)(SWIG_As_bool(obj1));
22353 if (SWIG_arg_fail(2)) SWIG_fail;
22354 }
22355 {
22356 PyThreadState* __tstate = wxPyBeginAllowThreads();
22357 (arg1)->SetFromTab(arg2);
22358
22359 wxPyEndAllowThreads(__tstate);
22360 if (PyErr_Occurred()) SWIG_fail;
22361 }
22362 Py_INCREF(Py_None); resultobj = Py_None;
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22370 PyObject *resultobj;
22371 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22372 long arg2 ;
22373 PyObject * obj0 = 0 ;
22374 PyObject * obj1 = 0 ;
22375 char *kwnames[] = {
22376 (char *) "self",(char *) "flags", NULL
22377 };
22378
22379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22381 if (SWIG_arg_fail(1)) SWIG_fail;
22382 {
22383 arg2 = (long)(SWIG_As_long(obj1));
22384 if (SWIG_arg_fail(2)) SWIG_fail;
22385 }
22386 {
22387 PyThreadState* __tstate = wxPyBeginAllowThreads();
22388 (arg1)->SetFlags(arg2);
22389
22390 wxPyEndAllowThreads(__tstate);
22391 if (PyErr_Occurred()) SWIG_fail;
22392 }
22393 Py_INCREF(Py_None); resultobj = Py_None;
22394 return resultobj;
22395 fail:
22396 return NULL;
22397 }
22398
22399
22400 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22401 PyObject *resultobj;
22402 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22403 wxWindow *result;
22404 PyObject * obj0 = 0 ;
22405 char *kwnames[] = {
22406 (char *) "self", NULL
22407 };
22408
22409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22411 if (SWIG_arg_fail(1)) SWIG_fail;
22412 {
22413 PyThreadState* __tstate = wxPyBeginAllowThreads();
22414 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22415
22416 wxPyEndAllowThreads(__tstate);
22417 if (PyErr_Occurred()) SWIG_fail;
22418 }
22419 {
22420 resultobj = wxPyMake_wxObject(result, 0);
22421 }
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22429 PyObject *resultobj;
22430 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22431 wxWindow *arg2 = (wxWindow *) 0 ;
22432 PyObject * obj0 = 0 ;
22433 PyObject * obj1 = 0 ;
22434 char *kwnames[] = {
22435 (char *) "self",(char *) "win", NULL
22436 };
22437
22438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22440 if (SWIG_arg_fail(1)) SWIG_fail;
22441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22442 if (SWIG_arg_fail(2)) SWIG_fail;
22443 {
22444 PyThreadState* __tstate = wxPyBeginAllowThreads();
22445 (arg1)->SetCurrentFocus(arg2);
22446
22447 wxPyEndAllowThreads(__tstate);
22448 if (PyErr_Occurred()) SWIG_fail;
22449 }
22450 Py_INCREF(Py_None); resultobj = Py_None;
22451 return resultobj;
22452 fail:
22453 return NULL;
22454 }
22455
22456
22457 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22458 PyObject *obj;
22459 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22460 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22461 Py_INCREF(obj);
22462 return Py_BuildValue((char *)"");
22463 }
22464 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22465 PyObject *resultobj;
22466 wxWindow *arg1 = (wxWindow *) NULL ;
22467 wxWindowCreateEvent *result;
22468 PyObject * obj0 = 0 ;
22469 char *kwnames[] = {
22470 (char *) "win", NULL
22471 };
22472
22473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22474 if (obj0) {
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 }
22478 {
22479 PyThreadState* __tstate = wxPyBeginAllowThreads();
22480 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22481
22482 wxPyEndAllowThreads(__tstate);
22483 if (PyErr_Occurred()) SWIG_fail;
22484 }
22485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22486 return resultobj;
22487 fail:
22488 return NULL;
22489 }
22490
22491
22492 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22493 PyObject *resultobj;
22494 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22495 wxWindow *result;
22496 PyObject * obj0 = 0 ;
22497 char *kwnames[] = {
22498 (char *) "self", NULL
22499 };
22500
22501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22503 if (SWIG_arg_fail(1)) SWIG_fail;
22504 {
22505 PyThreadState* __tstate = wxPyBeginAllowThreads();
22506 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22507
22508 wxPyEndAllowThreads(__tstate);
22509 if (PyErr_Occurred()) SWIG_fail;
22510 }
22511 {
22512 resultobj = wxPyMake_wxObject(result, 0);
22513 }
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22521 PyObject *obj;
22522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22523 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22524 Py_INCREF(obj);
22525 return Py_BuildValue((char *)"");
22526 }
22527 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22528 PyObject *resultobj;
22529 wxWindow *arg1 = (wxWindow *) NULL ;
22530 wxWindowDestroyEvent *result;
22531 PyObject * obj0 = 0 ;
22532 char *kwnames[] = {
22533 (char *) "win", NULL
22534 };
22535
22536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22537 if (obj0) {
22538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22539 if (SWIG_arg_fail(1)) SWIG_fail;
22540 }
22541 {
22542 PyThreadState* __tstate = wxPyBeginAllowThreads();
22543 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22544
22545 wxPyEndAllowThreads(__tstate);
22546 if (PyErr_Occurred()) SWIG_fail;
22547 }
22548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22549 return resultobj;
22550 fail:
22551 return NULL;
22552 }
22553
22554
22555 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22556 PyObject *resultobj;
22557 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22558 wxWindow *result;
22559 PyObject * obj0 = 0 ;
22560 char *kwnames[] = {
22561 (char *) "self", NULL
22562 };
22563
22564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22566 if (SWIG_arg_fail(1)) SWIG_fail;
22567 {
22568 PyThreadState* __tstate = wxPyBeginAllowThreads();
22569 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22570
22571 wxPyEndAllowThreads(__tstate);
22572 if (PyErr_Occurred()) SWIG_fail;
22573 }
22574 {
22575 resultobj = wxPyMake_wxObject(result, 0);
22576 }
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22584 PyObject *obj;
22585 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22586 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22587 Py_INCREF(obj);
22588 return Py_BuildValue((char *)"");
22589 }
22590 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22591 PyObject *resultobj;
22592 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22593 int arg2 = (int) 0 ;
22594 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22595 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22596 wxContextMenuEvent *result;
22597 wxPoint temp3 ;
22598 PyObject * obj0 = 0 ;
22599 PyObject * obj1 = 0 ;
22600 PyObject * obj2 = 0 ;
22601 char *kwnames[] = {
22602 (char *) "type",(char *) "winid",(char *) "pt", NULL
22603 };
22604
22605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22606 if (obj0) {
22607 {
22608 arg1 = (wxEventType)(SWIG_As_int(obj0));
22609 if (SWIG_arg_fail(1)) SWIG_fail;
22610 }
22611 }
22612 if (obj1) {
22613 {
22614 arg2 = (int)(SWIG_As_int(obj1));
22615 if (SWIG_arg_fail(2)) SWIG_fail;
22616 }
22617 }
22618 if (obj2) {
22619 {
22620 arg3 = &temp3;
22621 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22622 }
22623 }
22624 {
22625 PyThreadState* __tstate = wxPyBeginAllowThreads();
22626 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22627
22628 wxPyEndAllowThreads(__tstate);
22629 if (PyErr_Occurred()) SWIG_fail;
22630 }
22631 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22632 return resultobj;
22633 fail:
22634 return NULL;
22635 }
22636
22637
22638 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22639 PyObject *resultobj;
22640 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22641 wxPoint *result;
22642 PyObject * obj0 = 0 ;
22643 char *kwnames[] = {
22644 (char *) "self", NULL
22645 };
22646
22647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22649 if (SWIG_arg_fail(1)) SWIG_fail;
22650 {
22651 PyThreadState* __tstate = wxPyBeginAllowThreads();
22652 {
22653 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22654 result = (wxPoint *) &_result_ref;
22655 }
22656
22657 wxPyEndAllowThreads(__tstate);
22658 if (PyErr_Occurred()) SWIG_fail;
22659 }
22660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22661 return resultobj;
22662 fail:
22663 return NULL;
22664 }
22665
22666
22667 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22668 PyObject *resultobj;
22669 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22670 wxPoint *arg2 = 0 ;
22671 wxPoint temp2 ;
22672 PyObject * obj0 = 0 ;
22673 PyObject * obj1 = 0 ;
22674 char *kwnames[] = {
22675 (char *) "self",(char *) "pos", NULL
22676 };
22677
22678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22680 if (SWIG_arg_fail(1)) SWIG_fail;
22681 {
22682 arg2 = &temp2;
22683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22684 }
22685 {
22686 PyThreadState* __tstate = wxPyBeginAllowThreads();
22687 (arg1)->SetPosition((wxPoint const &)*arg2);
22688
22689 wxPyEndAllowThreads(__tstate);
22690 if (PyErr_Occurred()) SWIG_fail;
22691 }
22692 Py_INCREF(Py_None); resultobj = Py_None;
22693 return resultobj;
22694 fail:
22695 return NULL;
22696 }
22697
22698
22699 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22700 PyObject *obj;
22701 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22702 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22703 Py_INCREF(obj);
22704 return Py_BuildValue((char *)"");
22705 }
22706 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22707 PyObject *resultobj;
22708 wxIdleEvent *result;
22709 char *kwnames[] = {
22710 NULL
22711 };
22712
22713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22714 {
22715 PyThreadState* __tstate = wxPyBeginAllowThreads();
22716 result = (wxIdleEvent *)new wxIdleEvent();
22717
22718 wxPyEndAllowThreads(__tstate);
22719 if (PyErr_Occurred()) SWIG_fail;
22720 }
22721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22722 return resultobj;
22723 fail:
22724 return NULL;
22725 }
22726
22727
22728 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22729 PyObject *resultobj;
22730 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22731 bool arg2 = (bool) true ;
22732 PyObject * obj0 = 0 ;
22733 PyObject * obj1 = 0 ;
22734 char *kwnames[] = {
22735 (char *) "self",(char *) "needMore", NULL
22736 };
22737
22738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22740 if (SWIG_arg_fail(1)) SWIG_fail;
22741 if (obj1) {
22742 {
22743 arg2 = (bool)(SWIG_As_bool(obj1));
22744 if (SWIG_arg_fail(2)) SWIG_fail;
22745 }
22746 }
22747 {
22748 PyThreadState* __tstate = wxPyBeginAllowThreads();
22749 (arg1)->RequestMore(arg2);
22750
22751 wxPyEndAllowThreads(__tstate);
22752 if (PyErr_Occurred()) SWIG_fail;
22753 }
22754 Py_INCREF(Py_None); resultobj = Py_None;
22755 return resultobj;
22756 fail:
22757 return NULL;
22758 }
22759
22760
22761 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22762 PyObject *resultobj;
22763 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22764 bool result;
22765 PyObject * obj0 = 0 ;
22766 char *kwnames[] = {
22767 (char *) "self", NULL
22768 };
22769
22770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22772 if (SWIG_arg_fail(1)) SWIG_fail;
22773 {
22774 PyThreadState* __tstate = wxPyBeginAllowThreads();
22775 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22776
22777 wxPyEndAllowThreads(__tstate);
22778 if (PyErr_Occurred()) SWIG_fail;
22779 }
22780 {
22781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22782 }
22783 return resultobj;
22784 fail:
22785 return NULL;
22786 }
22787
22788
22789 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22790 PyObject *resultobj;
22791 wxIdleMode arg1 ;
22792 PyObject * obj0 = 0 ;
22793 char *kwnames[] = {
22794 (char *) "mode", NULL
22795 };
22796
22797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22798 {
22799 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22800 if (SWIG_arg_fail(1)) SWIG_fail;
22801 }
22802 {
22803 PyThreadState* __tstate = wxPyBeginAllowThreads();
22804 wxIdleEvent::SetMode((wxIdleMode )arg1);
22805
22806 wxPyEndAllowThreads(__tstate);
22807 if (PyErr_Occurred()) SWIG_fail;
22808 }
22809 Py_INCREF(Py_None); resultobj = Py_None;
22810 return resultobj;
22811 fail:
22812 return NULL;
22813 }
22814
22815
22816 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22817 PyObject *resultobj;
22818 wxIdleMode result;
22819 char *kwnames[] = {
22820 NULL
22821 };
22822
22823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22824 {
22825 PyThreadState* __tstate = wxPyBeginAllowThreads();
22826 result = (wxIdleMode)wxIdleEvent::GetMode();
22827
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 resultobj = SWIG_From_int((result));
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22839 PyObject *resultobj;
22840 wxWindow *arg1 = (wxWindow *) 0 ;
22841 bool result;
22842 PyObject * obj0 = 0 ;
22843 char *kwnames[] = {
22844 (char *) "win", NULL
22845 };
22846
22847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22849 if (SWIG_arg_fail(1)) SWIG_fail;
22850 {
22851 PyThreadState* __tstate = wxPyBeginAllowThreads();
22852 result = (bool)wxIdleEvent::CanSend(arg1);
22853
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 {
22858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22859 }
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22867 PyObject *obj;
22868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22869 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22870 Py_INCREF(obj);
22871 return Py_BuildValue((char *)"");
22872 }
22873 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22874 PyObject *resultobj;
22875 int arg1 = (int) 0 ;
22876 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22877 wxPyEvent *result;
22878 PyObject * obj0 = 0 ;
22879 PyObject * obj1 = 0 ;
22880 char *kwnames[] = {
22881 (char *) "winid",(char *) "eventType", NULL
22882 };
22883
22884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22885 if (obj0) {
22886 {
22887 arg1 = (int)(SWIG_As_int(obj0));
22888 if (SWIG_arg_fail(1)) SWIG_fail;
22889 }
22890 }
22891 if (obj1) {
22892 {
22893 arg2 = (wxEventType)(SWIG_As_int(obj1));
22894 if (SWIG_arg_fail(2)) SWIG_fail;
22895 }
22896 }
22897 {
22898 PyThreadState* __tstate = wxPyBeginAllowThreads();
22899 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22900
22901 wxPyEndAllowThreads(__tstate);
22902 if (PyErr_Occurred()) SWIG_fail;
22903 }
22904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22905 return resultobj;
22906 fail:
22907 return NULL;
22908 }
22909
22910
22911 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22912 PyObject *resultobj;
22913 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22914 PyObject * obj0 = 0 ;
22915 char *kwnames[] = {
22916 (char *) "self", NULL
22917 };
22918
22919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22921 if (SWIG_arg_fail(1)) SWIG_fail;
22922 {
22923 PyThreadState* __tstate = wxPyBeginAllowThreads();
22924 delete arg1;
22925
22926 wxPyEndAllowThreads(__tstate);
22927 if (PyErr_Occurred()) SWIG_fail;
22928 }
22929 Py_INCREF(Py_None); resultobj = Py_None;
22930 return resultobj;
22931 fail:
22932 return NULL;
22933 }
22934
22935
22936 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22937 PyObject *resultobj;
22938 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22939 PyObject *arg2 = (PyObject *) 0 ;
22940 PyObject * obj0 = 0 ;
22941 PyObject * obj1 = 0 ;
22942 char *kwnames[] = {
22943 (char *) "self",(char *) "self", NULL
22944 };
22945
22946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22948 if (SWIG_arg_fail(1)) SWIG_fail;
22949 arg2 = obj1;
22950 {
22951 PyThreadState* __tstate = wxPyBeginAllowThreads();
22952 (arg1)->SetSelf(arg2);
22953
22954 wxPyEndAllowThreads(__tstate);
22955 if (PyErr_Occurred()) SWIG_fail;
22956 }
22957 Py_INCREF(Py_None); resultobj = Py_None;
22958 return resultobj;
22959 fail:
22960 return NULL;
22961 }
22962
22963
22964 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22965 PyObject *resultobj;
22966 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22967 PyObject *result;
22968 PyObject * obj0 = 0 ;
22969 char *kwnames[] = {
22970 (char *) "self", NULL
22971 };
22972
22973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22975 if (SWIG_arg_fail(1)) SWIG_fail;
22976 {
22977 PyThreadState* __tstate = wxPyBeginAllowThreads();
22978 result = (PyObject *)(arg1)->GetSelf();
22979
22980 wxPyEndAllowThreads(__tstate);
22981 if (PyErr_Occurred()) SWIG_fail;
22982 }
22983 resultobj = result;
22984 return resultobj;
22985 fail:
22986 return NULL;
22987 }
22988
22989
22990 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22991 PyObject *obj;
22992 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22993 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22994 Py_INCREF(obj);
22995 return Py_BuildValue((char *)"");
22996 }
22997 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22998 PyObject *resultobj;
22999 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23000 int arg2 = (int) 0 ;
23001 wxPyCommandEvent *result;
23002 PyObject * obj0 = 0 ;
23003 PyObject * obj1 = 0 ;
23004 char *kwnames[] = {
23005 (char *) "eventType",(char *) "id", NULL
23006 };
23007
23008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23009 if (obj0) {
23010 {
23011 arg1 = (wxEventType)(SWIG_As_int(obj0));
23012 if (SWIG_arg_fail(1)) SWIG_fail;
23013 }
23014 }
23015 if (obj1) {
23016 {
23017 arg2 = (int)(SWIG_As_int(obj1));
23018 if (SWIG_arg_fail(2)) SWIG_fail;
23019 }
23020 }
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23024
23025 wxPyEndAllowThreads(__tstate);
23026 if (PyErr_Occurred()) SWIG_fail;
23027 }
23028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23029 return resultobj;
23030 fail:
23031 return NULL;
23032 }
23033
23034
23035 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23036 PyObject *resultobj;
23037 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23038 PyObject * obj0 = 0 ;
23039 char *kwnames[] = {
23040 (char *) "self", NULL
23041 };
23042
23043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23045 if (SWIG_arg_fail(1)) SWIG_fail;
23046 {
23047 PyThreadState* __tstate = wxPyBeginAllowThreads();
23048 delete arg1;
23049
23050 wxPyEndAllowThreads(__tstate);
23051 if (PyErr_Occurred()) SWIG_fail;
23052 }
23053 Py_INCREF(Py_None); resultobj = Py_None;
23054 return resultobj;
23055 fail:
23056 return NULL;
23057 }
23058
23059
23060 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23061 PyObject *resultobj;
23062 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23063 PyObject *arg2 = (PyObject *) 0 ;
23064 PyObject * obj0 = 0 ;
23065 PyObject * obj1 = 0 ;
23066 char *kwnames[] = {
23067 (char *) "self",(char *) "self", NULL
23068 };
23069
23070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23072 if (SWIG_arg_fail(1)) SWIG_fail;
23073 arg2 = obj1;
23074 {
23075 PyThreadState* __tstate = wxPyBeginAllowThreads();
23076 (arg1)->SetSelf(arg2);
23077
23078 wxPyEndAllowThreads(__tstate);
23079 if (PyErr_Occurred()) SWIG_fail;
23080 }
23081 Py_INCREF(Py_None); resultobj = Py_None;
23082 return resultobj;
23083 fail:
23084 return NULL;
23085 }
23086
23087
23088 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23089 PyObject *resultobj;
23090 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23091 PyObject *result;
23092 PyObject * obj0 = 0 ;
23093 char *kwnames[] = {
23094 (char *) "self", NULL
23095 };
23096
23097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23099 if (SWIG_arg_fail(1)) SWIG_fail;
23100 {
23101 PyThreadState* __tstate = wxPyBeginAllowThreads();
23102 result = (PyObject *)(arg1)->GetSelf();
23103
23104 wxPyEndAllowThreads(__tstate);
23105 if (PyErr_Occurred()) SWIG_fail;
23106 }
23107 resultobj = result;
23108 return resultobj;
23109 fail:
23110 return NULL;
23111 }
23112
23113
23114 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23115 PyObject *obj;
23116 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23117 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23118 Py_INCREF(obj);
23119 return Py_BuildValue((char *)"");
23120 }
23121 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23122 PyObject *resultobj;
23123 wxWindow *arg1 = (wxWindow *) 0 ;
23124 wxDateTime *arg2 = 0 ;
23125 wxEventType arg3 ;
23126 wxDateEvent *result;
23127 PyObject * obj0 = 0 ;
23128 PyObject * obj1 = 0 ;
23129 PyObject * obj2 = 0 ;
23130 char *kwnames[] = {
23131 (char *) "win",(char *) "dt",(char *) "type", NULL
23132 };
23133
23134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23136 if (SWIG_arg_fail(1)) SWIG_fail;
23137 {
23138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23139 if (SWIG_arg_fail(2)) SWIG_fail;
23140 if (arg2 == NULL) {
23141 SWIG_null_ref("wxDateTime");
23142 }
23143 if (SWIG_arg_fail(2)) SWIG_fail;
23144 }
23145 {
23146 arg3 = (wxEventType)(SWIG_As_int(obj2));
23147 if (SWIG_arg_fail(3)) SWIG_fail;
23148 }
23149 {
23150 PyThreadState* __tstate = wxPyBeginAllowThreads();
23151 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23152
23153 wxPyEndAllowThreads(__tstate);
23154 if (PyErr_Occurred()) SWIG_fail;
23155 }
23156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23157 return resultobj;
23158 fail:
23159 return NULL;
23160 }
23161
23162
23163 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23164 PyObject *resultobj;
23165 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23166 wxDateTime *result;
23167 PyObject * obj0 = 0 ;
23168 char *kwnames[] = {
23169 (char *) "self", NULL
23170 };
23171
23172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23174 if (SWIG_arg_fail(1)) SWIG_fail;
23175 {
23176 PyThreadState* __tstate = wxPyBeginAllowThreads();
23177 {
23178 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23179 result = (wxDateTime *) &_result_ref;
23180 }
23181
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23186 return resultobj;
23187 fail:
23188 return NULL;
23189 }
23190
23191
23192 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23193 PyObject *resultobj;
23194 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23195 wxDateTime *arg2 = 0 ;
23196 PyObject * obj0 = 0 ;
23197 PyObject * obj1 = 0 ;
23198 char *kwnames[] = {
23199 (char *) "self",(char *) "date", NULL
23200 };
23201
23202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23204 if (SWIG_arg_fail(1)) SWIG_fail;
23205 {
23206 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23207 if (SWIG_arg_fail(2)) SWIG_fail;
23208 if (arg2 == NULL) {
23209 SWIG_null_ref("wxDateTime");
23210 }
23211 if (SWIG_arg_fail(2)) SWIG_fail;
23212 }
23213 {
23214 PyThreadState* __tstate = wxPyBeginAllowThreads();
23215 (arg1)->SetDate((wxDateTime const &)*arg2);
23216
23217 wxPyEndAllowThreads(__tstate);
23218 if (PyErr_Occurred()) SWIG_fail;
23219 }
23220 Py_INCREF(Py_None); resultobj = Py_None;
23221 return resultobj;
23222 fail:
23223 return NULL;
23224 }
23225
23226
23227 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23228 PyObject *obj;
23229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23230 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23231 Py_INCREF(obj);
23232 return Py_BuildValue((char *)"");
23233 }
23234 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23235 PyObject *resultobj;
23236 wxPyApp *result;
23237 char *kwnames[] = {
23238 NULL
23239 };
23240
23241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 result = (wxPyApp *)new_wxPyApp();
23245
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj;
23258 wxPyApp *arg1 = (wxPyApp *) 0 ;
23259 PyObject * obj0 = 0 ;
23260 char *kwnames[] = {
23261 (char *) "self", NULL
23262 };
23263
23264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23266 if (SWIG_arg_fail(1)) SWIG_fail;
23267 {
23268 PyThreadState* __tstate = wxPyBeginAllowThreads();
23269 delete arg1;
23270
23271 wxPyEndAllowThreads(__tstate);
23272 if (PyErr_Occurred()) SWIG_fail;
23273 }
23274 Py_INCREF(Py_None); resultobj = Py_None;
23275 return resultobj;
23276 fail:
23277 return NULL;
23278 }
23279
23280
23281 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23282 PyObject *resultobj;
23283 wxPyApp *arg1 = (wxPyApp *) 0 ;
23284 PyObject *arg2 = (PyObject *) 0 ;
23285 PyObject *arg3 = (PyObject *) 0 ;
23286 bool arg4 ;
23287 PyObject * obj0 = 0 ;
23288 PyObject * obj1 = 0 ;
23289 PyObject * obj2 = 0 ;
23290 PyObject * obj3 = 0 ;
23291 char *kwnames[] = {
23292 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23293 };
23294
23295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = obj1;
23299 arg3 = obj2;
23300 {
23301 arg4 = (bool)(SWIG_As_bool(obj3));
23302 if (SWIG_arg_fail(4)) SWIG_fail;
23303 }
23304 {
23305 PyThreadState* __tstate = wxPyBeginAllowThreads();
23306 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23307
23308 wxPyEndAllowThreads(__tstate);
23309 if (PyErr_Occurred()) SWIG_fail;
23310 }
23311 Py_INCREF(Py_None); resultobj = Py_None;
23312 return resultobj;
23313 fail:
23314 return NULL;
23315 }
23316
23317
23318 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23319 PyObject *resultobj;
23320 wxPyApp *arg1 = (wxPyApp *) 0 ;
23321 wxString result;
23322 PyObject * obj0 = 0 ;
23323 char *kwnames[] = {
23324 (char *) "self", NULL
23325 };
23326
23327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23329 if (SWIG_arg_fail(1)) SWIG_fail;
23330 {
23331 PyThreadState* __tstate = wxPyBeginAllowThreads();
23332 result = ((wxPyApp const *)arg1)->GetAppName();
23333
23334 wxPyEndAllowThreads(__tstate);
23335 if (PyErr_Occurred()) SWIG_fail;
23336 }
23337 {
23338 #if wxUSE_UNICODE
23339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23340 #else
23341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23342 #endif
23343 }
23344 return resultobj;
23345 fail:
23346 return NULL;
23347 }
23348
23349
23350 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23351 PyObject *resultobj;
23352 wxPyApp *arg1 = (wxPyApp *) 0 ;
23353 wxString *arg2 = 0 ;
23354 bool temp2 = false ;
23355 PyObject * obj0 = 0 ;
23356 PyObject * obj1 = 0 ;
23357 char *kwnames[] = {
23358 (char *) "self",(char *) "name", NULL
23359 };
23360
23361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23363 if (SWIG_arg_fail(1)) SWIG_fail;
23364 {
23365 arg2 = wxString_in_helper(obj1);
23366 if (arg2 == NULL) SWIG_fail;
23367 temp2 = true;
23368 }
23369 {
23370 PyThreadState* __tstate = wxPyBeginAllowThreads();
23371 (arg1)->SetAppName((wxString const &)*arg2);
23372
23373 wxPyEndAllowThreads(__tstate);
23374 if (PyErr_Occurred()) SWIG_fail;
23375 }
23376 Py_INCREF(Py_None); resultobj = Py_None;
23377 {
23378 if (temp2)
23379 delete arg2;
23380 }
23381 return resultobj;
23382 fail:
23383 {
23384 if (temp2)
23385 delete arg2;
23386 }
23387 return NULL;
23388 }
23389
23390
23391 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23392 PyObject *resultobj;
23393 wxPyApp *arg1 = (wxPyApp *) 0 ;
23394 wxString result;
23395 PyObject * obj0 = 0 ;
23396 char *kwnames[] = {
23397 (char *) "self", NULL
23398 };
23399
23400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23402 if (SWIG_arg_fail(1)) SWIG_fail;
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 result = ((wxPyApp const *)arg1)->GetClassName();
23406
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 {
23411 #if wxUSE_UNICODE
23412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23413 #else
23414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23415 #endif
23416 }
23417 return resultobj;
23418 fail:
23419 return NULL;
23420 }
23421
23422
23423 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23424 PyObject *resultobj;
23425 wxPyApp *arg1 = (wxPyApp *) 0 ;
23426 wxString *arg2 = 0 ;
23427 bool temp2 = false ;
23428 PyObject * obj0 = 0 ;
23429 PyObject * obj1 = 0 ;
23430 char *kwnames[] = {
23431 (char *) "self",(char *) "name", NULL
23432 };
23433
23434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23436 if (SWIG_arg_fail(1)) SWIG_fail;
23437 {
23438 arg2 = wxString_in_helper(obj1);
23439 if (arg2 == NULL) SWIG_fail;
23440 temp2 = true;
23441 }
23442 {
23443 PyThreadState* __tstate = wxPyBeginAllowThreads();
23444 (arg1)->SetClassName((wxString const &)*arg2);
23445
23446 wxPyEndAllowThreads(__tstate);
23447 if (PyErr_Occurred()) SWIG_fail;
23448 }
23449 Py_INCREF(Py_None); resultobj = Py_None;
23450 {
23451 if (temp2)
23452 delete arg2;
23453 }
23454 return resultobj;
23455 fail:
23456 {
23457 if (temp2)
23458 delete arg2;
23459 }
23460 return NULL;
23461 }
23462
23463
23464 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23465 PyObject *resultobj;
23466 wxPyApp *arg1 = (wxPyApp *) 0 ;
23467 wxString *result;
23468 PyObject * obj0 = 0 ;
23469 char *kwnames[] = {
23470 (char *) "self", NULL
23471 };
23472
23473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23475 if (SWIG_arg_fail(1)) SWIG_fail;
23476 {
23477 PyThreadState* __tstate = wxPyBeginAllowThreads();
23478 {
23479 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23480 result = (wxString *) &_result_ref;
23481 }
23482
23483 wxPyEndAllowThreads(__tstate);
23484 if (PyErr_Occurred()) SWIG_fail;
23485 }
23486 {
23487 #if wxUSE_UNICODE
23488 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23489 #else
23490 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23491 #endif
23492 }
23493 return resultobj;
23494 fail:
23495 return NULL;
23496 }
23497
23498
23499 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23500 PyObject *resultobj;
23501 wxPyApp *arg1 = (wxPyApp *) 0 ;
23502 wxString *arg2 = 0 ;
23503 bool temp2 = false ;
23504 PyObject * obj0 = 0 ;
23505 PyObject * obj1 = 0 ;
23506 char *kwnames[] = {
23507 (char *) "self",(char *) "name", NULL
23508 };
23509
23510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23512 if (SWIG_arg_fail(1)) SWIG_fail;
23513 {
23514 arg2 = wxString_in_helper(obj1);
23515 if (arg2 == NULL) SWIG_fail;
23516 temp2 = true;
23517 }
23518 {
23519 PyThreadState* __tstate = wxPyBeginAllowThreads();
23520 (arg1)->SetVendorName((wxString const &)*arg2);
23521
23522 wxPyEndAllowThreads(__tstate);
23523 if (PyErr_Occurred()) SWIG_fail;
23524 }
23525 Py_INCREF(Py_None); resultobj = Py_None;
23526 {
23527 if (temp2)
23528 delete arg2;
23529 }
23530 return resultobj;
23531 fail:
23532 {
23533 if (temp2)
23534 delete arg2;
23535 }
23536 return NULL;
23537 }
23538
23539
23540 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23541 PyObject *resultobj;
23542 wxPyApp *arg1 = (wxPyApp *) 0 ;
23543 wxAppTraits *result;
23544 PyObject * obj0 = 0 ;
23545 char *kwnames[] = {
23546 (char *) "self", NULL
23547 };
23548
23549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23551 if (SWIG_arg_fail(1)) SWIG_fail;
23552 {
23553 PyThreadState* __tstate = wxPyBeginAllowThreads();
23554 result = (wxAppTraits *)(arg1)->GetTraits();
23555
23556 wxPyEndAllowThreads(__tstate);
23557 if (PyErr_Occurred()) SWIG_fail;
23558 }
23559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23560 return resultobj;
23561 fail:
23562 return NULL;
23563 }
23564
23565
23566 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23567 PyObject *resultobj;
23568 wxPyApp *arg1 = (wxPyApp *) 0 ;
23569 PyObject * obj0 = 0 ;
23570 char *kwnames[] = {
23571 (char *) "self", NULL
23572 };
23573
23574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23576 if (SWIG_arg_fail(1)) SWIG_fail;
23577 {
23578 PyThreadState* __tstate = wxPyBeginAllowThreads();
23579 (arg1)->ProcessPendingEvents();
23580
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 Py_INCREF(Py_None); resultobj = Py_None;
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23592 PyObject *resultobj;
23593 wxPyApp *arg1 = (wxPyApp *) 0 ;
23594 bool arg2 = (bool) false ;
23595 bool result;
23596 PyObject * obj0 = 0 ;
23597 PyObject * obj1 = 0 ;
23598 char *kwnames[] = {
23599 (char *) "self",(char *) "onlyIfNeeded", NULL
23600 };
23601
23602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23604 if (SWIG_arg_fail(1)) SWIG_fail;
23605 if (obj1) {
23606 {
23607 arg2 = (bool)(SWIG_As_bool(obj1));
23608 if (SWIG_arg_fail(2)) SWIG_fail;
23609 }
23610 }
23611 {
23612 PyThreadState* __tstate = wxPyBeginAllowThreads();
23613 result = (bool)(arg1)->Yield(arg2);
23614
23615 wxPyEndAllowThreads(__tstate);
23616 if (PyErr_Occurred()) SWIG_fail;
23617 }
23618 {
23619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23620 }
23621 return resultobj;
23622 fail:
23623 return NULL;
23624 }
23625
23626
23627 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23628 PyObject *resultobj;
23629 wxPyApp *arg1 = (wxPyApp *) 0 ;
23630 PyObject * obj0 = 0 ;
23631 char *kwnames[] = {
23632 (char *) "self", NULL
23633 };
23634
23635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23637 if (SWIG_arg_fail(1)) SWIG_fail;
23638 {
23639 PyThreadState* __tstate = wxPyBeginAllowThreads();
23640 (arg1)->WakeUpIdle();
23641
23642 wxPyEndAllowThreads(__tstate);
23643 if (PyErr_Occurred()) SWIG_fail;
23644 }
23645 Py_INCREF(Py_None); resultobj = Py_None;
23646 return resultobj;
23647 fail:
23648 return NULL;
23649 }
23650
23651
23652 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23653 PyObject *resultobj;
23654 bool result;
23655 char *kwnames[] = {
23656 NULL
23657 };
23658
23659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = (bool)wxPyApp::IsMainLoopRunning();
23663
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 {
23668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23669 }
23670 return resultobj;
23671 fail:
23672 return NULL;
23673 }
23674
23675
23676 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23677 PyObject *resultobj;
23678 wxPyApp *arg1 = (wxPyApp *) 0 ;
23679 int result;
23680 PyObject * obj0 = 0 ;
23681 char *kwnames[] = {
23682 (char *) "self", NULL
23683 };
23684
23685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23687 if (SWIG_arg_fail(1)) SWIG_fail;
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = (int)(arg1)->MainLoop();
23691
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 {
23696 resultobj = SWIG_From_int((int)(result));
23697 }
23698 return resultobj;
23699 fail:
23700 return NULL;
23701 }
23702
23703
23704 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23705 PyObject *resultobj;
23706 wxPyApp *arg1 = (wxPyApp *) 0 ;
23707 PyObject * obj0 = 0 ;
23708 char *kwnames[] = {
23709 (char *) "self", NULL
23710 };
23711
23712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23714 if (SWIG_arg_fail(1)) SWIG_fail;
23715 {
23716 PyThreadState* __tstate = wxPyBeginAllowThreads();
23717 (arg1)->Exit();
23718
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 Py_INCREF(Py_None); resultobj = Py_None;
23723 return resultobj;
23724 fail:
23725 return NULL;
23726 }
23727
23728
23729 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23730 PyObject *resultobj;
23731 wxPyApp *arg1 = (wxPyApp *) 0 ;
23732 PyObject * obj0 = 0 ;
23733 char *kwnames[] = {
23734 (char *) "self", NULL
23735 };
23736
23737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23739 if (SWIG_arg_fail(1)) SWIG_fail;
23740 {
23741 PyThreadState* __tstate = wxPyBeginAllowThreads();
23742 (arg1)->ExitMainLoop();
23743
23744 wxPyEndAllowThreads(__tstate);
23745 if (PyErr_Occurred()) SWIG_fail;
23746 }
23747 Py_INCREF(Py_None); resultobj = Py_None;
23748 return resultobj;
23749 fail:
23750 return NULL;
23751 }
23752
23753
23754 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23755 PyObject *resultobj;
23756 wxPyApp *arg1 = (wxPyApp *) 0 ;
23757 bool result;
23758 PyObject * obj0 = 0 ;
23759 char *kwnames[] = {
23760 (char *) "self", NULL
23761 };
23762
23763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23765 if (SWIG_arg_fail(1)) SWIG_fail;
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = (bool)(arg1)->Pending();
23769
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 {
23774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23775 }
23776 return resultobj;
23777 fail:
23778 return NULL;
23779 }
23780
23781
23782 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23783 PyObject *resultobj;
23784 wxPyApp *arg1 = (wxPyApp *) 0 ;
23785 bool result;
23786 PyObject * obj0 = 0 ;
23787 char *kwnames[] = {
23788 (char *) "self", NULL
23789 };
23790
23791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23793 if (SWIG_arg_fail(1)) SWIG_fail;
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 result = (bool)(arg1)->Dispatch();
23797
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 {
23802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23803 }
23804 return resultobj;
23805 fail:
23806 return NULL;
23807 }
23808
23809
23810 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23811 PyObject *resultobj;
23812 wxPyApp *arg1 = (wxPyApp *) 0 ;
23813 bool result;
23814 PyObject * obj0 = 0 ;
23815 char *kwnames[] = {
23816 (char *) "self", NULL
23817 };
23818
23819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23821 if (SWIG_arg_fail(1)) SWIG_fail;
23822 {
23823 PyThreadState* __tstate = wxPyBeginAllowThreads();
23824 result = (bool)(arg1)->ProcessIdle();
23825
23826 wxPyEndAllowThreads(__tstate);
23827 if (PyErr_Occurred()) SWIG_fail;
23828 }
23829 {
23830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23831 }
23832 return resultobj;
23833 fail:
23834 return NULL;
23835 }
23836
23837
23838 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23839 PyObject *resultobj;
23840 wxPyApp *arg1 = (wxPyApp *) 0 ;
23841 wxWindow *arg2 = (wxWindow *) 0 ;
23842 wxIdleEvent *arg3 = 0 ;
23843 bool result;
23844 PyObject * obj0 = 0 ;
23845 PyObject * obj1 = 0 ;
23846 PyObject * obj2 = 0 ;
23847 char *kwnames[] = {
23848 (char *) "self",(char *) "win",(char *) "event", NULL
23849 };
23850
23851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23853 if (SWIG_arg_fail(1)) SWIG_fail;
23854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23855 if (SWIG_arg_fail(2)) SWIG_fail;
23856 {
23857 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23858 if (SWIG_arg_fail(3)) SWIG_fail;
23859 if (arg3 == NULL) {
23860 SWIG_null_ref("wxIdleEvent");
23861 }
23862 if (SWIG_arg_fail(3)) SWIG_fail;
23863 }
23864 {
23865 PyThreadState* __tstate = wxPyBeginAllowThreads();
23866 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23867
23868 wxPyEndAllowThreads(__tstate);
23869 if (PyErr_Occurred()) SWIG_fail;
23870 }
23871 {
23872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23873 }
23874 return resultobj;
23875 fail:
23876 return NULL;
23877 }
23878
23879
23880 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23881 PyObject *resultobj;
23882 wxPyApp *arg1 = (wxPyApp *) 0 ;
23883 bool result;
23884 PyObject * obj0 = 0 ;
23885 char *kwnames[] = {
23886 (char *) "self", NULL
23887 };
23888
23889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23891 if (SWIG_arg_fail(1)) SWIG_fail;
23892 {
23893 PyThreadState* __tstate = wxPyBeginAllowThreads();
23894 result = (bool)((wxPyApp const *)arg1)->IsActive();
23895
23896 wxPyEndAllowThreads(__tstate);
23897 if (PyErr_Occurred()) SWIG_fail;
23898 }
23899 {
23900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23901 }
23902 return resultobj;
23903 fail:
23904 return NULL;
23905 }
23906
23907
23908 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23909 PyObject *resultobj;
23910 wxPyApp *arg1 = (wxPyApp *) 0 ;
23911 wxWindow *arg2 = (wxWindow *) 0 ;
23912 PyObject * obj0 = 0 ;
23913 PyObject * obj1 = 0 ;
23914 char *kwnames[] = {
23915 (char *) "self",(char *) "win", NULL
23916 };
23917
23918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23920 if (SWIG_arg_fail(1)) SWIG_fail;
23921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23922 if (SWIG_arg_fail(2)) SWIG_fail;
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 (arg1)->SetTopWindow(arg2);
23926
23927 wxPyEndAllowThreads(__tstate);
23928 if (PyErr_Occurred()) SWIG_fail;
23929 }
23930 Py_INCREF(Py_None); resultobj = Py_None;
23931 return resultobj;
23932 fail:
23933 return NULL;
23934 }
23935
23936
23937 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23938 PyObject *resultobj;
23939 wxPyApp *arg1 = (wxPyApp *) 0 ;
23940 wxWindow *result;
23941 PyObject * obj0 = 0 ;
23942 char *kwnames[] = {
23943 (char *) "self", NULL
23944 };
23945
23946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23948 if (SWIG_arg_fail(1)) SWIG_fail;
23949 {
23950 PyThreadState* __tstate = wxPyBeginAllowThreads();
23951 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23952
23953 wxPyEndAllowThreads(__tstate);
23954 if (PyErr_Occurred()) SWIG_fail;
23955 }
23956 {
23957 resultobj = wxPyMake_wxObject(result, 0);
23958 }
23959 return resultobj;
23960 fail:
23961 return NULL;
23962 }
23963
23964
23965 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23966 PyObject *resultobj;
23967 wxPyApp *arg1 = (wxPyApp *) 0 ;
23968 bool arg2 ;
23969 PyObject * obj0 = 0 ;
23970 PyObject * obj1 = 0 ;
23971 char *kwnames[] = {
23972 (char *) "self",(char *) "flag", NULL
23973 };
23974
23975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23977 if (SWIG_arg_fail(1)) SWIG_fail;
23978 {
23979 arg2 = (bool)(SWIG_As_bool(obj1));
23980 if (SWIG_arg_fail(2)) SWIG_fail;
23981 }
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 (arg1)->SetExitOnFrameDelete(arg2);
23985
23986 wxPyEndAllowThreads(__tstate);
23987 if (PyErr_Occurred()) SWIG_fail;
23988 }
23989 Py_INCREF(Py_None); resultobj = Py_None;
23990 return resultobj;
23991 fail:
23992 return NULL;
23993 }
23994
23995
23996 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23997 PyObject *resultobj;
23998 wxPyApp *arg1 = (wxPyApp *) 0 ;
23999 bool result;
24000 PyObject * obj0 = 0 ;
24001 char *kwnames[] = {
24002 (char *) "self", NULL
24003 };
24004
24005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24007 if (SWIG_arg_fail(1)) SWIG_fail;
24008 {
24009 PyThreadState* __tstate = wxPyBeginAllowThreads();
24010 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24011
24012 wxPyEndAllowThreads(__tstate);
24013 if (PyErr_Occurred()) SWIG_fail;
24014 }
24015 {
24016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24017 }
24018 return resultobj;
24019 fail:
24020 return NULL;
24021 }
24022
24023
24024 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24025 PyObject *resultobj;
24026 wxPyApp *arg1 = (wxPyApp *) 0 ;
24027 bool arg2 ;
24028 PyObject * obj0 = 0 ;
24029 PyObject * obj1 = 0 ;
24030 char *kwnames[] = {
24031 (char *) "self",(char *) "flag", NULL
24032 };
24033
24034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24036 if (SWIG_arg_fail(1)) SWIG_fail;
24037 {
24038 arg2 = (bool)(SWIG_As_bool(obj1));
24039 if (SWIG_arg_fail(2)) SWIG_fail;
24040 }
24041 {
24042 PyThreadState* __tstate = wxPyBeginAllowThreads();
24043 (arg1)->SetUseBestVisual(arg2);
24044
24045 wxPyEndAllowThreads(__tstate);
24046 if (PyErr_Occurred()) SWIG_fail;
24047 }
24048 Py_INCREF(Py_None); resultobj = Py_None;
24049 return resultobj;
24050 fail:
24051 return NULL;
24052 }
24053
24054
24055 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24056 PyObject *resultobj;
24057 wxPyApp *arg1 = (wxPyApp *) 0 ;
24058 bool result;
24059 PyObject * obj0 = 0 ;
24060 char *kwnames[] = {
24061 (char *) "self", NULL
24062 };
24063
24064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24066 if (SWIG_arg_fail(1)) SWIG_fail;
24067 {
24068 PyThreadState* __tstate = wxPyBeginAllowThreads();
24069 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24070
24071 wxPyEndAllowThreads(__tstate);
24072 if (PyErr_Occurred()) SWIG_fail;
24073 }
24074 {
24075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24076 }
24077 return resultobj;
24078 fail:
24079 return NULL;
24080 }
24081
24082
24083 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24084 PyObject *resultobj;
24085 wxPyApp *arg1 = (wxPyApp *) 0 ;
24086 int arg2 ;
24087 PyObject * obj0 = 0 ;
24088 PyObject * obj1 = 0 ;
24089 char *kwnames[] = {
24090 (char *) "self",(char *) "mode", NULL
24091 };
24092
24093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24095 if (SWIG_arg_fail(1)) SWIG_fail;
24096 {
24097 arg2 = (int)(SWIG_As_int(obj1));
24098 if (SWIG_arg_fail(2)) SWIG_fail;
24099 }
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 (arg1)->SetPrintMode(arg2);
24103
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 Py_INCREF(Py_None); resultobj = Py_None;
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24115 PyObject *resultobj;
24116 wxPyApp *arg1 = (wxPyApp *) 0 ;
24117 int result;
24118 PyObject * obj0 = 0 ;
24119 char *kwnames[] = {
24120 (char *) "self", NULL
24121 };
24122
24123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24125 if (SWIG_arg_fail(1)) SWIG_fail;
24126 {
24127 PyThreadState* __tstate = wxPyBeginAllowThreads();
24128 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24129
24130 wxPyEndAllowThreads(__tstate);
24131 if (PyErr_Occurred()) SWIG_fail;
24132 }
24133 {
24134 resultobj = SWIG_From_int((int)(result));
24135 }
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24143 PyObject *resultobj;
24144 wxPyApp *arg1 = (wxPyApp *) 0 ;
24145 int arg2 ;
24146 PyObject * obj0 = 0 ;
24147 PyObject * obj1 = 0 ;
24148 char *kwnames[] = {
24149 (char *) "self",(char *) "mode", NULL
24150 };
24151
24152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24154 if (SWIG_arg_fail(1)) SWIG_fail;
24155 {
24156 arg2 = (int)(SWIG_As_int(obj1));
24157 if (SWIG_arg_fail(2)) SWIG_fail;
24158 }
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 (arg1)->SetAssertMode(arg2);
24162
24163 wxPyEndAllowThreads(__tstate);
24164 if (PyErr_Occurred()) SWIG_fail;
24165 }
24166 Py_INCREF(Py_None); resultobj = Py_None;
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24174 PyObject *resultobj;
24175 wxPyApp *arg1 = (wxPyApp *) 0 ;
24176 int result;
24177 PyObject * obj0 = 0 ;
24178 char *kwnames[] = {
24179 (char *) "self", NULL
24180 };
24181
24182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24184 if (SWIG_arg_fail(1)) SWIG_fail;
24185 {
24186 PyThreadState* __tstate = wxPyBeginAllowThreads();
24187 result = (int)(arg1)->GetAssertMode();
24188
24189 wxPyEndAllowThreads(__tstate);
24190 if (PyErr_Occurred()) SWIG_fail;
24191 }
24192 {
24193 resultobj = SWIG_From_int((int)(result));
24194 }
24195 return resultobj;
24196 fail:
24197 return NULL;
24198 }
24199
24200
24201 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24202 PyObject *resultobj;
24203 bool result;
24204 char *kwnames[] = {
24205 NULL
24206 };
24207
24208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24209 {
24210 PyThreadState* __tstate = wxPyBeginAllowThreads();
24211 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24212
24213 wxPyEndAllowThreads(__tstate);
24214 if (PyErr_Occurred()) SWIG_fail;
24215 }
24216 {
24217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24218 }
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24226 PyObject *resultobj;
24227 long result;
24228 char *kwnames[] = {
24229 NULL
24230 };
24231
24232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24233 {
24234 PyThreadState* __tstate = wxPyBeginAllowThreads();
24235 result = (long)wxPyApp::GetMacAboutMenuItemId();
24236
24237 wxPyEndAllowThreads(__tstate);
24238 if (PyErr_Occurred()) SWIG_fail;
24239 }
24240 {
24241 resultobj = SWIG_From_long((long)(result));
24242 }
24243 return resultobj;
24244 fail:
24245 return NULL;
24246 }
24247
24248
24249 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24250 PyObject *resultobj;
24251 long result;
24252 char *kwnames[] = {
24253 NULL
24254 };
24255
24256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24257 {
24258 PyThreadState* __tstate = wxPyBeginAllowThreads();
24259 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24260
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 {
24265 resultobj = SWIG_From_long((long)(result));
24266 }
24267 return resultobj;
24268 fail:
24269 return NULL;
24270 }
24271
24272
24273 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24274 PyObject *resultobj;
24275 long result;
24276 char *kwnames[] = {
24277 NULL
24278 };
24279
24280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 result = (long)wxPyApp::GetMacExitMenuItemId();
24284
24285 wxPyEndAllowThreads(__tstate);
24286 if (PyErr_Occurred()) SWIG_fail;
24287 }
24288 {
24289 resultobj = SWIG_From_long((long)(result));
24290 }
24291 return resultobj;
24292 fail:
24293 return NULL;
24294 }
24295
24296
24297 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24298 PyObject *resultobj;
24299 wxString result;
24300 char *kwnames[] = {
24301 NULL
24302 };
24303
24304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24305 {
24306 PyThreadState* __tstate = wxPyBeginAllowThreads();
24307 result = wxPyApp::GetMacHelpMenuTitleName();
24308
24309 wxPyEndAllowThreads(__tstate);
24310 if (PyErr_Occurred()) SWIG_fail;
24311 }
24312 {
24313 #if wxUSE_UNICODE
24314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24315 #else
24316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24317 #endif
24318 }
24319 return resultobj;
24320 fail:
24321 return NULL;
24322 }
24323
24324
24325 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24326 PyObject *resultobj;
24327 bool arg1 ;
24328 PyObject * obj0 = 0 ;
24329 char *kwnames[] = {
24330 (char *) "val", NULL
24331 };
24332
24333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24334 {
24335 arg1 = (bool)(SWIG_As_bool(obj0));
24336 if (SWIG_arg_fail(1)) SWIG_fail;
24337 }
24338 {
24339 PyThreadState* __tstate = wxPyBeginAllowThreads();
24340 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24341
24342 wxPyEndAllowThreads(__tstate);
24343 if (PyErr_Occurred()) SWIG_fail;
24344 }
24345 Py_INCREF(Py_None); resultobj = Py_None;
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24353 PyObject *resultobj;
24354 long arg1 ;
24355 PyObject * obj0 = 0 ;
24356 char *kwnames[] = {
24357 (char *) "val", NULL
24358 };
24359
24360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24361 {
24362 arg1 = (long)(SWIG_As_long(obj0));
24363 if (SWIG_arg_fail(1)) SWIG_fail;
24364 }
24365 {
24366 PyThreadState* __tstate = wxPyBeginAllowThreads();
24367 wxPyApp::SetMacAboutMenuItemId(arg1);
24368
24369 wxPyEndAllowThreads(__tstate);
24370 if (PyErr_Occurred()) SWIG_fail;
24371 }
24372 Py_INCREF(Py_None); resultobj = Py_None;
24373 return resultobj;
24374 fail:
24375 return NULL;
24376 }
24377
24378
24379 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24380 PyObject *resultobj;
24381 long arg1 ;
24382 PyObject * obj0 = 0 ;
24383 char *kwnames[] = {
24384 (char *) "val", NULL
24385 };
24386
24387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24388 {
24389 arg1 = (long)(SWIG_As_long(obj0));
24390 if (SWIG_arg_fail(1)) SWIG_fail;
24391 }
24392 {
24393 PyThreadState* __tstate = wxPyBeginAllowThreads();
24394 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24395
24396 wxPyEndAllowThreads(__tstate);
24397 if (PyErr_Occurred()) SWIG_fail;
24398 }
24399 Py_INCREF(Py_None); resultobj = Py_None;
24400 return resultobj;
24401 fail:
24402 return NULL;
24403 }
24404
24405
24406 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj;
24408 long arg1 ;
24409 PyObject * obj0 = 0 ;
24410 char *kwnames[] = {
24411 (char *) "val", NULL
24412 };
24413
24414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24415 {
24416 arg1 = (long)(SWIG_As_long(obj0));
24417 if (SWIG_arg_fail(1)) SWIG_fail;
24418 }
24419 {
24420 PyThreadState* __tstate = wxPyBeginAllowThreads();
24421 wxPyApp::SetMacExitMenuItemId(arg1);
24422
24423 wxPyEndAllowThreads(__tstate);
24424 if (PyErr_Occurred()) SWIG_fail;
24425 }
24426 Py_INCREF(Py_None); resultobj = Py_None;
24427 return resultobj;
24428 fail:
24429 return NULL;
24430 }
24431
24432
24433 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24434 PyObject *resultobj;
24435 wxString *arg1 = 0 ;
24436 bool temp1 = false ;
24437 PyObject * obj0 = 0 ;
24438 char *kwnames[] = {
24439 (char *) "val", NULL
24440 };
24441
24442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24443 {
24444 arg1 = wxString_in_helper(obj0);
24445 if (arg1 == NULL) SWIG_fail;
24446 temp1 = true;
24447 }
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24451
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 Py_INCREF(Py_None); resultobj = Py_None;
24456 {
24457 if (temp1)
24458 delete arg1;
24459 }
24460 return resultobj;
24461 fail:
24462 {
24463 if (temp1)
24464 delete arg1;
24465 }
24466 return NULL;
24467 }
24468
24469
24470 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24471 PyObject *resultobj;
24472 wxPyApp *arg1 = (wxPyApp *) 0 ;
24473 PyObject * obj0 = 0 ;
24474 char *kwnames[] = {
24475 (char *) "self", NULL
24476 };
24477
24478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24480 if (SWIG_arg_fail(1)) SWIG_fail;
24481 {
24482 PyThreadState* __tstate = wxPyBeginAllowThreads();
24483 (arg1)->_BootstrapApp();
24484
24485 wxPyEndAllowThreads(__tstate);
24486 if (PyErr_Occurred()) SWIG_fail;
24487 }
24488 Py_INCREF(Py_None); resultobj = Py_None;
24489 return resultobj;
24490 fail:
24491 return NULL;
24492 }
24493
24494
24495 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24496 PyObject *resultobj;
24497 int result;
24498 char *kwnames[] = {
24499 NULL
24500 };
24501
24502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24503 {
24504 PyThreadState* __tstate = wxPyBeginAllowThreads();
24505 result = (int)PyApp_GetComCtl32Version();
24506
24507 wxPyEndAllowThreads(__tstate);
24508 if (PyErr_Occurred()) SWIG_fail;
24509 }
24510 {
24511 resultobj = SWIG_From_int((int)(result));
24512 }
24513 return resultobj;
24514 fail:
24515 return NULL;
24516 }
24517
24518
24519 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24520 PyObject *obj;
24521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24522 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24523 Py_INCREF(obj);
24524 return Py_BuildValue((char *)"");
24525 }
24526 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24527 PyObject *resultobj;
24528 char *kwnames[] = {
24529 NULL
24530 };
24531
24532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24533 {
24534 PyThreadState* __tstate = wxPyBeginAllowThreads();
24535 wxExit();
24536
24537 wxPyEndAllowThreads(__tstate);
24538 if (PyErr_Occurred()) SWIG_fail;
24539 }
24540 Py_INCREF(Py_None); resultobj = Py_None;
24541 return resultobj;
24542 fail:
24543 return NULL;
24544 }
24545
24546
24547 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24548 PyObject *resultobj;
24549 bool result;
24550 char *kwnames[] = {
24551 NULL
24552 };
24553
24554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24555 {
24556 PyThreadState* __tstate = wxPyBeginAllowThreads();
24557 result = (bool)wxYield();
24558
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 {
24563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24564 }
24565 return resultobj;
24566 fail:
24567 return NULL;
24568 }
24569
24570
24571 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24572 PyObject *resultobj;
24573 bool result;
24574 char *kwnames[] = {
24575 NULL
24576 };
24577
24578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24579 {
24580 PyThreadState* __tstate = wxPyBeginAllowThreads();
24581 result = (bool)wxYieldIfNeeded();
24582
24583 wxPyEndAllowThreads(__tstate);
24584 if (PyErr_Occurred()) SWIG_fail;
24585 }
24586 {
24587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24588 }
24589 return resultobj;
24590 fail:
24591 return NULL;
24592 }
24593
24594
24595 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24596 PyObject *resultobj;
24597 wxWindow *arg1 = (wxWindow *) NULL ;
24598 bool arg2 = (bool) false ;
24599 bool result;
24600 PyObject * obj0 = 0 ;
24601 PyObject * obj1 = 0 ;
24602 char *kwnames[] = {
24603 (char *) "win",(char *) "onlyIfNeeded", NULL
24604 };
24605
24606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24607 if (obj0) {
24608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24609 if (SWIG_arg_fail(1)) SWIG_fail;
24610 }
24611 if (obj1) {
24612 {
24613 arg2 = (bool)(SWIG_As_bool(obj1));
24614 if (SWIG_arg_fail(2)) SWIG_fail;
24615 }
24616 }
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 result = (bool)wxSafeYield(arg1,arg2);
24620
24621 wxPyEndAllowThreads(__tstate);
24622 if (PyErr_Occurred()) SWIG_fail;
24623 }
24624 {
24625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24626 }
24627 return resultobj;
24628 fail:
24629 return NULL;
24630 }
24631
24632
24633 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24634 PyObject *resultobj;
24635 char *kwnames[] = {
24636 NULL
24637 };
24638
24639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24640 {
24641 PyThreadState* __tstate = wxPyBeginAllowThreads();
24642 wxWakeUpIdle();
24643
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 Py_INCREF(Py_None); resultobj = Py_None;
24648 return resultobj;
24649 fail:
24650 return NULL;
24651 }
24652
24653
24654 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24655 PyObject *resultobj;
24656 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24657 wxEvent *arg2 = 0 ;
24658 PyObject * obj0 = 0 ;
24659 PyObject * obj1 = 0 ;
24660 char *kwnames[] = {
24661 (char *) "dest",(char *) "event", NULL
24662 };
24663
24664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24666 if (SWIG_arg_fail(1)) SWIG_fail;
24667 {
24668 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24669 if (SWIG_arg_fail(2)) SWIG_fail;
24670 if (arg2 == NULL) {
24671 SWIG_null_ref("wxEvent");
24672 }
24673 if (SWIG_arg_fail(2)) SWIG_fail;
24674 }
24675 {
24676 PyThreadState* __tstate = wxPyBeginAllowThreads();
24677 wxPostEvent(arg1,*arg2);
24678
24679 wxPyEndAllowThreads(__tstate);
24680 if (PyErr_Occurred()) SWIG_fail;
24681 }
24682 Py_INCREF(Py_None); resultobj = Py_None;
24683 return resultobj;
24684 fail:
24685 return NULL;
24686 }
24687
24688
24689 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24690 PyObject *resultobj;
24691 char *kwnames[] = {
24692 NULL
24693 };
24694
24695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24696 {
24697 PyThreadState* __tstate = wxPyBeginAllowThreads();
24698 wxApp_CleanUp();
24699
24700 wxPyEndAllowThreads(__tstate);
24701 if (PyErr_Occurred()) SWIG_fail;
24702 }
24703 Py_INCREF(Py_None); resultobj = Py_None;
24704 return resultobj;
24705 fail:
24706 return NULL;
24707 }
24708
24709
24710 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24711 PyObject *resultobj;
24712 wxPyApp *result;
24713 char *kwnames[] = {
24714 NULL
24715 };
24716
24717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24718 {
24719 PyThreadState* __tstate = wxPyBeginAllowThreads();
24720 result = (wxPyApp *)wxPyGetApp();
24721
24722 wxPyEndAllowThreads(__tstate);
24723 if (PyErr_Occurred()) SWIG_fail;
24724 }
24725 {
24726 resultobj = wxPyMake_wxObject(result, 0);
24727 }
24728 return resultobj;
24729 fail:
24730 return NULL;
24731 }
24732
24733
24734 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24735 PyObject *resultobj;
24736 char *arg1 = (char *) 0 ;
24737 PyObject * obj0 = 0 ;
24738 char *kwnames[] = {
24739 (char *) "encoding", NULL
24740 };
24741
24742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24743 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24744 SWIG_arg_fail(1);SWIG_fail;
24745 }
24746 {
24747 PyThreadState* __tstate = wxPyBeginAllowThreads();
24748 wxSetDefaultPyEncoding((char const *)arg1);
24749
24750 wxPyEndAllowThreads(__tstate);
24751 if (PyErr_Occurred()) SWIG_fail;
24752 }
24753 Py_INCREF(Py_None); resultobj = Py_None;
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24761 PyObject *resultobj;
24762 char *result;
24763 char *kwnames[] = {
24764 NULL
24765 };
24766
24767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24768 {
24769 PyThreadState* __tstate = wxPyBeginAllowThreads();
24770 result = (char *)wxGetDefaultPyEncoding();
24771
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 resultobj = SWIG_FromCharPtr(result);
24776 return resultobj;
24777 fail:
24778 return NULL;
24779 }
24780
24781
24782 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24783 PyObject *resultobj;
24784 wxEventLoop *result;
24785 char *kwnames[] = {
24786 NULL
24787 };
24788
24789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24790 {
24791 PyThreadState* __tstate = wxPyBeginAllowThreads();
24792 result = (wxEventLoop *)new wxEventLoop();
24793
24794 wxPyEndAllowThreads(__tstate);
24795 if (PyErr_Occurred()) SWIG_fail;
24796 }
24797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24798 return resultobj;
24799 fail:
24800 return NULL;
24801 }
24802
24803
24804 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24805 PyObject *resultobj;
24806 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24807 PyObject * obj0 = 0 ;
24808 char *kwnames[] = {
24809 (char *) "self", NULL
24810 };
24811
24812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24814 if (SWIG_arg_fail(1)) SWIG_fail;
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 delete arg1;
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 Py_INCREF(Py_None); resultobj = Py_None;
24823 return resultobj;
24824 fail:
24825 return NULL;
24826 }
24827
24828
24829 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24830 PyObject *resultobj;
24831 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24832 int result;
24833 PyObject * obj0 = 0 ;
24834 char *kwnames[] = {
24835 (char *) "self", NULL
24836 };
24837
24838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24840 if (SWIG_arg_fail(1)) SWIG_fail;
24841 {
24842 PyThreadState* __tstate = wxPyBeginAllowThreads();
24843 result = (int)(arg1)->Run();
24844
24845 wxPyEndAllowThreads(__tstate);
24846 if (PyErr_Occurred()) SWIG_fail;
24847 }
24848 {
24849 resultobj = SWIG_From_int((int)(result));
24850 }
24851 return resultobj;
24852 fail:
24853 return NULL;
24854 }
24855
24856
24857 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24858 PyObject *resultobj;
24859 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24860 int arg2 = (int) 0 ;
24861 PyObject * obj0 = 0 ;
24862 PyObject * obj1 = 0 ;
24863 char *kwnames[] = {
24864 (char *) "self",(char *) "rc", NULL
24865 };
24866
24867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24869 if (SWIG_arg_fail(1)) SWIG_fail;
24870 if (obj1) {
24871 {
24872 arg2 = (int)(SWIG_As_int(obj1));
24873 if (SWIG_arg_fail(2)) SWIG_fail;
24874 }
24875 }
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 (arg1)->Exit(arg2);
24879
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 Py_INCREF(Py_None); resultobj = Py_None;
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24891 PyObject *resultobj;
24892 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24893 bool result;
24894 PyObject * obj0 = 0 ;
24895 char *kwnames[] = {
24896 (char *) "self", NULL
24897 };
24898
24899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24901 if (SWIG_arg_fail(1)) SWIG_fail;
24902 {
24903 PyThreadState* __tstate = wxPyBeginAllowThreads();
24904 result = (bool)((wxEventLoop const *)arg1)->Pending();
24905
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 {
24910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24911 }
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24919 PyObject *resultobj;
24920 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24921 bool result;
24922 PyObject * obj0 = 0 ;
24923 char *kwnames[] = {
24924 (char *) "self", NULL
24925 };
24926
24927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24929 if (SWIG_arg_fail(1)) SWIG_fail;
24930 {
24931 PyThreadState* __tstate = wxPyBeginAllowThreads();
24932 result = (bool)(arg1)->Dispatch();
24933
24934 wxPyEndAllowThreads(__tstate);
24935 if (PyErr_Occurred()) SWIG_fail;
24936 }
24937 {
24938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24939 }
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24947 PyObject *resultobj;
24948 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24949 bool result;
24950 PyObject * obj0 = 0 ;
24951 char *kwnames[] = {
24952 (char *) "self", NULL
24953 };
24954
24955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24957 if (SWIG_arg_fail(1)) SWIG_fail;
24958 {
24959 PyThreadState* __tstate = wxPyBeginAllowThreads();
24960 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24961
24962 wxPyEndAllowThreads(__tstate);
24963 if (PyErr_Occurred()) SWIG_fail;
24964 }
24965 {
24966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24967 }
24968 return resultobj;
24969 fail:
24970 return NULL;
24971 }
24972
24973
24974 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24975 PyObject *resultobj;
24976 wxEventLoop *result;
24977 char *kwnames[] = {
24978 NULL
24979 };
24980
24981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24982 {
24983 PyThreadState* __tstate = wxPyBeginAllowThreads();
24984 result = (wxEventLoop *)wxEventLoop::GetActive();
24985
24986 wxPyEndAllowThreads(__tstate);
24987 if (PyErr_Occurred()) SWIG_fail;
24988 }
24989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24990 return resultobj;
24991 fail:
24992 return NULL;
24993 }
24994
24995
24996 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24997 PyObject *resultobj;
24998 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24999 PyObject * obj0 = 0 ;
25000 char *kwnames[] = {
25001 (char *) "loop", NULL
25002 };
25003
25004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25006 if (SWIG_arg_fail(1)) SWIG_fail;
25007 {
25008 PyThreadState* __tstate = wxPyBeginAllowThreads();
25009 wxEventLoop::SetActive(arg1);
25010
25011 wxPyEndAllowThreads(__tstate);
25012 if (PyErr_Occurred()) SWIG_fail;
25013 }
25014 Py_INCREF(Py_None); resultobj = Py_None;
25015 return resultobj;
25016 fail:
25017 return NULL;
25018 }
25019
25020
25021 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25022 PyObject *obj;
25023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25024 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25025 Py_INCREF(obj);
25026 return Py_BuildValue((char *)"");
25027 }
25028 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25029 PyObject *resultobj;
25030 int arg1 = (int) 0 ;
25031 int arg2 = (int) 0 ;
25032 int arg3 = (int) 0 ;
25033 wxAcceleratorEntry *result;
25034 PyObject * obj0 = 0 ;
25035 PyObject * obj1 = 0 ;
25036 PyObject * obj2 = 0 ;
25037 char *kwnames[] = {
25038 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25039 };
25040
25041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25042 if (obj0) {
25043 {
25044 arg1 = (int)(SWIG_As_int(obj0));
25045 if (SWIG_arg_fail(1)) SWIG_fail;
25046 }
25047 }
25048 if (obj1) {
25049 {
25050 arg2 = (int)(SWIG_As_int(obj1));
25051 if (SWIG_arg_fail(2)) SWIG_fail;
25052 }
25053 }
25054 if (obj2) {
25055 {
25056 arg3 = (int)(SWIG_As_int(obj2));
25057 if (SWIG_arg_fail(3)) SWIG_fail;
25058 }
25059 }
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25063
25064 wxPyEndAllowThreads(__tstate);
25065 if (PyErr_Occurred()) SWIG_fail;
25066 }
25067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25068 return resultobj;
25069 fail:
25070 return NULL;
25071 }
25072
25073
25074 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25075 PyObject *resultobj;
25076 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25077 PyObject * obj0 = 0 ;
25078 char *kwnames[] = {
25079 (char *) "self", NULL
25080 };
25081
25082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25084 if (SWIG_arg_fail(1)) SWIG_fail;
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 delete arg1;
25088
25089 wxPyEndAllowThreads(__tstate);
25090 if (PyErr_Occurred()) SWIG_fail;
25091 }
25092 Py_INCREF(Py_None); resultobj = Py_None;
25093 return resultobj;
25094 fail:
25095 return NULL;
25096 }
25097
25098
25099 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25100 PyObject *resultobj;
25101 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25102 int arg2 ;
25103 int arg3 ;
25104 int arg4 ;
25105 PyObject * obj0 = 0 ;
25106 PyObject * obj1 = 0 ;
25107 PyObject * obj2 = 0 ;
25108 PyObject * obj3 = 0 ;
25109 char *kwnames[] = {
25110 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25111 };
25112
25113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25115 if (SWIG_arg_fail(1)) SWIG_fail;
25116 {
25117 arg2 = (int)(SWIG_As_int(obj1));
25118 if (SWIG_arg_fail(2)) SWIG_fail;
25119 }
25120 {
25121 arg3 = (int)(SWIG_As_int(obj2));
25122 if (SWIG_arg_fail(3)) SWIG_fail;
25123 }
25124 {
25125 arg4 = (int)(SWIG_As_int(obj3));
25126 if (SWIG_arg_fail(4)) SWIG_fail;
25127 }
25128 {
25129 PyThreadState* __tstate = wxPyBeginAllowThreads();
25130 (arg1)->Set(arg2,arg3,arg4);
25131
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 Py_INCREF(Py_None); resultobj = Py_None;
25136 return resultobj;
25137 fail:
25138 return NULL;
25139 }
25140
25141
25142 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25143 PyObject *resultobj;
25144 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25145 int result;
25146 PyObject * obj0 = 0 ;
25147 char *kwnames[] = {
25148 (char *) "self", NULL
25149 };
25150
25151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25153 if (SWIG_arg_fail(1)) SWIG_fail;
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (int)(arg1)->GetFlags();
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 resultobj = SWIG_From_int((int)(result));
25163 }
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj;
25172 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25173 int result;
25174 PyObject * obj0 = 0 ;
25175 char *kwnames[] = {
25176 (char *) "self", NULL
25177 };
25178
25179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25181 if (SWIG_arg_fail(1)) SWIG_fail;
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 result = (int)(arg1)->GetKeyCode();
25185
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 {
25190 resultobj = SWIG_From_int((int)(result));
25191 }
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj;
25200 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25201 int result;
25202 PyObject * obj0 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "self", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(1)) SWIG_fail;
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = (int)(arg1)->GetCommand();
25213
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 resultobj = SWIG_From_int((int)(result));
25219 }
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25227 PyObject *obj;
25228 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25229 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25230 Py_INCREF(obj);
25231 return Py_BuildValue((char *)"");
25232 }
25233 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25234 PyObject *resultobj;
25235 int arg1 ;
25236 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25237 wxAcceleratorTable *result;
25238 PyObject * obj0 = 0 ;
25239 char *kwnames[] = {
25240 (char *) "n", NULL
25241 };
25242
25243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25244 {
25245 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25246 if (arg2) arg1 = PyList_Size(obj0);
25247 else arg1 = 0;
25248 }
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25252
25253 wxPyEndAllowThreads(__tstate);
25254 if (PyErr_Occurred()) SWIG_fail;
25255 }
25256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25257 {
25258 delete [] arg2;
25259 }
25260 return resultobj;
25261 fail:
25262 {
25263 delete [] arg2;
25264 }
25265 return NULL;
25266 }
25267
25268
25269 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25270 PyObject *resultobj;
25271 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25272 PyObject * obj0 = 0 ;
25273 char *kwnames[] = {
25274 (char *) "self", NULL
25275 };
25276
25277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25279 if (SWIG_arg_fail(1)) SWIG_fail;
25280 {
25281 PyThreadState* __tstate = wxPyBeginAllowThreads();
25282 delete arg1;
25283
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 Py_INCREF(Py_None); resultobj = Py_None;
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25295 PyObject *resultobj;
25296 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25297 bool result;
25298 PyObject * obj0 = 0 ;
25299 char *kwnames[] = {
25300 (char *) "self", NULL
25301 };
25302
25303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25305 if (SWIG_arg_fail(1)) SWIG_fail;
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25309
25310 wxPyEndAllowThreads(__tstate);
25311 if (PyErr_Occurred()) SWIG_fail;
25312 }
25313 {
25314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25315 }
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25323 PyObject *obj;
25324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25325 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25326 Py_INCREF(obj);
25327 return Py_BuildValue((char *)"");
25328 }
25329 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25330 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25331 return 1;
25332 }
25333
25334
25335 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25336 PyObject *pyobj;
25337
25338 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25339 return pyobj;
25340 }
25341
25342
25343 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25344 PyObject *resultobj;
25345 wxString *arg1 = 0 ;
25346 wxAcceleratorEntry *result;
25347 bool temp1 = false ;
25348 PyObject * obj0 = 0 ;
25349 char *kwnames[] = {
25350 (char *) "label", NULL
25351 };
25352
25353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25354 {
25355 arg1 = wxString_in_helper(obj0);
25356 if (arg1 == NULL) SWIG_fail;
25357 temp1 = true;
25358 }
25359 {
25360 PyThreadState* __tstate = wxPyBeginAllowThreads();
25361 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25362
25363 wxPyEndAllowThreads(__tstate);
25364 if (PyErr_Occurred()) SWIG_fail;
25365 }
25366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25367 {
25368 if (temp1)
25369 delete arg1;
25370 }
25371 return resultobj;
25372 fail:
25373 {
25374 if (temp1)
25375 delete arg1;
25376 }
25377 return NULL;
25378 }
25379
25380
25381 static int _wrap_PanelNameStr_set(PyObject *) {
25382 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25383 return 1;
25384 }
25385
25386
25387 static PyObject *_wrap_PanelNameStr_get(void) {
25388 PyObject *pyobj;
25389
25390 {
25391 #if wxUSE_UNICODE
25392 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25393 #else
25394 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25395 #endif
25396 }
25397 return pyobj;
25398 }
25399
25400
25401 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25402 PyObject *resultobj;
25403 wxVisualAttributes *result;
25404 char *kwnames[] = {
25405 NULL
25406 };
25407
25408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25409 {
25410 PyThreadState* __tstate = wxPyBeginAllowThreads();
25411 result = (wxVisualAttributes *)new_wxVisualAttributes();
25412
25413 wxPyEndAllowThreads(__tstate);
25414 if (PyErr_Occurred()) SWIG_fail;
25415 }
25416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25417 return resultobj;
25418 fail:
25419 return NULL;
25420 }
25421
25422
25423 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25424 PyObject *resultobj;
25425 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25426 PyObject * obj0 = 0 ;
25427 char *kwnames[] = {
25428 (char *) "self", NULL
25429 };
25430
25431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25433 if (SWIG_arg_fail(1)) SWIG_fail;
25434 {
25435 PyThreadState* __tstate = wxPyBeginAllowThreads();
25436 delete_wxVisualAttributes(arg1);
25437
25438 wxPyEndAllowThreads(__tstate);
25439 if (PyErr_Occurred()) SWIG_fail;
25440 }
25441 Py_INCREF(Py_None); resultobj = Py_None;
25442 return resultobj;
25443 fail:
25444 return NULL;
25445 }
25446
25447
25448 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25449 PyObject *resultobj;
25450 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25451 wxFont *arg2 = (wxFont *) 0 ;
25452 PyObject * obj0 = 0 ;
25453 PyObject * obj1 = 0 ;
25454 char *kwnames[] = {
25455 (char *) "self",(char *) "font", NULL
25456 };
25457
25458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25460 if (SWIG_arg_fail(1)) SWIG_fail;
25461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25462 if (SWIG_arg_fail(2)) SWIG_fail;
25463 if (arg1) (arg1)->font = *arg2;
25464
25465 Py_INCREF(Py_None); resultobj = Py_None;
25466 return resultobj;
25467 fail:
25468 return NULL;
25469 }
25470
25471
25472 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25473 PyObject *resultobj;
25474 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25475 wxFont *result;
25476 PyObject * obj0 = 0 ;
25477 char *kwnames[] = {
25478 (char *) "self", NULL
25479 };
25480
25481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25483 if (SWIG_arg_fail(1)) SWIG_fail;
25484 result = (wxFont *)& ((arg1)->font);
25485
25486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25487 return resultobj;
25488 fail:
25489 return NULL;
25490 }
25491
25492
25493 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25494 PyObject *resultobj;
25495 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25496 wxColour *arg2 = (wxColour *) 0 ;
25497 PyObject * obj0 = 0 ;
25498 PyObject * obj1 = 0 ;
25499 char *kwnames[] = {
25500 (char *) "self",(char *) "colFg", NULL
25501 };
25502
25503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25505 if (SWIG_arg_fail(1)) SWIG_fail;
25506 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25507 if (SWIG_arg_fail(2)) SWIG_fail;
25508 if (arg1) (arg1)->colFg = *arg2;
25509
25510 Py_INCREF(Py_None); resultobj = Py_None;
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25518 PyObject *resultobj;
25519 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25520 wxColour *result;
25521 PyObject * obj0 = 0 ;
25522 char *kwnames[] = {
25523 (char *) "self", NULL
25524 };
25525
25526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25528 if (SWIG_arg_fail(1)) SWIG_fail;
25529 result = (wxColour *)& ((arg1)->colFg);
25530
25531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25532 return resultobj;
25533 fail:
25534 return NULL;
25535 }
25536
25537
25538 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25539 PyObject *resultobj;
25540 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25541 wxColour *arg2 = (wxColour *) 0 ;
25542 PyObject * obj0 = 0 ;
25543 PyObject * obj1 = 0 ;
25544 char *kwnames[] = {
25545 (char *) "self",(char *) "colBg", NULL
25546 };
25547
25548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25550 if (SWIG_arg_fail(1)) SWIG_fail;
25551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25552 if (SWIG_arg_fail(2)) SWIG_fail;
25553 if (arg1) (arg1)->colBg = *arg2;
25554
25555 Py_INCREF(Py_None); resultobj = Py_None;
25556 return resultobj;
25557 fail:
25558 return NULL;
25559 }
25560
25561
25562 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25563 PyObject *resultobj;
25564 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25565 wxColour *result;
25566 PyObject * obj0 = 0 ;
25567 char *kwnames[] = {
25568 (char *) "self", NULL
25569 };
25570
25571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25573 if (SWIG_arg_fail(1)) SWIG_fail;
25574 result = (wxColour *)& ((arg1)->colBg);
25575
25576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25584 PyObject *obj;
25585 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25586 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25587 Py_INCREF(obj);
25588 return Py_BuildValue((char *)"");
25589 }
25590 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj;
25592 wxWindow *arg1 = (wxWindow *) 0 ;
25593 int arg2 = (int) (int)-1 ;
25594 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25595 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25596 wxSize const &arg4_defvalue = wxDefaultSize ;
25597 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25598 long arg5 = (long) 0 ;
25599 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25600 wxString *arg6 = (wxString *) &arg6_defvalue ;
25601 wxWindow *result;
25602 wxPoint temp3 ;
25603 wxSize temp4 ;
25604 bool temp6 = false ;
25605 PyObject * obj0 = 0 ;
25606 PyObject * obj1 = 0 ;
25607 PyObject * obj2 = 0 ;
25608 PyObject * obj3 = 0 ;
25609 PyObject * obj4 = 0 ;
25610 PyObject * obj5 = 0 ;
25611 char *kwnames[] = {
25612 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25613 };
25614
25615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25617 if (SWIG_arg_fail(1)) SWIG_fail;
25618 if (obj1) {
25619 {
25620 arg2 = (int const)(SWIG_As_int(obj1));
25621 if (SWIG_arg_fail(2)) SWIG_fail;
25622 }
25623 }
25624 if (obj2) {
25625 {
25626 arg3 = &temp3;
25627 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25628 }
25629 }
25630 if (obj3) {
25631 {
25632 arg4 = &temp4;
25633 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25634 }
25635 }
25636 if (obj4) {
25637 {
25638 arg5 = (long)(SWIG_As_long(obj4));
25639 if (SWIG_arg_fail(5)) SWIG_fail;
25640 }
25641 }
25642 if (obj5) {
25643 {
25644 arg6 = wxString_in_helper(obj5);
25645 if (arg6 == NULL) SWIG_fail;
25646 temp6 = true;
25647 }
25648 }
25649 {
25650 if (!wxPyCheckForApp()) SWIG_fail;
25651 PyThreadState* __tstate = wxPyBeginAllowThreads();
25652 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25653
25654 wxPyEndAllowThreads(__tstate);
25655 if (PyErr_Occurred()) SWIG_fail;
25656 }
25657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25658 {
25659 if (temp6)
25660 delete arg6;
25661 }
25662 return resultobj;
25663 fail:
25664 {
25665 if (temp6)
25666 delete arg6;
25667 }
25668 return NULL;
25669 }
25670
25671
25672 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25673 PyObject *resultobj;
25674 wxWindow *result;
25675 char *kwnames[] = {
25676 NULL
25677 };
25678
25679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25680 {
25681 if (!wxPyCheckForApp()) SWIG_fail;
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 result = (wxWindow *)new wxWindow();
25684
25685 wxPyEndAllowThreads(__tstate);
25686 if (PyErr_Occurred()) SWIG_fail;
25687 }
25688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25696 PyObject *resultobj;
25697 wxWindow *arg1 = (wxWindow *) 0 ;
25698 wxWindow *arg2 = (wxWindow *) 0 ;
25699 int arg3 = (int) (int)-1 ;
25700 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25701 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25702 wxSize const &arg5_defvalue = wxDefaultSize ;
25703 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25704 long arg6 = (long) 0 ;
25705 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25706 wxString *arg7 = (wxString *) &arg7_defvalue ;
25707 bool result;
25708 wxPoint temp4 ;
25709 wxSize temp5 ;
25710 bool temp7 = false ;
25711 PyObject * obj0 = 0 ;
25712 PyObject * obj1 = 0 ;
25713 PyObject * obj2 = 0 ;
25714 PyObject * obj3 = 0 ;
25715 PyObject * obj4 = 0 ;
25716 PyObject * obj5 = 0 ;
25717 PyObject * obj6 = 0 ;
25718 char *kwnames[] = {
25719 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25720 };
25721
25722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25724 if (SWIG_arg_fail(1)) SWIG_fail;
25725 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25726 if (SWIG_arg_fail(2)) SWIG_fail;
25727 if (obj2) {
25728 {
25729 arg3 = (int const)(SWIG_As_int(obj2));
25730 if (SWIG_arg_fail(3)) SWIG_fail;
25731 }
25732 }
25733 if (obj3) {
25734 {
25735 arg4 = &temp4;
25736 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25737 }
25738 }
25739 if (obj4) {
25740 {
25741 arg5 = &temp5;
25742 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25743 }
25744 }
25745 if (obj5) {
25746 {
25747 arg6 = (long)(SWIG_As_long(obj5));
25748 if (SWIG_arg_fail(6)) SWIG_fail;
25749 }
25750 }
25751 if (obj6) {
25752 {
25753 arg7 = wxString_in_helper(obj6);
25754 if (arg7 == NULL) SWIG_fail;
25755 temp7 = true;
25756 }
25757 }
25758 {
25759 PyThreadState* __tstate = wxPyBeginAllowThreads();
25760 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25761
25762 wxPyEndAllowThreads(__tstate);
25763 if (PyErr_Occurred()) SWIG_fail;
25764 }
25765 {
25766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25767 }
25768 {
25769 if (temp7)
25770 delete arg7;
25771 }
25772 return resultobj;
25773 fail:
25774 {
25775 if (temp7)
25776 delete arg7;
25777 }
25778 return NULL;
25779 }
25780
25781
25782 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25783 PyObject *resultobj;
25784 wxWindow *arg1 = (wxWindow *) 0 ;
25785 bool arg2 = (bool) false ;
25786 bool result;
25787 PyObject * obj0 = 0 ;
25788 PyObject * obj1 = 0 ;
25789 char *kwnames[] = {
25790 (char *) "self",(char *) "force", NULL
25791 };
25792
25793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25795 if (SWIG_arg_fail(1)) SWIG_fail;
25796 if (obj1) {
25797 {
25798 arg2 = (bool)(SWIG_As_bool(obj1));
25799 if (SWIG_arg_fail(2)) SWIG_fail;
25800 }
25801 }
25802 {
25803 PyThreadState* __tstate = wxPyBeginAllowThreads();
25804 result = (bool)(arg1)->Close(arg2);
25805
25806 wxPyEndAllowThreads(__tstate);
25807 if (PyErr_Occurred()) SWIG_fail;
25808 }
25809 {
25810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25811 }
25812 return resultobj;
25813 fail:
25814 return NULL;
25815 }
25816
25817
25818 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25819 PyObject *resultobj;
25820 wxWindow *arg1 = (wxWindow *) 0 ;
25821 bool result;
25822 PyObject * obj0 = 0 ;
25823 char *kwnames[] = {
25824 (char *) "self", NULL
25825 };
25826
25827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25829 if (SWIG_arg_fail(1)) SWIG_fail;
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 result = (bool)(arg1)->Destroy();
25833
25834 wxPyEndAllowThreads(__tstate);
25835 if (PyErr_Occurred()) SWIG_fail;
25836 }
25837 {
25838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25839 }
25840 return resultobj;
25841 fail:
25842 return NULL;
25843 }
25844
25845
25846 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25847 PyObject *resultobj;
25848 wxWindow *arg1 = (wxWindow *) 0 ;
25849 bool result;
25850 PyObject * obj0 = 0 ;
25851 char *kwnames[] = {
25852 (char *) "self", NULL
25853 };
25854
25855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25857 if (SWIG_arg_fail(1)) SWIG_fail;
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 result = (bool)(arg1)->DestroyChildren();
25861
25862 wxPyEndAllowThreads(__tstate);
25863 if (PyErr_Occurred()) SWIG_fail;
25864 }
25865 {
25866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25867 }
25868 return resultobj;
25869 fail:
25870 return NULL;
25871 }
25872
25873
25874 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25875 PyObject *resultobj;
25876 wxWindow *arg1 = (wxWindow *) 0 ;
25877 bool result;
25878 PyObject * obj0 = 0 ;
25879 char *kwnames[] = {
25880 (char *) "self", NULL
25881 };
25882
25883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25885 if (SWIG_arg_fail(1)) SWIG_fail;
25886 {
25887 PyThreadState* __tstate = wxPyBeginAllowThreads();
25888 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25889
25890 wxPyEndAllowThreads(__tstate);
25891 if (PyErr_Occurred()) SWIG_fail;
25892 }
25893 {
25894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25895 }
25896 return resultobj;
25897 fail:
25898 return NULL;
25899 }
25900
25901
25902 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25903 PyObject *resultobj;
25904 wxWindow *arg1 = (wxWindow *) 0 ;
25905 wxString *arg2 = 0 ;
25906 bool temp2 = false ;
25907 PyObject * obj0 = 0 ;
25908 PyObject * obj1 = 0 ;
25909 char *kwnames[] = {
25910 (char *) "self",(char *) "label", NULL
25911 };
25912
25913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25915 if (SWIG_arg_fail(1)) SWIG_fail;
25916 {
25917 arg2 = wxString_in_helper(obj1);
25918 if (arg2 == NULL) SWIG_fail;
25919 temp2 = true;
25920 }
25921 {
25922 PyThreadState* __tstate = wxPyBeginAllowThreads();
25923 (arg1)->SetLabel((wxString const &)*arg2);
25924
25925 wxPyEndAllowThreads(__tstate);
25926 if (PyErr_Occurred()) SWIG_fail;
25927 }
25928 Py_INCREF(Py_None); resultobj = Py_None;
25929 {
25930 if (temp2)
25931 delete arg2;
25932 }
25933 return resultobj;
25934 fail:
25935 {
25936 if (temp2)
25937 delete arg2;
25938 }
25939 return NULL;
25940 }
25941
25942
25943 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25944 PyObject *resultobj;
25945 wxWindow *arg1 = (wxWindow *) 0 ;
25946 wxString result;
25947 PyObject * obj0 = 0 ;
25948 char *kwnames[] = {
25949 (char *) "self", NULL
25950 };
25951
25952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25954 if (SWIG_arg_fail(1)) SWIG_fail;
25955 {
25956 PyThreadState* __tstate = wxPyBeginAllowThreads();
25957 result = ((wxWindow const *)arg1)->GetLabel();
25958
25959 wxPyEndAllowThreads(__tstate);
25960 if (PyErr_Occurred()) SWIG_fail;
25961 }
25962 {
25963 #if wxUSE_UNICODE
25964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25965 #else
25966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25967 #endif
25968 }
25969 return resultobj;
25970 fail:
25971 return NULL;
25972 }
25973
25974
25975 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25976 PyObject *resultobj;
25977 wxWindow *arg1 = (wxWindow *) 0 ;
25978 wxString *arg2 = 0 ;
25979 bool temp2 = false ;
25980 PyObject * obj0 = 0 ;
25981 PyObject * obj1 = 0 ;
25982 char *kwnames[] = {
25983 (char *) "self",(char *) "name", NULL
25984 };
25985
25986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25988 if (SWIG_arg_fail(1)) SWIG_fail;
25989 {
25990 arg2 = wxString_in_helper(obj1);
25991 if (arg2 == NULL) SWIG_fail;
25992 temp2 = true;
25993 }
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 (arg1)->SetName((wxString const &)*arg2);
25997
25998 wxPyEndAllowThreads(__tstate);
25999 if (PyErr_Occurred()) SWIG_fail;
26000 }
26001 Py_INCREF(Py_None); resultobj = Py_None;
26002 {
26003 if (temp2)
26004 delete arg2;
26005 }
26006 return resultobj;
26007 fail:
26008 {
26009 if (temp2)
26010 delete arg2;
26011 }
26012 return NULL;
26013 }
26014
26015
26016 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26017 PyObject *resultobj;
26018 wxWindow *arg1 = (wxWindow *) 0 ;
26019 wxString result;
26020 PyObject * obj0 = 0 ;
26021 char *kwnames[] = {
26022 (char *) "self", NULL
26023 };
26024
26025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26027 if (SWIG_arg_fail(1)) SWIG_fail;
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 result = ((wxWindow const *)arg1)->GetName();
26031
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 {
26036 #if wxUSE_UNICODE
26037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26038 #else
26039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26040 #endif
26041 }
26042 return resultobj;
26043 fail:
26044 return NULL;
26045 }
26046
26047
26048 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26049 PyObject *resultobj;
26050 wxWindow *arg1 = (wxWindow *) 0 ;
26051 wxWindowVariant arg2 ;
26052 PyObject * obj0 = 0 ;
26053 PyObject * obj1 = 0 ;
26054 char *kwnames[] = {
26055 (char *) "self",(char *) "variant", NULL
26056 };
26057
26058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26060 if (SWIG_arg_fail(1)) SWIG_fail;
26061 {
26062 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
26063 if (SWIG_arg_fail(2)) SWIG_fail;
26064 }
26065 {
26066 PyThreadState* __tstate = wxPyBeginAllowThreads();
26067 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
26068
26069 wxPyEndAllowThreads(__tstate);
26070 if (PyErr_Occurred()) SWIG_fail;
26071 }
26072 Py_INCREF(Py_None); resultobj = Py_None;
26073 return resultobj;
26074 fail:
26075 return NULL;
26076 }
26077
26078
26079 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26080 PyObject *resultobj;
26081 wxWindow *arg1 = (wxWindow *) 0 ;
26082 wxWindowVariant result;
26083 PyObject * obj0 = 0 ;
26084 char *kwnames[] = {
26085 (char *) "self", NULL
26086 };
26087
26088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26090 if (SWIG_arg_fail(1)) SWIG_fail;
26091 {
26092 PyThreadState* __tstate = wxPyBeginAllowThreads();
26093 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26094
26095 wxPyEndAllowThreads(__tstate);
26096 if (PyErr_Occurred()) SWIG_fail;
26097 }
26098 resultobj = SWIG_From_int((result));
26099 return resultobj;
26100 fail:
26101 return NULL;
26102 }
26103
26104
26105 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26106 PyObject *resultobj;
26107 wxWindow *arg1 = (wxWindow *) 0 ;
26108 int arg2 ;
26109 PyObject * obj0 = 0 ;
26110 PyObject * obj1 = 0 ;
26111 char *kwnames[] = {
26112 (char *) "self",(char *) "winid", NULL
26113 };
26114
26115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26117 if (SWIG_arg_fail(1)) SWIG_fail;
26118 {
26119 arg2 = (int)(SWIG_As_int(obj1));
26120 if (SWIG_arg_fail(2)) SWIG_fail;
26121 }
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 (arg1)->SetId(arg2);
26125
26126 wxPyEndAllowThreads(__tstate);
26127 if (PyErr_Occurred()) SWIG_fail;
26128 }
26129 Py_INCREF(Py_None); resultobj = Py_None;
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj;
26138 wxWindow *arg1 = (wxWindow *) 0 ;
26139 int result;
26140 PyObject * obj0 = 0 ;
26141 char *kwnames[] = {
26142 (char *) "self", NULL
26143 };
26144
26145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26147 if (SWIG_arg_fail(1)) SWIG_fail;
26148 {
26149 PyThreadState* __tstate = wxPyBeginAllowThreads();
26150 result = (int)((wxWindow const *)arg1)->GetId();
26151
26152 wxPyEndAllowThreads(__tstate);
26153 if (PyErr_Occurred()) SWIG_fail;
26154 }
26155 {
26156 resultobj = SWIG_From_int((int)(result));
26157 }
26158 return resultobj;
26159 fail:
26160 return NULL;
26161 }
26162
26163
26164 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26165 PyObject *resultobj;
26166 int result;
26167 char *kwnames[] = {
26168 NULL
26169 };
26170
26171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26172 {
26173 PyThreadState* __tstate = wxPyBeginAllowThreads();
26174 result = (int)wxWindow::NewControlId();
26175
26176 wxPyEndAllowThreads(__tstate);
26177 if (PyErr_Occurred()) SWIG_fail;
26178 }
26179 {
26180 resultobj = SWIG_From_int((int)(result));
26181 }
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26189 PyObject *resultobj;
26190 int arg1 ;
26191 int result;
26192 PyObject * obj0 = 0 ;
26193 char *kwnames[] = {
26194 (char *) "winid", NULL
26195 };
26196
26197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26198 {
26199 arg1 = (int)(SWIG_As_int(obj0));
26200 if (SWIG_arg_fail(1)) SWIG_fail;
26201 }
26202 {
26203 PyThreadState* __tstate = wxPyBeginAllowThreads();
26204 result = (int)wxWindow::NextControlId(arg1);
26205
26206 wxPyEndAllowThreads(__tstate);
26207 if (PyErr_Occurred()) SWIG_fail;
26208 }
26209 {
26210 resultobj = SWIG_From_int((int)(result));
26211 }
26212 return resultobj;
26213 fail:
26214 return NULL;
26215 }
26216
26217
26218 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26219 PyObject *resultobj;
26220 int arg1 ;
26221 int result;
26222 PyObject * obj0 = 0 ;
26223 char *kwnames[] = {
26224 (char *) "winid", NULL
26225 };
26226
26227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26228 {
26229 arg1 = (int)(SWIG_As_int(obj0));
26230 if (SWIG_arg_fail(1)) SWIG_fail;
26231 }
26232 {
26233 PyThreadState* __tstate = wxPyBeginAllowThreads();
26234 result = (int)wxWindow::PrevControlId(arg1);
26235
26236 wxPyEndAllowThreads(__tstate);
26237 if (PyErr_Occurred()) SWIG_fail;
26238 }
26239 {
26240 resultobj = SWIG_From_int((int)(result));
26241 }
26242 return resultobj;
26243 fail:
26244 return NULL;
26245 }
26246
26247
26248 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26249 PyObject *resultobj;
26250 wxWindow *arg1 = (wxWindow *) 0 ;
26251 wxSize *arg2 = 0 ;
26252 wxSize temp2 ;
26253 PyObject * obj0 = 0 ;
26254 PyObject * obj1 = 0 ;
26255 char *kwnames[] = {
26256 (char *) "self",(char *) "size", NULL
26257 };
26258
26259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26261 if (SWIG_arg_fail(1)) SWIG_fail;
26262 {
26263 arg2 = &temp2;
26264 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26265 }
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 (arg1)->SetSize((wxSize const &)*arg2);
26269
26270 wxPyEndAllowThreads(__tstate);
26271 if (PyErr_Occurred()) SWIG_fail;
26272 }
26273 Py_INCREF(Py_None); resultobj = Py_None;
26274 return resultobj;
26275 fail:
26276 return NULL;
26277 }
26278
26279
26280 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26281 PyObject *resultobj;
26282 wxWindow *arg1 = (wxWindow *) 0 ;
26283 int arg2 ;
26284 int arg3 ;
26285 int arg4 ;
26286 int arg5 ;
26287 int arg6 = (int) wxSIZE_AUTO ;
26288 PyObject * obj0 = 0 ;
26289 PyObject * obj1 = 0 ;
26290 PyObject * obj2 = 0 ;
26291 PyObject * obj3 = 0 ;
26292 PyObject * obj4 = 0 ;
26293 PyObject * obj5 = 0 ;
26294 char *kwnames[] = {
26295 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26296 };
26297
26298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26300 if (SWIG_arg_fail(1)) SWIG_fail;
26301 {
26302 arg2 = (int)(SWIG_As_int(obj1));
26303 if (SWIG_arg_fail(2)) SWIG_fail;
26304 }
26305 {
26306 arg3 = (int)(SWIG_As_int(obj2));
26307 if (SWIG_arg_fail(3)) SWIG_fail;
26308 }
26309 {
26310 arg4 = (int)(SWIG_As_int(obj3));
26311 if (SWIG_arg_fail(4)) SWIG_fail;
26312 }
26313 {
26314 arg5 = (int)(SWIG_As_int(obj4));
26315 if (SWIG_arg_fail(5)) SWIG_fail;
26316 }
26317 if (obj5) {
26318 {
26319 arg6 = (int)(SWIG_As_int(obj5));
26320 if (SWIG_arg_fail(6)) SWIG_fail;
26321 }
26322 }
26323 {
26324 PyThreadState* __tstate = wxPyBeginAllowThreads();
26325 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26326
26327 wxPyEndAllowThreads(__tstate);
26328 if (PyErr_Occurred()) SWIG_fail;
26329 }
26330 Py_INCREF(Py_None); resultobj = Py_None;
26331 return resultobj;
26332 fail:
26333 return NULL;
26334 }
26335
26336
26337 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26338 PyObject *resultobj;
26339 wxWindow *arg1 = (wxWindow *) 0 ;
26340 wxRect *arg2 = 0 ;
26341 int arg3 = (int) wxSIZE_AUTO ;
26342 wxRect temp2 ;
26343 PyObject * obj0 = 0 ;
26344 PyObject * obj1 = 0 ;
26345 PyObject * obj2 = 0 ;
26346 char *kwnames[] = {
26347 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26348 };
26349
26350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26352 if (SWIG_arg_fail(1)) SWIG_fail;
26353 {
26354 arg2 = &temp2;
26355 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26356 }
26357 if (obj2) {
26358 {
26359 arg3 = (int)(SWIG_As_int(obj2));
26360 if (SWIG_arg_fail(3)) SWIG_fail;
26361 }
26362 }
26363 {
26364 PyThreadState* __tstate = wxPyBeginAllowThreads();
26365 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26366
26367 wxPyEndAllowThreads(__tstate);
26368 if (PyErr_Occurred()) SWIG_fail;
26369 }
26370 Py_INCREF(Py_None); resultobj = Py_None;
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26378 PyObject *resultobj;
26379 wxWindow *arg1 = (wxWindow *) 0 ;
26380 int arg2 ;
26381 int arg3 ;
26382 PyObject * obj0 = 0 ;
26383 PyObject * obj1 = 0 ;
26384 PyObject * obj2 = 0 ;
26385 char *kwnames[] = {
26386 (char *) "self",(char *) "width",(char *) "height", NULL
26387 };
26388
26389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26391 if (SWIG_arg_fail(1)) SWIG_fail;
26392 {
26393 arg2 = (int)(SWIG_As_int(obj1));
26394 if (SWIG_arg_fail(2)) SWIG_fail;
26395 }
26396 {
26397 arg3 = (int)(SWIG_As_int(obj2));
26398 if (SWIG_arg_fail(3)) SWIG_fail;
26399 }
26400 {
26401 PyThreadState* __tstate = wxPyBeginAllowThreads();
26402 (arg1)->SetSize(arg2,arg3);
26403
26404 wxPyEndAllowThreads(__tstate);
26405 if (PyErr_Occurred()) SWIG_fail;
26406 }
26407 Py_INCREF(Py_None); resultobj = Py_None;
26408 return resultobj;
26409 fail:
26410 return NULL;
26411 }
26412
26413
26414 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26415 PyObject *resultobj;
26416 wxWindow *arg1 = (wxWindow *) 0 ;
26417 wxPoint *arg2 = 0 ;
26418 int arg3 = (int) wxSIZE_USE_EXISTING ;
26419 wxPoint temp2 ;
26420 PyObject * obj0 = 0 ;
26421 PyObject * obj1 = 0 ;
26422 PyObject * obj2 = 0 ;
26423 char *kwnames[] = {
26424 (char *) "self",(char *) "pt",(char *) "flags", NULL
26425 };
26426
26427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26429 if (SWIG_arg_fail(1)) SWIG_fail;
26430 {
26431 arg2 = &temp2;
26432 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26433 }
26434 if (obj2) {
26435 {
26436 arg3 = (int)(SWIG_As_int(obj2));
26437 if (SWIG_arg_fail(3)) SWIG_fail;
26438 }
26439 }
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 (arg1)->Move((wxPoint const &)*arg2,arg3);
26443
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 Py_INCREF(Py_None); resultobj = Py_None;
26448 return resultobj;
26449 fail:
26450 return NULL;
26451 }
26452
26453
26454 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26455 PyObject *resultobj;
26456 wxWindow *arg1 = (wxWindow *) 0 ;
26457 int arg2 ;
26458 int arg3 ;
26459 int arg4 = (int) wxSIZE_USE_EXISTING ;
26460 PyObject * obj0 = 0 ;
26461 PyObject * obj1 = 0 ;
26462 PyObject * obj2 = 0 ;
26463 PyObject * obj3 = 0 ;
26464 char *kwnames[] = {
26465 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26466 };
26467
26468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26470 if (SWIG_arg_fail(1)) SWIG_fail;
26471 {
26472 arg2 = (int)(SWIG_As_int(obj1));
26473 if (SWIG_arg_fail(2)) SWIG_fail;
26474 }
26475 {
26476 arg3 = (int)(SWIG_As_int(obj2));
26477 if (SWIG_arg_fail(3)) SWIG_fail;
26478 }
26479 if (obj3) {
26480 {
26481 arg4 = (int)(SWIG_As_int(obj3));
26482 if (SWIG_arg_fail(4)) SWIG_fail;
26483 }
26484 }
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 (arg1)->Move(arg2,arg3,arg4);
26488
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 Py_INCREF(Py_None); resultobj = Py_None;
26493 return resultobj;
26494 fail:
26495 return NULL;
26496 }
26497
26498
26499 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26500 PyObject *resultobj;
26501 wxWindow *arg1 = (wxWindow *) 0 ;
26502 wxSize const &arg2_defvalue = wxDefaultSize ;
26503 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26504 wxSize temp2 ;
26505 PyObject * obj0 = 0 ;
26506 PyObject * obj1 = 0 ;
26507 char *kwnames[] = {
26508 (char *) "self",(char *) "size", NULL
26509 };
26510
26511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26513 if (SWIG_arg_fail(1)) SWIG_fail;
26514 if (obj1) {
26515 {
26516 arg2 = &temp2;
26517 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26518 }
26519 }
26520 {
26521 PyThreadState* __tstate = wxPyBeginAllowThreads();
26522 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26523
26524 wxPyEndAllowThreads(__tstate);
26525 if (PyErr_Occurred()) SWIG_fail;
26526 }
26527 Py_INCREF(Py_None); resultobj = Py_None;
26528 return resultobj;
26529 fail:
26530 return NULL;
26531 }
26532
26533
26534 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26535 PyObject *resultobj;
26536 wxWindow *arg1 = (wxWindow *) 0 ;
26537 PyObject * obj0 = 0 ;
26538 char *kwnames[] = {
26539 (char *) "self", NULL
26540 };
26541
26542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26544 if (SWIG_arg_fail(1)) SWIG_fail;
26545 {
26546 PyThreadState* __tstate = wxPyBeginAllowThreads();
26547 (arg1)->Raise();
26548
26549 wxPyEndAllowThreads(__tstate);
26550 if (PyErr_Occurred()) SWIG_fail;
26551 }
26552 Py_INCREF(Py_None); resultobj = Py_None;
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj;
26561 wxWindow *arg1 = (wxWindow *) 0 ;
26562 PyObject * obj0 = 0 ;
26563 char *kwnames[] = {
26564 (char *) "self", NULL
26565 };
26566
26567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26569 if (SWIG_arg_fail(1)) SWIG_fail;
26570 {
26571 PyThreadState* __tstate = wxPyBeginAllowThreads();
26572 (arg1)->Lower();
26573
26574 wxPyEndAllowThreads(__tstate);
26575 if (PyErr_Occurred()) SWIG_fail;
26576 }
26577 Py_INCREF(Py_None); resultobj = Py_None;
26578 return resultobj;
26579 fail:
26580 return NULL;
26581 }
26582
26583
26584 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26585 PyObject *resultobj;
26586 wxWindow *arg1 = (wxWindow *) 0 ;
26587 wxSize *arg2 = 0 ;
26588 wxSize temp2 ;
26589 PyObject * obj0 = 0 ;
26590 PyObject * obj1 = 0 ;
26591 char *kwnames[] = {
26592 (char *) "self",(char *) "size", NULL
26593 };
26594
26595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26597 if (SWIG_arg_fail(1)) SWIG_fail;
26598 {
26599 arg2 = &temp2;
26600 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26601 }
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 (arg1)->SetClientSize((wxSize const &)*arg2);
26605
26606 wxPyEndAllowThreads(__tstate);
26607 if (PyErr_Occurred()) SWIG_fail;
26608 }
26609 Py_INCREF(Py_None); resultobj = Py_None;
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26617 PyObject *resultobj;
26618 wxWindow *arg1 = (wxWindow *) 0 ;
26619 int arg2 ;
26620 int arg3 ;
26621 PyObject * obj0 = 0 ;
26622 PyObject * obj1 = 0 ;
26623 PyObject * obj2 = 0 ;
26624 char *kwnames[] = {
26625 (char *) "self",(char *) "width",(char *) "height", NULL
26626 };
26627
26628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26630 if (SWIG_arg_fail(1)) SWIG_fail;
26631 {
26632 arg2 = (int)(SWIG_As_int(obj1));
26633 if (SWIG_arg_fail(2)) SWIG_fail;
26634 }
26635 {
26636 arg3 = (int)(SWIG_As_int(obj2));
26637 if (SWIG_arg_fail(3)) SWIG_fail;
26638 }
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 (arg1)->SetClientSize(arg2,arg3);
26642
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 Py_INCREF(Py_None); resultobj = Py_None;
26647 return resultobj;
26648 fail:
26649 return NULL;
26650 }
26651
26652
26653 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26654 PyObject *resultobj;
26655 wxWindow *arg1 = (wxWindow *) 0 ;
26656 wxRect *arg2 = 0 ;
26657 wxRect temp2 ;
26658 PyObject * obj0 = 0 ;
26659 PyObject * obj1 = 0 ;
26660 char *kwnames[] = {
26661 (char *) "self",(char *) "rect", NULL
26662 };
26663
26664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26666 if (SWIG_arg_fail(1)) SWIG_fail;
26667 {
26668 arg2 = &temp2;
26669 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26670 }
26671 {
26672 PyThreadState* __tstate = wxPyBeginAllowThreads();
26673 (arg1)->SetClientSize((wxRect const &)*arg2);
26674
26675 wxPyEndAllowThreads(__tstate);
26676 if (PyErr_Occurred()) SWIG_fail;
26677 }
26678 Py_INCREF(Py_None); resultobj = Py_None;
26679 return resultobj;
26680 fail:
26681 return NULL;
26682 }
26683
26684
26685 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26686 PyObject *resultobj;
26687 wxWindow *arg1 = (wxWindow *) 0 ;
26688 wxPoint result;
26689 PyObject * obj0 = 0 ;
26690 char *kwnames[] = {
26691 (char *) "self", NULL
26692 };
26693
26694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26696 if (SWIG_arg_fail(1)) SWIG_fail;
26697 {
26698 PyThreadState* __tstate = wxPyBeginAllowThreads();
26699 result = (arg1)->GetPosition();
26700
26701 wxPyEndAllowThreads(__tstate);
26702 if (PyErr_Occurred()) SWIG_fail;
26703 }
26704 {
26705 wxPoint * resultptr;
26706 resultptr = new wxPoint((wxPoint &)(result));
26707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26708 }
26709 return resultobj;
26710 fail:
26711 return NULL;
26712 }
26713
26714
26715 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26716 PyObject *resultobj;
26717 wxWindow *arg1 = (wxWindow *) 0 ;
26718 int *arg2 = (int *) 0 ;
26719 int *arg3 = (int *) 0 ;
26720 int temp2 ;
26721 int res2 = 0 ;
26722 int temp3 ;
26723 int res3 = 0 ;
26724 PyObject * obj0 = 0 ;
26725 char *kwnames[] = {
26726 (char *) "self", NULL
26727 };
26728
26729 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26730 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26733 if (SWIG_arg_fail(1)) SWIG_fail;
26734 {
26735 PyThreadState* __tstate = wxPyBeginAllowThreads();
26736 (arg1)->GetPosition(arg2,arg3);
26737
26738 wxPyEndAllowThreads(__tstate);
26739 if (PyErr_Occurred()) SWIG_fail;
26740 }
26741 Py_INCREF(Py_None); resultobj = Py_None;
26742 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26743 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26744 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26745 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26746 return resultobj;
26747 fail:
26748 return NULL;
26749 }
26750
26751
26752 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26753 PyObject *resultobj;
26754 wxWindow *arg1 = (wxWindow *) 0 ;
26755 wxSize result;
26756 PyObject * obj0 = 0 ;
26757 char *kwnames[] = {
26758 (char *) "self", NULL
26759 };
26760
26761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26763 if (SWIG_arg_fail(1)) SWIG_fail;
26764 {
26765 PyThreadState* __tstate = wxPyBeginAllowThreads();
26766 result = ((wxWindow const *)arg1)->GetSize();
26767
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 {
26772 wxSize * resultptr;
26773 resultptr = new wxSize((wxSize &)(result));
26774 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26775 }
26776 return resultobj;
26777 fail:
26778 return NULL;
26779 }
26780
26781
26782 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26783 PyObject *resultobj;
26784 wxWindow *arg1 = (wxWindow *) 0 ;
26785 int *arg2 = (int *) 0 ;
26786 int *arg3 = (int *) 0 ;
26787 int temp2 ;
26788 int res2 = 0 ;
26789 int temp3 ;
26790 int res3 = 0 ;
26791 PyObject * obj0 = 0 ;
26792 char *kwnames[] = {
26793 (char *) "self", NULL
26794 };
26795
26796 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26797 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26800 if (SWIG_arg_fail(1)) SWIG_fail;
26801 {
26802 PyThreadState* __tstate = wxPyBeginAllowThreads();
26803 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26804
26805 wxPyEndAllowThreads(__tstate);
26806 if (PyErr_Occurred()) SWIG_fail;
26807 }
26808 Py_INCREF(Py_None); resultobj = Py_None;
26809 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26810 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26811 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26812 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26813 return resultobj;
26814 fail:
26815 return NULL;
26816 }
26817
26818
26819 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26820 PyObject *resultobj;
26821 wxWindow *arg1 = (wxWindow *) 0 ;
26822 wxRect result;
26823 PyObject * obj0 = 0 ;
26824 char *kwnames[] = {
26825 (char *) "self", NULL
26826 };
26827
26828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26830 if (SWIG_arg_fail(1)) SWIG_fail;
26831 {
26832 PyThreadState* __tstate = wxPyBeginAllowThreads();
26833 result = ((wxWindow const *)arg1)->GetRect();
26834
26835 wxPyEndAllowThreads(__tstate);
26836 if (PyErr_Occurred()) SWIG_fail;
26837 }
26838 {
26839 wxRect * resultptr;
26840 resultptr = new wxRect((wxRect &)(result));
26841 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26842 }
26843 return resultobj;
26844 fail:
26845 return NULL;
26846 }
26847
26848
26849 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26850 PyObject *resultobj;
26851 wxWindow *arg1 = (wxWindow *) 0 ;
26852 wxSize result;
26853 PyObject * obj0 = 0 ;
26854 char *kwnames[] = {
26855 (char *) "self", NULL
26856 };
26857
26858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26860 if (SWIG_arg_fail(1)) SWIG_fail;
26861 {
26862 PyThreadState* __tstate = wxPyBeginAllowThreads();
26863 result = ((wxWindow const *)arg1)->GetClientSize();
26864
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 {
26869 wxSize * resultptr;
26870 resultptr = new wxSize((wxSize &)(result));
26871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26872 }
26873 return resultobj;
26874 fail:
26875 return NULL;
26876 }
26877
26878
26879 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26880 PyObject *resultobj;
26881 wxWindow *arg1 = (wxWindow *) 0 ;
26882 int *arg2 = (int *) 0 ;
26883 int *arg3 = (int *) 0 ;
26884 int temp2 ;
26885 int res2 = 0 ;
26886 int temp3 ;
26887 int res3 = 0 ;
26888 PyObject * obj0 = 0 ;
26889 char *kwnames[] = {
26890 (char *) "self", NULL
26891 };
26892
26893 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26894 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26897 if (SWIG_arg_fail(1)) SWIG_fail;
26898 {
26899 PyThreadState* __tstate = wxPyBeginAllowThreads();
26900 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26901
26902 wxPyEndAllowThreads(__tstate);
26903 if (PyErr_Occurred()) SWIG_fail;
26904 }
26905 Py_INCREF(Py_None); resultobj = Py_None;
26906 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26907 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26908 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26909 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26910 return resultobj;
26911 fail:
26912 return NULL;
26913 }
26914
26915
26916 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26917 PyObject *resultobj;
26918 wxWindow *arg1 = (wxWindow *) 0 ;
26919 wxPoint result;
26920 PyObject * obj0 = 0 ;
26921 char *kwnames[] = {
26922 (char *) "self", NULL
26923 };
26924
26925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26930 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26931
26932 wxPyEndAllowThreads(__tstate);
26933 if (PyErr_Occurred()) SWIG_fail;
26934 }
26935 {
26936 wxPoint * resultptr;
26937 resultptr = new wxPoint((wxPoint &)(result));
26938 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26939 }
26940 return resultobj;
26941 fail:
26942 return NULL;
26943 }
26944
26945
26946 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26947 PyObject *resultobj;
26948 wxWindow *arg1 = (wxWindow *) 0 ;
26949 wxRect result;
26950 PyObject * obj0 = 0 ;
26951 char *kwnames[] = {
26952 (char *) "self", NULL
26953 };
26954
26955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26957 if (SWIG_arg_fail(1)) SWIG_fail;
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 result = ((wxWindow const *)arg1)->GetClientRect();
26961
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 {
26966 wxRect * resultptr;
26967 resultptr = new wxRect((wxRect &)(result));
26968 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26969 }
26970 return resultobj;
26971 fail:
26972 return NULL;
26973 }
26974
26975
26976 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj;
26978 wxWindow *arg1 = (wxWindow *) 0 ;
26979 wxSize result;
26980 PyObject * obj0 = 0 ;
26981 char *kwnames[] = {
26982 (char *) "self", NULL
26983 };
26984
26985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26987 if (SWIG_arg_fail(1)) SWIG_fail;
26988 {
26989 PyThreadState* __tstate = wxPyBeginAllowThreads();
26990 result = ((wxWindow const *)arg1)->GetBestSize();
26991
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 {
26996 wxSize * resultptr;
26997 resultptr = new wxSize((wxSize &)(result));
26998 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26999 }
27000 return resultobj;
27001 fail:
27002 return NULL;
27003 }
27004
27005
27006 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27007 PyObject *resultobj;
27008 wxWindow *arg1 = (wxWindow *) 0 ;
27009 int *arg2 = (int *) 0 ;
27010 int *arg3 = (int *) 0 ;
27011 int temp2 ;
27012 int res2 = 0 ;
27013 int temp3 ;
27014 int res3 = 0 ;
27015 PyObject * obj0 = 0 ;
27016 char *kwnames[] = {
27017 (char *) "self", NULL
27018 };
27019
27020 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27021 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27024 if (SWIG_arg_fail(1)) SWIG_fail;
27025 {
27026 PyThreadState* __tstate = wxPyBeginAllowThreads();
27027 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27028
27029 wxPyEndAllowThreads(__tstate);
27030 if (PyErr_Occurred()) SWIG_fail;
27031 }
27032 Py_INCREF(Py_None); resultobj = Py_None;
27033 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27034 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27035 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27036 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27037 return resultobj;
27038 fail:
27039 return NULL;
27040 }
27041
27042
27043 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27044 PyObject *resultobj;
27045 wxWindow *arg1 = (wxWindow *) 0 ;
27046 PyObject * obj0 = 0 ;
27047 char *kwnames[] = {
27048 (char *) "self", NULL
27049 };
27050
27051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27053 if (SWIG_arg_fail(1)) SWIG_fail;
27054 {
27055 PyThreadState* __tstate = wxPyBeginAllowThreads();
27056 (arg1)->InvalidateBestSize();
27057
27058 wxPyEndAllowThreads(__tstate);
27059 if (PyErr_Occurred()) SWIG_fail;
27060 }
27061 Py_INCREF(Py_None); resultobj = Py_None;
27062 return resultobj;
27063 fail:
27064 return NULL;
27065 }
27066
27067
27068 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27069 PyObject *resultobj;
27070 wxWindow *arg1 = (wxWindow *) 0 ;
27071 wxSize *arg2 = 0 ;
27072 wxSize temp2 ;
27073 PyObject * obj0 = 0 ;
27074 PyObject * obj1 = 0 ;
27075 char *kwnames[] = {
27076 (char *) "self",(char *) "size", NULL
27077 };
27078
27079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27081 if (SWIG_arg_fail(1)) SWIG_fail;
27082 {
27083 arg2 = &temp2;
27084 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27085 }
27086 {
27087 PyThreadState* __tstate = wxPyBeginAllowThreads();
27088 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27089
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 Py_INCREF(Py_None); resultobj = Py_None;
27094 return resultobj;
27095 fail:
27096 return NULL;
27097 }
27098
27099
27100 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27101 PyObject *resultobj;
27102 wxWindow *arg1 = (wxWindow *) 0 ;
27103 wxSize result;
27104 PyObject * obj0 = 0 ;
27105 char *kwnames[] = {
27106 (char *) "self", NULL
27107 };
27108
27109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27111 if (SWIG_arg_fail(1)) SWIG_fail;
27112 {
27113 PyThreadState* __tstate = wxPyBeginAllowThreads();
27114 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27115
27116 wxPyEndAllowThreads(__tstate);
27117 if (PyErr_Occurred()) SWIG_fail;
27118 }
27119 {
27120 wxSize * resultptr;
27121 resultptr = new wxSize((wxSize &)(result));
27122 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27123 }
27124 return resultobj;
27125 fail:
27126 return NULL;
27127 }
27128
27129
27130 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27131 PyObject *resultobj;
27132 wxWindow *arg1 = (wxWindow *) 0 ;
27133 wxSize result;
27134 PyObject * obj0 = 0 ;
27135 char *kwnames[] = {
27136 (char *) "self", NULL
27137 };
27138
27139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27141 if (SWIG_arg_fail(1)) SWIG_fail;
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27145
27146 wxPyEndAllowThreads(__tstate);
27147 if (PyErr_Occurred()) SWIG_fail;
27148 }
27149 {
27150 wxSize * resultptr;
27151 resultptr = new wxSize((wxSize &)(result));
27152 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27153 }
27154 return resultobj;
27155 fail:
27156 return NULL;
27157 }
27158
27159
27160 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27161 PyObject *resultobj;
27162 wxWindow *arg1 = (wxWindow *) 0 ;
27163 int arg2 = (int) wxBOTH ;
27164 PyObject * obj0 = 0 ;
27165 PyObject * obj1 = 0 ;
27166 char *kwnames[] = {
27167 (char *) "self",(char *) "direction", NULL
27168 };
27169
27170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27172 if (SWIG_arg_fail(1)) SWIG_fail;
27173 if (obj1) {
27174 {
27175 arg2 = (int)(SWIG_As_int(obj1));
27176 if (SWIG_arg_fail(2)) SWIG_fail;
27177 }
27178 }
27179 {
27180 PyThreadState* __tstate = wxPyBeginAllowThreads();
27181 (arg1)->Center(arg2);
27182
27183 wxPyEndAllowThreads(__tstate);
27184 if (PyErr_Occurred()) SWIG_fail;
27185 }
27186 Py_INCREF(Py_None); resultobj = Py_None;
27187 return resultobj;
27188 fail:
27189 return NULL;
27190 }
27191
27192
27193 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27194 PyObject *resultobj;
27195 wxWindow *arg1 = (wxWindow *) 0 ;
27196 int arg2 = (int) wxBOTH ;
27197 PyObject * obj0 = 0 ;
27198 PyObject * obj1 = 0 ;
27199 char *kwnames[] = {
27200 (char *) "self",(char *) "dir", NULL
27201 };
27202
27203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27205 if (SWIG_arg_fail(1)) SWIG_fail;
27206 if (obj1) {
27207 {
27208 arg2 = (int)(SWIG_As_int(obj1));
27209 if (SWIG_arg_fail(2)) SWIG_fail;
27210 }
27211 }
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 (arg1)->CenterOnScreen(arg2);
27215
27216 wxPyEndAllowThreads(__tstate);
27217 if (PyErr_Occurred()) SWIG_fail;
27218 }
27219 Py_INCREF(Py_None); resultobj = Py_None;
27220 return resultobj;
27221 fail:
27222 return NULL;
27223 }
27224
27225
27226 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27227 PyObject *resultobj;
27228 wxWindow *arg1 = (wxWindow *) 0 ;
27229 int arg2 = (int) wxBOTH ;
27230 PyObject * obj0 = 0 ;
27231 PyObject * obj1 = 0 ;
27232 char *kwnames[] = {
27233 (char *) "self",(char *) "dir", NULL
27234 };
27235
27236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27238 if (SWIG_arg_fail(1)) SWIG_fail;
27239 if (obj1) {
27240 {
27241 arg2 = (int)(SWIG_As_int(obj1));
27242 if (SWIG_arg_fail(2)) SWIG_fail;
27243 }
27244 }
27245 {
27246 PyThreadState* __tstate = wxPyBeginAllowThreads();
27247 (arg1)->CenterOnParent(arg2);
27248
27249 wxPyEndAllowThreads(__tstate);
27250 if (PyErr_Occurred()) SWIG_fail;
27251 }
27252 Py_INCREF(Py_None); resultobj = Py_None;
27253 return resultobj;
27254 fail:
27255 return NULL;
27256 }
27257
27258
27259 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27260 PyObject *resultobj;
27261 wxWindow *arg1 = (wxWindow *) 0 ;
27262 PyObject * obj0 = 0 ;
27263 char *kwnames[] = {
27264 (char *) "self", NULL
27265 };
27266
27267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27269 if (SWIG_arg_fail(1)) SWIG_fail;
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 (arg1)->Fit();
27273
27274 wxPyEndAllowThreads(__tstate);
27275 if (PyErr_Occurred()) SWIG_fail;
27276 }
27277 Py_INCREF(Py_None); resultobj = Py_None;
27278 return resultobj;
27279 fail:
27280 return NULL;
27281 }
27282
27283
27284 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27285 PyObject *resultobj;
27286 wxWindow *arg1 = (wxWindow *) 0 ;
27287 PyObject * obj0 = 0 ;
27288 char *kwnames[] = {
27289 (char *) "self", NULL
27290 };
27291
27292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27294 if (SWIG_arg_fail(1)) SWIG_fail;
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 (arg1)->FitInside();
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_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27310 PyObject *resultobj;
27311 wxWindow *arg1 = (wxWindow *) 0 ;
27312 int arg2 ;
27313 int arg3 ;
27314 int arg4 = (int) -1 ;
27315 int arg5 = (int) -1 ;
27316 int arg6 = (int) -1 ;
27317 int arg7 = (int) -1 ;
27318 PyObject * obj0 = 0 ;
27319 PyObject * obj1 = 0 ;
27320 PyObject * obj2 = 0 ;
27321 PyObject * obj3 = 0 ;
27322 PyObject * obj4 = 0 ;
27323 PyObject * obj5 = 0 ;
27324 PyObject * obj6 = 0 ;
27325 char *kwnames[] = {
27326 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27327 };
27328
27329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27331 if (SWIG_arg_fail(1)) SWIG_fail;
27332 {
27333 arg2 = (int)(SWIG_As_int(obj1));
27334 if (SWIG_arg_fail(2)) SWIG_fail;
27335 }
27336 {
27337 arg3 = (int)(SWIG_As_int(obj2));
27338 if (SWIG_arg_fail(3)) SWIG_fail;
27339 }
27340 if (obj3) {
27341 {
27342 arg4 = (int)(SWIG_As_int(obj3));
27343 if (SWIG_arg_fail(4)) SWIG_fail;
27344 }
27345 }
27346 if (obj4) {
27347 {
27348 arg5 = (int)(SWIG_As_int(obj4));
27349 if (SWIG_arg_fail(5)) SWIG_fail;
27350 }
27351 }
27352 if (obj5) {
27353 {
27354 arg6 = (int)(SWIG_As_int(obj5));
27355 if (SWIG_arg_fail(6)) SWIG_fail;
27356 }
27357 }
27358 if (obj6) {
27359 {
27360 arg7 = (int)(SWIG_As_int(obj6));
27361 if (SWIG_arg_fail(7)) SWIG_fail;
27362 }
27363 }
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27367
27368 wxPyEndAllowThreads(__tstate);
27369 if (PyErr_Occurred()) SWIG_fail;
27370 }
27371 Py_INCREF(Py_None); resultobj = Py_None;
27372 return resultobj;
27373 fail:
27374 return NULL;
27375 }
27376
27377
27378 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27379 PyObject *resultobj;
27380 wxWindow *arg1 = (wxWindow *) 0 ;
27381 wxSize *arg2 = 0 ;
27382 wxSize const &arg3_defvalue = wxDefaultSize ;
27383 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27384 wxSize const &arg4_defvalue = wxDefaultSize ;
27385 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27386 wxSize temp2 ;
27387 wxSize temp3 ;
27388 wxSize temp4 ;
27389 PyObject * obj0 = 0 ;
27390 PyObject * obj1 = 0 ;
27391 PyObject * obj2 = 0 ;
27392 PyObject * obj3 = 0 ;
27393 char *kwnames[] = {
27394 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27395 };
27396
27397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27399 if (SWIG_arg_fail(1)) SWIG_fail;
27400 {
27401 arg2 = &temp2;
27402 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27403 }
27404 if (obj2) {
27405 {
27406 arg3 = &temp3;
27407 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27408 }
27409 }
27410 if (obj3) {
27411 {
27412 arg4 = &temp4;
27413 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27414 }
27415 }
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27419
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 Py_INCREF(Py_None); resultobj = Py_None;
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj;
27432 wxWindow *arg1 = (wxWindow *) 0 ;
27433 int arg2 ;
27434 int arg3 ;
27435 int arg4 = (int) -1 ;
27436 int arg5 = (int) -1 ;
27437 PyObject * obj0 = 0 ;
27438 PyObject * obj1 = 0 ;
27439 PyObject * obj2 = 0 ;
27440 PyObject * obj3 = 0 ;
27441 PyObject * obj4 = 0 ;
27442 char *kwnames[] = {
27443 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27444 };
27445
27446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27448 if (SWIG_arg_fail(1)) SWIG_fail;
27449 {
27450 arg2 = (int)(SWIG_As_int(obj1));
27451 if (SWIG_arg_fail(2)) SWIG_fail;
27452 }
27453 {
27454 arg3 = (int)(SWIG_As_int(obj2));
27455 if (SWIG_arg_fail(3)) SWIG_fail;
27456 }
27457 if (obj3) {
27458 {
27459 arg4 = (int)(SWIG_As_int(obj3));
27460 if (SWIG_arg_fail(4)) SWIG_fail;
27461 }
27462 }
27463 if (obj4) {
27464 {
27465 arg5 = (int)(SWIG_As_int(obj4));
27466 if (SWIG_arg_fail(5)) SWIG_fail;
27467 }
27468 }
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27472
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 Py_INCREF(Py_None); resultobj = Py_None;
27477 return resultobj;
27478 fail:
27479 return NULL;
27480 }
27481
27482
27483 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27484 PyObject *resultobj;
27485 wxWindow *arg1 = (wxWindow *) 0 ;
27486 wxSize *arg2 = 0 ;
27487 wxSize const &arg3_defvalue = wxDefaultSize ;
27488 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27489 wxSize temp2 ;
27490 wxSize temp3 ;
27491 PyObject * obj0 = 0 ;
27492 PyObject * obj1 = 0 ;
27493 PyObject * obj2 = 0 ;
27494 char *kwnames[] = {
27495 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27496 };
27497
27498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27500 if (SWIG_arg_fail(1)) SWIG_fail;
27501 {
27502 arg2 = &temp2;
27503 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27504 }
27505 if (obj2) {
27506 {
27507 arg3 = &temp3;
27508 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27509 }
27510 }
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27514
27515 wxPyEndAllowThreads(__tstate);
27516 if (PyErr_Occurred()) SWIG_fail;
27517 }
27518 Py_INCREF(Py_None); resultobj = Py_None;
27519 return resultobj;
27520 fail:
27521 return NULL;
27522 }
27523
27524
27525 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27526 PyObject *resultobj;
27527 wxWindow *arg1 = (wxWindow *) 0 ;
27528 wxSize result;
27529 PyObject * obj0 = 0 ;
27530 char *kwnames[] = {
27531 (char *) "self", NULL
27532 };
27533
27534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27536 if (SWIG_arg_fail(1)) SWIG_fail;
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 result = ((wxWindow const *)arg1)->GetMaxSize();
27540
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 {
27545 wxSize * resultptr;
27546 resultptr = new wxSize((wxSize &)(result));
27547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27548 }
27549 return resultobj;
27550 fail:
27551 return NULL;
27552 }
27553
27554
27555 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27556 PyObject *resultobj;
27557 wxWindow *arg1 = (wxWindow *) 0 ;
27558 wxSize result;
27559 PyObject * obj0 = 0 ;
27560 char *kwnames[] = {
27561 (char *) "self", NULL
27562 };
27563
27564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27566 if (SWIG_arg_fail(1)) SWIG_fail;
27567 {
27568 PyThreadState* __tstate = wxPyBeginAllowThreads();
27569 result = ((wxWindow const *)arg1)->GetMinSize();
27570
27571 wxPyEndAllowThreads(__tstate);
27572 if (PyErr_Occurred()) SWIG_fail;
27573 }
27574 {
27575 wxSize * resultptr;
27576 resultptr = new wxSize((wxSize &)(result));
27577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27578 }
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27586 PyObject *resultobj;
27587 wxWindow *arg1 = (wxWindow *) 0 ;
27588 wxSize *arg2 = 0 ;
27589 wxSize temp2 ;
27590 PyObject * obj0 = 0 ;
27591 PyObject * obj1 = 0 ;
27592 char *kwnames[] = {
27593 (char *) "self",(char *) "minSize", NULL
27594 };
27595
27596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27598 if (SWIG_arg_fail(1)) SWIG_fail;
27599 {
27600 arg2 = &temp2;
27601 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27602 }
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 (arg1)->SetMinSize((wxSize const &)*arg2);
27606
27607 wxPyEndAllowThreads(__tstate);
27608 if (PyErr_Occurred()) SWIG_fail;
27609 }
27610 Py_INCREF(Py_None); resultobj = Py_None;
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27618 PyObject *resultobj;
27619 wxWindow *arg1 = (wxWindow *) 0 ;
27620 wxSize *arg2 = 0 ;
27621 wxSize temp2 ;
27622 PyObject * obj0 = 0 ;
27623 PyObject * obj1 = 0 ;
27624 char *kwnames[] = {
27625 (char *) "self",(char *) "maxSize", NULL
27626 };
27627
27628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27630 if (SWIG_arg_fail(1)) SWIG_fail;
27631 {
27632 arg2 = &temp2;
27633 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27634 }
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 (arg1)->SetMaxSize((wxSize const &)*arg2);
27638
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 Py_INCREF(Py_None); resultobj = Py_None;
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27650 PyObject *resultobj;
27651 wxWindow *arg1 = (wxWindow *) 0 ;
27652 int result;
27653 PyObject * obj0 = 0 ;
27654 char *kwnames[] = {
27655 (char *) "self", NULL
27656 };
27657
27658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27660 if (SWIG_arg_fail(1)) SWIG_fail;
27661 {
27662 PyThreadState* __tstate = wxPyBeginAllowThreads();
27663 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27664
27665 wxPyEndAllowThreads(__tstate);
27666 if (PyErr_Occurred()) SWIG_fail;
27667 }
27668 {
27669 resultobj = SWIG_From_int((int)(result));
27670 }
27671 return resultobj;
27672 fail:
27673 return NULL;
27674 }
27675
27676
27677 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27678 PyObject *resultobj;
27679 wxWindow *arg1 = (wxWindow *) 0 ;
27680 int result;
27681 PyObject * obj0 = 0 ;
27682 char *kwnames[] = {
27683 (char *) "self", NULL
27684 };
27685
27686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27688 if (SWIG_arg_fail(1)) SWIG_fail;
27689 {
27690 PyThreadState* __tstate = wxPyBeginAllowThreads();
27691 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27692
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 {
27697 resultobj = SWIG_From_int((int)(result));
27698 }
27699 return resultobj;
27700 fail:
27701 return NULL;
27702 }
27703
27704
27705 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27706 PyObject *resultobj;
27707 wxWindow *arg1 = (wxWindow *) 0 ;
27708 int result;
27709 PyObject * obj0 = 0 ;
27710 char *kwnames[] = {
27711 (char *) "self", NULL
27712 };
27713
27714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27716 if (SWIG_arg_fail(1)) SWIG_fail;
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27720
27721 wxPyEndAllowThreads(__tstate);
27722 if (PyErr_Occurred()) SWIG_fail;
27723 }
27724 {
27725 resultobj = SWIG_From_int((int)(result));
27726 }
27727 return resultobj;
27728 fail:
27729 return NULL;
27730 }
27731
27732
27733 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27734 PyObject *resultobj;
27735 wxWindow *arg1 = (wxWindow *) 0 ;
27736 int result;
27737 PyObject * obj0 = 0 ;
27738 char *kwnames[] = {
27739 (char *) "self", NULL
27740 };
27741
27742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27744 if (SWIG_arg_fail(1)) SWIG_fail;
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27748
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 {
27753 resultobj = SWIG_From_int((int)(result));
27754 }
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27762 PyObject *resultobj;
27763 wxWindow *arg1 = (wxWindow *) 0 ;
27764 wxSize *arg2 = 0 ;
27765 wxSize temp2 ;
27766 PyObject * obj0 = 0 ;
27767 PyObject * obj1 = 0 ;
27768 char *kwnames[] = {
27769 (char *) "self",(char *) "size", NULL
27770 };
27771
27772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27774 if (SWIG_arg_fail(1)) SWIG_fail;
27775 {
27776 arg2 = &temp2;
27777 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27778 }
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27782
27783 wxPyEndAllowThreads(__tstate);
27784 if (PyErr_Occurred()) SWIG_fail;
27785 }
27786 Py_INCREF(Py_None); resultobj = Py_None;
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj;
27795 wxWindow *arg1 = (wxWindow *) 0 ;
27796 int arg2 ;
27797 int arg3 ;
27798 PyObject * obj0 = 0 ;
27799 PyObject * obj1 = 0 ;
27800 PyObject * obj2 = 0 ;
27801 char *kwnames[] = {
27802 (char *) "self",(char *) "w",(char *) "h", NULL
27803 };
27804
27805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27807 if (SWIG_arg_fail(1)) SWIG_fail;
27808 {
27809 arg2 = (int)(SWIG_As_int(obj1));
27810 if (SWIG_arg_fail(2)) SWIG_fail;
27811 }
27812 {
27813 arg3 = (int)(SWIG_As_int(obj2));
27814 if (SWIG_arg_fail(3)) SWIG_fail;
27815 }
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 (arg1)->SetVirtualSize(arg2,arg3);
27819
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 Py_INCREF(Py_None); resultobj = Py_None;
27824 return resultobj;
27825 fail:
27826 return NULL;
27827 }
27828
27829
27830 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27831 PyObject *resultobj;
27832 wxWindow *arg1 = (wxWindow *) 0 ;
27833 wxSize result;
27834 PyObject * obj0 = 0 ;
27835 char *kwnames[] = {
27836 (char *) "self", NULL
27837 };
27838
27839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27841 if (SWIG_arg_fail(1)) SWIG_fail;
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = ((wxWindow const *)arg1)->GetVirtualSize();
27845
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 {
27850 wxSize * resultptr;
27851 resultptr = new wxSize((wxSize &)(result));
27852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27853 }
27854 return resultobj;
27855 fail:
27856 return NULL;
27857 }
27858
27859
27860 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27861 PyObject *resultobj;
27862 wxWindow *arg1 = (wxWindow *) 0 ;
27863 int *arg2 = (int *) 0 ;
27864 int *arg3 = (int *) 0 ;
27865 int temp2 ;
27866 int res2 = 0 ;
27867 int temp3 ;
27868 int res3 = 0 ;
27869 PyObject * obj0 = 0 ;
27870 char *kwnames[] = {
27871 (char *) "self", NULL
27872 };
27873
27874 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27875 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27878 if (SWIG_arg_fail(1)) SWIG_fail;
27879 {
27880 PyThreadState* __tstate = wxPyBeginAllowThreads();
27881 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27882
27883 wxPyEndAllowThreads(__tstate);
27884 if (PyErr_Occurred()) SWIG_fail;
27885 }
27886 Py_INCREF(Py_None); resultobj = Py_None;
27887 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27888 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27889 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27890 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27891 return resultobj;
27892 fail:
27893 return NULL;
27894 }
27895
27896
27897 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27898 PyObject *resultobj;
27899 wxWindow *arg1 = (wxWindow *) 0 ;
27900 wxSize result;
27901 PyObject * obj0 = 0 ;
27902 char *kwnames[] = {
27903 (char *) "self", NULL
27904 };
27905
27906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27908 if (SWIG_arg_fail(1)) SWIG_fail;
27909 {
27910 PyThreadState* __tstate = wxPyBeginAllowThreads();
27911 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27912
27913 wxPyEndAllowThreads(__tstate);
27914 if (PyErr_Occurred()) SWIG_fail;
27915 }
27916 {
27917 wxSize * resultptr;
27918 resultptr = new wxSize((wxSize &)(result));
27919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27920 }
27921 return resultobj;
27922 fail:
27923 return NULL;
27924 }
27925
27926
27927 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27928 PyObject *resultobj;
27929 wxWindow *arg1 = (wxWindow *) 0 ;
27930 bool arg2 = (bool) true ;
27931 bool result;
27932 PyObject * obj0 = 0 ;
27933 PyObject * obj1 = 0 ;
27934 char *kwnames[] = {
27935 (char *) "self",(char *) "show", NULL
27936 };
27937
27938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27940 if (SWIG_arg_fail(1)) SWIG_fail;
27941 if (obj1) {
27942 {
27943 arg2 = (bool)(SWIG_As_bool(obj1));
27944 if (SWIG_arg_fail(2)) SWIG_fail;
27945 }
27946 }
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 result = (bool)(arg1)->Show(arg2);
27950
27951 wxPyEndAllowThreads(__tstate);
27952 if (PyErr_Occurred()) SWIG_fail;
27953 }
27954 {
27955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27956 }
27957 return resultobj;
27958 fail:
27959 return NULL;
27960 }
27961
27962
27963 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27964 PyObject *resultobj;
27965 wxWindow *arg1 = (wxWindow *) 0 ;
27966 bool result;
27967 PyObject * obj0 = 0 ;
27968 char *kwnames[] = {
27969 (char *) "self", NULL
27970 };
27971
27972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27974 if (SWIG_arg_fail(1)) SWIG_fail;
27975 {
27976 PyThreadState* __tstate = wxPyBeginAllowThreads();
27977 result = (bool)(arg1)->Hide();
27978
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 {
27983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27984 }
27985 return resultobj;
27986 fail:
27987 return NULL;
27988 }
27989
27990
27991 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27992 PyObject *resultobj;
27993 wxWindow *arg1 = (wxWindow *) 0 ;
27994 bool arg2 = (bool) true ;
27995 bool result;
27996 PyObject * obj0 = 0 ;
27997 PyObject * obj1 = 0 ;
27998 char *kwnames[] = {
27999 (char *) "self",(char *) "enable", NULL
28000 };
28001
28002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) 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 if (obj1) {
28006 {
28007 arg2 = (bool)(SWIG_As_bool(obj1));
28008 if (SWIG_arg_fail(2)) SWIG_fail;
28009 }
28010 }
28011 {
28012 PyThreadState* __tstate = wxPyBeginAllowThreads();
28013 result = (bool)(arg1)->Enable(arg2);
28014
28015 wxPyEndAllowThreads(__tstate);
28016 if (PyErr_Occurred()) SWIG_fail;
28017 }
28018 {
28019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28020 }
28021 return resultobj;
28022 fail:
28023 return NULL;
28024 }
28025
28026
28027 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28028 PyObject *resultobj;
28029 wxWindow *arg1 = (wxWindow *) 0 ;
28030 bool result;
28031 PyObject * obj0 = 0 ;
28032 char *kwnames[] = {
28033 (char *) "self", NULL
28034 };
28035
28036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28038 if (SWIG_arg_fail(1)) SWIG_fail;
28039 {
28040 PyThreadState* __tstate = wxPyBeginAllowThreads();
28041 result = (bool)(arg1)->Disable();
28042
28043 wxPyEndAllowThreads(__tstate);
28044 if (PyErr_Occurred()) SWIG_fail;
28045 }
28046 {
28047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28048 }
28049 return resultobj;
28050 fail:
28051 return NULL;
28052 }
28053
28054
28055 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28056 PyObject *resultobj;
28057 wxWindow *arg1 = (wxWindow *) 0 ;
28058 bool result;
28059 PyObject * obj0 = 0 ;
28060 char *kwnames[] = {
28061 (char *) "self", NULL
28062 };
28063
28064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28066 if (SWIG_arg_fail(1)) SWIG_fail;
28067 {
28068 PyThreadState* __tstate = wxPyBeginAllowThreads();
28069 result = (bool)((wxWindow const *)arg1)->IsShown();
28070
28071 wxPyEndAllowThreads(__tstate);
28072 if (PyErr_Occurred()) SWIG_fail;
28073 }
28074 {
28075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28076 }
28077 return resultobj;
28078 fail:
28079 return NULL;
28080 }
28081
28082
28083 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28084 PyObject *resultobj;
28085 wxWindow *arg1 = (wxWindow *) 0 ;
28086 bool result;
28087 PyObject * obj0 = 0 ;
28088 char *kwnames[] = {
28089 (char *) "self", NULL
28090 };
28091
28092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28094 if (SWIG_arg_fail(1)) SWIG_fail;
28095 {
28096 PyThreadState* __tstate = wxPyBeginAllowThreads();
28097 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28098
28099 wxPyEndAllowThreads(__tstate);
28100 if (PyErr_Occurred()) SWIG_fail;
28101 }
28102 {
28103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28104 }
28105 return resultobj;
28106 fail:
28107 return NULL;
28108 }
28109
28110
28111 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28112 PyObject *resultobj;
28113 wxWindow *arg1 = (wxWindow *) 0 ;
28114 long arg2 ;
28115 PyObject * obj0 = 0 ;
28116 PyObject * obj1 = 0 ;
28117 char *kwnames[] = {
28118 (char *) "self",(char *) "style", NULL
28119 };
28120
28121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28123 if (SWIG_arg_fail(1)) SWIG_fail;
28124 {
28125 arg2 = (long)(SWIG_As_long(obj1));
28126 if (SWIG_arg_fail(2)) SWIG_fail;
28127 }
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 (arg1)->SetWindowStyleFlag(arg2);
28131
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 Py_INCREF(Py_None); resultobj = Py_None;
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28143 PyObject *resultobj;
28144 wxWindow *arg1 = (wxWindow *) 0 ;
28145 long result;
28146 PyObject * obj0 = 0 ;
28147 char *kwnames[] = {
28148 (char *) "self", NULL
28149 };
28150
28151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28153 if (SWIG_arg_fail(1)) SWIG_fail;
28154 {
28155 PyThreadState* __tstate = wxPyBeginAllowThreads();
28156 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28157
28158 wxPyEndAllowThreads(__tstate);
28159 if (PyErr_Occurred()) SWIG_fail;
28160 }
28161 {
28162 resultobj = SWIG_From_long((long)(result));
28163 }
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28171 PyObject *resultobj;
28172 wxWindow *arg1 = (wxWindow *) 0 ;
28173 int arg2 ;
28174 bool result;
28175 PyObject * obj0 = 0 ;
28176 PyObject * obj1 = 0 ;
28177 char *kwnames[] = {
28178 (char *) "self",(char *) "flag", NULL
28179 };
28180
28181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28183 if (SWIG_arg_fail(1)) SWIG_fail;
28184 {
28185 arg2 = (int)(SWIG_As_int(obj1));
28186 if (SWIG_arg_fail(2)) SWIG_fail;
28187 }
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28191
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 {
28196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28197 }
28198 return resultobj;
28199 fail:
28200 return NULL;
28201 }
28202
28203
28204 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28205 PyObject *resultobj;
28206 wxWindow *arg1 = (wxWindow *) 0 ;
28207 bool result;
28208 PyObject * obj0 = 0 ;
28209 char *kwnames[] = {
28210 (char *) "self", NULL
28211 };
28212
28213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28215 if (SWIG_arg_fail(1)) SWIG_fail;
28216 {
28217 PyThreadState* __tstate = wxPyBeginAllowThreads();
28218 result = (bool)((wxWindow const *)arg1)->IsRetained();
28219
28220 wxPyEndAllowThreads(__tstate);
28221 if (PyErr_Occurred()) SWIG_fail;
28222 }
28223 {
28224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28225 }
28226 return resultobj;
28227 fail:
28228 return NULL;
28229 }
28230
28231
28232 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28233 PyObject *resultobj;
28234 wxWindow *arg1 = (wxWindow *) 0 ;
28235 long arg2 ;
28236 PyObject * obj0 = 0 ;
28237 PyObject * obj1 = 0 ;
28238 char *kwnames[] = {
28239 (char *) "self",(char *) "exStyle", NULL
28240 };
28241
28242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28244 if (SWIG_arg_fail(1)) SWIG_fail;
28245 {
28246 arg2 = (long)(SWIG_As_long(obj1));
28247 if (SWIG_arg_fail(2)) SWIG_fail;
28248 }
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 (arg1)->SetExtraStyle(arg2);
28252
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 Py_INCREF(Py_None); resultobj = Py_None;
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28264 PyObject *resultobj;
28265 wxWindow *arg1 = (wxWindow *) 0 ;
28266 long result;
28267 PyObject * obj0 = 0 ;
28268 char *kwnames[] = {
28269 (char *) "self", NULL
28270 };
28271
28272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28274 if (SWIG_arg_fail(1)) SWIG_fail;
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28278
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 {
28283 resultobj = SWIG_From_long((long)(result));
28284 }
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28292 PyObject *resultobj;
28293 wxWindow *arg1 = (wxWindow *) 0 ;
28294 bool arg2 = (bool) true ;
28295 PyObject * obj0 = 0 ;
28296 PyObject * obj1 = 0 ;
28297 char *kwnames[] = {
28298 (char *) "self",(char *) "modal", NULL
28299 };
28300
28301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28303 if (SWIG_arg_fail(1)) SWIG_fail;
28304 if (obj1) {
28305 {
28306 arg2 = (bool)(SWIG_As_bool(obj1));
28307 if (SWIG_arg_fail(2)) SWIG_fail;
28308 }
28309 }
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 (arg1)->MakeModal(arg2);
28313
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 Py_INCREF(Py_None); resultobj = Py_None;
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28325 PyObject *resultobj;
28326 wxWindow *arg1 = (wxWindow *) 0 ;
28327 bool arg2 ;
28328 PyObject * obj0 = 0 ;
28329 PyObject * obj1 = 0 ;
28330 char *kwnames[] = {
28331 (char *) "self",(char *) "enableTheme", NULL
28332 };
28333
28334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28336 if (SWIG_arg_fail(1)) SWIG_fail;
28337 {
28338 arg2 = (bool)(SWIG_As_bool(obj1));
28339 if (SWIG_arg_fail(2)) SWIG_fail;
28340 }
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 (arg1)->SetThemeEnabled(arg2);
28344
28345 wxPyEndAllowThreads(__tstate);
28346 if (PyErr_Occurred()) SWIG_fail;
28347 }
28348 Py_INCREF(Py_None); resultobj = Py_None;
28349 return resultobj;
28350 fail:
28351 return NULL;
28352 }
28353
28354
28355 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28356 PyObject *resultobj;
28357 wxWindow *arg1 = (wxWindow *) 0 ;
28358 bool result;
28359 PyObject * obj0 = 0 ;
28360 char *kwnames[] = {
28361 (char *) "self", NULL
28362 };
28363
28364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28366 if (SWIG_arg_fail(1)) SWIG_fail;
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28370
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 {
28375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28376 }
28377 return resultobj;
28378 fail:
28379 return NULL;
28380 }
28381
28382
28383 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28384 PyObject *resultobj;
28385 wxWindow *arg1 = (wxWindow *) 0 ;
28386 PyObject * obj0 = 0 ;
28387 char *kwnames[] = {
28388 (char *) "self", NULL
28389 };
28390
28391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28393 if (SWIG_arg_fail(1)) SWIG_fail;
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 (arg1)->SetFocus();
28397
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 Py_INCREF(Py_None); resultobj = Py_None;
28402 return resultobj;
28403 fail:
28404 return NULL;
28405 }
28406
28407
28408 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28409 PyObject *resultobj;
28410 wxWindow *arg1 = (wxWindow *) 0 ;
28411 PyObject * obj0 = 0 ;
28412 char *kwnames[] = {
28413 (char *) "self", NULL
28414 };
28415
28416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28418 if (SWIG_arg_fail(1)) SWIG_fail;
28419 {
28420 PyThreadState* __tstate = wxPyBeginAllowThreads();
28421 (arg1)->SetFocusFromKbd();
28422
28423 wxPyEndAllowThreads(__tstate);
28424 if (PyErr_Occurred()) SWIG_fail;
28425 }
28426 Py_INCREF(Py_None); resultobj = Py_None;
28427 return resultobj;
28428 fail:
28429 return NULL;
28430 }
28431
28432
28433 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28434 PyObject *resultobj;
28435 wxWindow *result;
28436 char *kwnames[] = {
28437 NULL
28438 };
28439
28440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28441 {
28442 if (!wxPyCheckForApp()) SWIG_fail;
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = (wxWindow *)wxWindow::FindFocus();
28445
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 {
28450 resultobj = wxPyMake_wxObject(result, 0);
28451 }
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28459 PyObject *resultobj;
28460 wxWindow *arg1 = (wxWindow *) 0 ;
28461 bool result;
28462 PyObject * obj0 = 0 ;
28463 char *kwnames[] = {
28464 (char *) "self", NULL
28465 };
28466
28467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28469 if (SWIG_arg_fail(1)) SWIG_fail;
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28473
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 {
28478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28479 }
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj;
28488 wxWindow *arg1 = (wxWindow *) 0 ;
28489 bool result;
28490 PyObject * obj0 = 0 ;
28491 char *kwnames[] = {
28492 (char *) "self", NULL
28493 };
28494
28495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28497 if (SWIG_arg_fail(1)) SWIG_fail;
28498 {
28499 PyThreadState* __tstate = wxPyBeginAllowThreads();
28500 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28501
28502 wxPyEndAllowThreads(__tstate);
28503 if (PyErr_Occurred()) SWIG_fail;
28504 }
28505 {
28506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28507 }
28508 return resultobj;
28509 fail:
28510 return NULL;
28511 }
28512
28513
28514 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28515 PyObject *resultobj;
28516 wxWindow *arg1 = (wxWindow *) 0 ;
28517 wxWindow *result;
28518 PyObject * obj0 = 0 ;
28519 char *kwnames[] = {
28520 (char *) "self", NULL
28521 };
28522
28523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28525 if (SWIG_arg_fail(1)) SWIG_fail;
28526 {
28527 PyThreadState* __tstate = wxPyBeginAllowThreads();
28528 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28529
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 {
28534 resultobj = wxPyMake_wxObject(result, 0);
28535 }
28536 return resultobj;
28537 fail:
28538 return NULL;
28539 }
28540
28541
28542 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28543 PyObject *resultobj;
28544 wxWindow *arg1 = (wxWindow *) 0 ;
28545 wxWindow *arg2 = (wxWindow *) 0 ;
28546 wxWindow *result;
28547 PyObject * obj0 = 0 ;
28548 PyObject * obj1 = 0 ;
28549 char *kwnames[] = {
28550 (char *) "self",(char *) "child", NULL
28551 };
28552
28553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28555 if (SWIG_arg_fail(1)) SWIG_fail;
28556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28557 if (SWIG_arg_fail(2)) SWIG_fail;
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28561
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 {
28566 resultobj = wxPyMake_wxObject(result, 0);
28567 }
28568 return resultobj;
28569 fail:
28570 return NULL;
28571 }
28572
28573
28574 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28575 PyObject *resultobj;
28576 wxWindow *arg1 = (wxWindow *) 0 ;
28577 wxWindow *arg2 = (wxWindow *) 0 ;
28578 PyObject * obj0 = 0 ;
28579 PyObject * obj1 = 0 ;
28580 char *kwnames[] = {
28581 (char *) "self",(char *) "win", NULL
28582 };
28583
28584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28586 if (SWIG_arg_fail(1)) SWIG_fail;
28587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28588 if (SWIG_arg_fail(2)) SWIG_fail;
28589 {
28590 PyThreadState* __tstate = wxPyBeginAllowThreads();
28591 (arg1)->SetTmpDefaultItem(arg2);
28592
28593 wxPyEndAllowThreads(__tstate);
28594 if (PyErr_Occurred()) SWIG_fail;
28595 }
28596 Py_INCREF(Py_None); resultobj = Py_None;
28597 return resultobj;
28598 fail:
28599 return NULL;
28600 }
28601
28602
28603 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28604 PyObject *resultobj;
28605 wxWindow *arg1 = (wxWindow *) 0 ;
28606 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28607 bool result;
28608 PyObject * obj0 = 0 ;
28609 PyObject * obj1 = 0 ;
28610 char *kwnames[] = {
28611 (char *) "self",(char *) "flags", NULL
28612 };
28613
28614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28616 if (SWIG_arg_fail(1)) SWIG_fail;
28617 if (obj1) {
28618 {
28619 arg2 = (int)(SWIG_As_int(obj1));
28620 if (SWIG_arg_fail(2)) SWIG_fail;
28621 }
28622 }
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 result = (bool)(arg1)->Navigate(arg2);
28626
28627 wxPyEndAllowThreads(__tstate);
28628 if (PyErr_Occurred()) SWIG_fail;
28629 }
28630 {
28631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28632 }
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxWindow *arg1 = (wxWindow *) 0 ;
28642 wxWindow *arg2 = (wxWindow *) 0 ;
28643 PyObject * obj0 = 0 ;
28644 PyObject * obj1 = 0 ;
28645 char *kwnames[] = {
28646 (char *) "self",(char *) "win", NULL
28647 };
28648
28649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28651 if (SWIG_arg_fail(1)) SWIG_fail;
28652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28653 if (SWIG_arg_fail(2)) SWIG_fail;
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 (arg1)->MoveAfterInTabOrder(arg2);
28657
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 Py_INCREF(Py_None); resultobj = Py_None;
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28669 PyObject *resultobj;
28670 wxWindow *arg1 = (wxWindow *) 0 ;
28671 wxWindow *arg2 = (wxWindow *) 0 ;
28672 PyObject * obj0 = 0 ;
28673 PyObject * obj1 = 0 ;
28674 char *kwnames[] = {
28675 (char *) "self",(char *) "win", NULL
28676 };
28677
28678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28680 if (SWIG_arg_fail(1)) SWIG_fail;
28681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(2)) SWIG_fail;
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 (arg1)->MoveBeforeInTabOrder(arg2);
28686
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 Py_INCREF(Py_None); resultobj = Py_None;
28691 return resultobj;
28692 fail:
28693 return NULL;
28694 }
28695
28696
28697 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28698 PyObject *resultobj;
28699 wxWindow *arg1 = (wxWindow *) 0 ;
28700 PyObject *result;
28701 PyObject * obj0 = 0 ;
28702 char *kwnames[] = {
28703 (char *) "self", NULL
28704 };
28705
28706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28708 if (SWIG_arg_fail(1)) SWIG_fail;
28709 {
28710 PyThreadState* __tstate = wxPyBeginAllowThreads();
28711 result = (PyObject *)wxWindow_GetChildren(arg1);
28712
28713 wxPyEndAllowThreads(__tstate);
28714 if (PyErr_Occurred()) SWIG_fail;
28715 }
28716 resultobj = result;
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj;
28725 wxWindow *arg1 = (wxWindow *) 0 ;
28726 wxWindow *result;
28727 PyObject * obj0 = 0 ;
28728 char *kwnames[] = {
28729 (char *) "self", NULL
28730 };
28731
28732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28734 if (SWIG_arg_fail(1)) SWIG_fail;
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28738
28739 wxPyEndAllowThreads(__tstate);
28740 if (PyErr_Occurred()) SWIG_fail;
28741 }
28742 {
28743 resultobj = wxPyMake_wxObject(result, 0);
28744 }
28745 return resultobj;
28746 fail:
28747 return NULL;
28748 }
28749
28750
28751 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28752 PyObject *resultobj;
28753 wxWindow *arg1 = (wxWindow *) 0 ;
28754 wxWindow *result;
28755 PyObject * obj0 = 0 ;
28756 char *kwnames[] = {
28757 (char *) "self", NULL
28758 };
28759
28760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28762 if (SWIG_arg_fail(1)) SWIG_fail;
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28766
28767 wxPyEndAllowThreads(__tstate);
28768 if (PyErr_Occurred()) SWIG_fail;
28769 }
28770 {
28771 resultobj = wxPyMake_wxObject(result, 0);
28772 }
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28780 PyObject *resultobj;
28781 wxWindow *arg1 = (wxWindow *) 0 ;
28782 bool result;
28783 PyObject * obj0 = 0 ;
28784 char *kwnames[] = {
28785 (char *) "self", NULL
28786 };
28787
28788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28790 if (SWIG_arg_fail(1)) SWIG_fail;
28791 {
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28794
28795 wxPyEndAllowThreads(__tstate);
28796 if (PyErr_Occurred()) SWIG_fail;
28797 }
28798 {
28799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28800 }
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28808 PyObject *resultobj;
28809 wxWindow *arg1 = (wxWindow *) 0 ;
28810 wxWindow *arg2 = (wxWindow *) 0 ;
28811 bool result;
28812 PyObject * obj0 = 0 ;
28813 PyObject * obj1 = 0 ;
28814 char *kwnames[] = {
28815 (char *) "self",(char *) "newParent", NULL
28816 };
28817
28818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28820 if (SWIG_arg_fail(1)) SWIG_fail;
28821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28822 if (SWIG_arg_fail(2)) SWIG_fail;
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 result = (bool)(arg1)->Reparent(arg2);
28826
28827 wxPyEndAllowThreads(__tstate);
28828 if (PyErr_Occurred()) SWIG_fail;
28829 }
28830 {
28831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28832 }
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28840 PyObject *resultobj;
28841 wxWindow *arg1 = (wxWindow *) 0 ;
28842 wxWindow *arg2 = (wxWindow *) 0 ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 char *kwnames[] = {
28846 (char *) "self",(char *) "child", NULL
28847 };
28848
28849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28851 if (SWIG_arg_fail(1)) SWIG_fail;
28852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28853 if (SWIG_arg_fail(2)) SWIG_fail;
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 (arg1)->AddChild(arg2);
28857
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 Py_INCREF(Py_None); resultobj = Py_None;
28862 return resultobj;
28863 fail:
28864 return NULL;
28865 }
28866
28867
28868 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28869 PyObject *resultobj;
28870 wxWindow *arg1 = (wxWindow *) 0 ;
28871 wxWindow *arg2 = (wxWindow *) 0 ;
28872 PyObject * obj0 = 0 ;
28873 PyObject * obj1 = 0 ;
28874 char *kwnames[] = {
28875 (char *) "self",(char *) "child", NULL
28876 };
28877
28878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28880 if (SWIG_arg_fail(1)) SWIG_fail;
28881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28882 if (SWIG_arg_fail(2)) SWIG_fail;
28883 {
28884 PyThreadState* __tstate = wxPyBeginAllowThreads();
28885 (arg1)->RemoveChild(arg2);
28886
28887 wxPyEndAllowThreads(__tstate);
28888 if (PyErr_Occurred()) SWIG_fail;
28889 }
28890 Py_INCREF(Py_None); resultobj = Py_None;
28891 return resultobj;
28892 fail:
28893 return NULL;
28894 }
28895
28896
28897 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28898 PyObject *resultobj;
28899 wxWindow *arg1 = (wxWindow *) 0 ;
28900 long arg2 ;
28901 wxWindow *result;
28902 PyObject * obj0 = 0 ;
28903 PyObject * obj1 = 0 ;
28904 char *kwnames[] = {
28905 (char *) "self",(char *) "winid", NULL
28906 };
28907
28908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28910 if (SWIG_arg_fail(1)) SWIG_fail;
28911 {
28912 arg2 = (long)(SWIG_As_long(obj1));
28913 if (SWIG_arg_fail(2)) SWIG_fail;
28914 }
28915 {
28916 PyThreadState* __tstate = wxPyBeginAllowThreads();
28917 result = (wxWindow *)(arg1)->FindWindow(arg2);
28918
28919 wxPyEndAllowThreads(__tstate);
28920 if (PyErr_Occurred()) SWIG_fail;
28921 }
28922 {
28923 resultobj = wxPyMake_wxObject(result, 0);
28924 }
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj;
28933 wxWindow *arg1 = (wxWindow *) 0 ;
28934 wxString *arg2 = 0 ;
28935 wxWindow *result;
28936 bool temp2 = false ;
28937 PyObject * obj0 = 0 ;
28938 PyObject * obj1 = 0 ;
28939 char *kwnames[] = {
28940 (char *) "self",(char *) "name", NULL
28941 };
28942
28943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28945 if (SWIG_arg_fail(1)) SWIG_fail;
28946 {
28947 arg2 = wxString_in_helper(obj1);
28948 if (arg2 == NULL) SWIG_fail;
28949 temp2 = true;
28950 }
28951 {
28952 PyThreadState* __tstate = wxPyBeginAllowThreads();
28953 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28954
28955 wxPyEndAllowThreads(__tstate);
28956 if (PyErr_Occurred()) SWIG_fail;
28957 }
28958 {
28959 resultobj = wxPyMake_wxObject(result, 0);
28960 }
28961 {
28962 if (temp2)
28963 delete arg2;
28964 }
28965 return resultobj;
28966 fail:
28967 {
28968 if (temp2)
28969 delete arg2;
28970 }
28971 return NULL;
28972 }
28973
28974
28975 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28976 PyObject *resultobj;
28977 wxWindow *arg1 = (wxWindow *) 0 ;
28978 wxEvtHandler *result;
28979 PyObject * obj0 = 0 ;
28980 char *kwnames[] = {
28981 (char *) "self", NULL
28982 };
28983
28984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28986 if (SWIG_arg_fail(1)) SWIG_fail;
28987 {
28988 PyThreadState* __tstate = wxPyBeginAllowThreads();
28989 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28990
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 {
28995 resultobj = wxPyMake_wxObject(result, 0);
28996 }
28997 return resultobj;
28998 fail:
28999 return NULL;
29000 }
29001
29002
29003 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29004 PyObject *resultobj;
29005 wxWindow *arg1 = (wxWindow *) 0 ;
29006 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29007 PyObject * obj0 = 0 ;
29008 PyObject * obj1 = 0 ;
29009 char *kwnames[] = {
29010 (char *) "self",(char *) "handler", NULL
29011 };
29012
29013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29015 if (SWIG_arg_fail(1)) SWIG_fail;
29016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29017 if (SWIG_arg_fail(2)) SWIG_fail;
29018 {
29019 PyThreadState* __tstate = wxPyBeginAllowThreads();
29020 (arg1)->SetEventHandler(arg2);
29021
29022 wxPyEndAllowThreads(__tstate);
29023 if (PyErr_Occurred()) SWIG_fail;
29024 }
29025 Py_INCREF(Py_None); resultobj = Py_None;
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj;
29034 wxWindow *arg1 = (wxWindow *) 0 ;
29035 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29036 PyObject * obj0 = 0 ;
29037 PyObject * obj1 = 0 ;
29038 char *kwnames[] = {
29039 (char *) "self",(char *) "handler", NULL
29040 };
29041
29042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29044 if (SWIG_arg_fail(1)) SWIG_fail;
29045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29046 if (SWIG_arg_fail(2)) SWIG_fail;
29047 {
29048 PyThreadState* __tstate = wxPyBeginAllowThreads();
29049 (arg1)->PushEventHandler(arg2);
29050
29051 wxPyEndAllowThreads(__tstate);
29052 if (PyErr_Occurred()) SWIG_fail;
29053 }
29054 Py_INCREF(Py_None); resultobj = Py_None;
29055 return resultobj;
29056 fail:
29057 return NULL;
29058 }
29059
29060
29061 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29062 PyObject *resultobj;
29063 wxWindow *arg1 = (wxWindow *) 0 ;
29064 bool arg2 = (bool) false ;
29065 wxEvtHandler *result;
29066 PyObject * obj0 = 0 ;
29067 PyObject * obj1 = 0 ;
29068 char *kwnames[] = {
29069 (char *) "self",(char *) "deleteHandler", NULL
29070 };
29071
29072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29074 if (SWIG_arg_fail(1)) SWIG_fail;
29075 if (obj1) {
29076 {
29077 arg2 = (bool)(SWIG_As_bool(obj1));
29078 if (SWIG_arg_fail(2)) SWIG_fail;
29079 }
29080 }
29081 {
29082 PyThreadState* __tstate = wxPyBeginAllowThreads();
29083 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29084
29085 wxPyEndAllowThreads(__tstate);
29086 if (PyErr_Occurred()) SWIG_fail;
29087 }
29088 {
29089 resultobj = wxPyMake_wxObject(result, 0);
29090 }
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29098 PyObject *resultobj;
29099 wxWindow *arg1 = (wxWindow *) 0 ;
29100 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29101 bool result;
29102 PyObject * obj0 = 0 ;
29103 PyObject * obj1 = 0 ;
29104 char *kwnames[] = {
29105 (char *) "self",(char *) "handler", NULL
29106 };
29107
29108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29110 if (SWIG_arg_fail(1)) SWIG_fail;
29111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29112 if (SWIG_arg_fail(2)) SWIG_fail;
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 result = (bool)(arg1)->RemoveEventHandler(arg2);
29116
29117 wxPyEndAllowThreads(__tstate);
29118 if (PyErr_Occurred()) SWIG_fail;
29119 }
29120 {
29121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29122 }
29123 return resultobj;
29124 fail:
29125 return NULL;
29126 }
29127
29128
29129 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29130 PyObject *resultobj;
29131 wxWindow *arg1 = (wxWindow *) 0 ;
29132 wxValidator *arg2 = 0 ;
29133 PyObject * obj0 = 0 ;
29134 PyObject * obj1 = 0 ;
29135 char *kwnames[] = {
29136 (char *) "self",(char *) "validator", NULL
29137 };
29138
29139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29141 if (SWIG_arg_fail(1)) SWIG_fail;
29142 {
29143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29144 if (SWIG_arg_fail(2)) SWIG_fail;
29145 if (arg2 == NULL) {
29146 SWIG_null_ref("wxValidator");
29147 }
29148 if (SWIG_arg_fail(2)) SWIG_fail;
29149 }
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 (arg1)->SetValidator((wxValidator const &)*arg2);
29153
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 Py_INCREF(Py_None); resultobj = Py_None;
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29165 PyObject *resultobj;
29166 wxWindow *arg1 = (wxWindow *) 0 ;
29167 wxValidator *result;
29168 PyObject * obj0 = 0 ;
29169 char *kwnames[] = {
29170 (char *) "self", NULL
29171 };
29172
29173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29175 if (SWIG_arg_fail(1)) SWIG_fail;
29176 {
29177 PyThreadState* __tstate = wxPyBeginAllowThreads();
29178 result = (wxValidator *)(arg1)->GetValidator();
29179
29180 wxPyEndAllowThreads(__tstate);
29181 if (PyErr_Occurred()) SWIG_fail;
29182 }
29183 {
29184 resultobj = wxPyMake_wxObject(result, 0);
29185 }
29186 return resultobj;
29187 fail:
29188 return NULL;
29189 }
29190
29191
29192 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29193 PyObject *resultobj;
29194 wxWindow *arg1 = (wxWindow *) 0 ;
29195 bool result;
29196 PyObject * obj0 = 0 ;
29197 char *kwnames[] = {
29198 (char *) "self", NULL
29199 };
29200
29201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29203 if (SWIG_arg_fail(1)) SWIG_fail;
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 result = (bool)(arg1)->Validate();
29207
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 {
29212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29213 }
29214 return resultobj;
29215 fail:
29216 return NULL;
29217 }
29218
29219
29220 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29221 PyObject *resultobj;
29222 wxWindow *arg1 = (wxWindow *) 0 ;
29223 bool result;
29224 PyObject * obj0 = 0 ;
29225 char *kwnames[] = {
29226 (char *) "self", NULL
29227 };
29228
29229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29231 if (SWIG_arg_fail(1)) SWIG_fail;
29232 {
29233 PyThreadState* __tstate = wxPyBeginAllowThreads();
29234 result = (bool)(arg1)->TransferDataToWindow();
29235
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 {
29240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29241 }
29242 return resultobj;
29243 fail:
29244 return NULL;
29245 }
29246
29247
29248 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29249 PyObject *resultobj;
29250 wxWindow *arg1 = (wxWindow *) 0 ;
29251 bool result;
29252 PyObject * obj0 = 0 ;
29253 char *kwnames[] = {
29254 (char *) "self", NULL
29255 };
29256
29257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29259 if (SWIG_arg_fail(1)) SWIG_fail;
29260 {
29261 PyThreadState* __tstate = wxPyBeginAllowThreads();
29262 result = (bool)(arg1)->TransferDataFromWindow();
29263
29264 wxPyEndAllowThreads(__tstate);
29265 if (PyErr_Occurred()) SWIG_fail;
29266 }
29267 {
29268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29269 }
29270 return resultobj;
29271 fail:
29272 return NULL;
29273 }
29274
29275
29276 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29277 PyObject *resultobj;
29278 wxWindow *arg1 = (wxWindow *) 0 ;
29279 PyObject * obj0 = 0 ;
29280 char *kwnames[] = {
29281 (char *) "self", NULL
29282 };
29283
29284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29286 if (SWIG_arg_fail(1)) SWIG_fail;
29287 {
29288 PyThreadState* __tstate = wxPyBeginAllowThreads();
29289 (arg1)->InitDialog();
29290
29291 wxPyEndAllowThreads(__tstate);
29292 if (PyErr_Occurred()) SWIG_fail;
29293 }
29294 Py_INCREF(Py_None); resultobj = Py_None;
29295 return resultobj;
29296 fail:
29297 return NULL;
29298 }
29299
29300
29301 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29302 PyObject *resultobj;
29303 wxWindow *arg1 = (wxWindow *) 0 ;
29304 wxAcceleratorTable *arg2 = 0 ;
29305 PyObject * obj0 = 0 ;
29306 PyObject * obj1 = 0 ;
29307 char *kwnames[] = {
29308 (char *) "self",(char *) "accel", NULL
29309 };
29310
29311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29313 if (SWIG_arg_fail(1)) SWIG_fail;
29314 {
29315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29316 if (SWIG_arg_fail(2)) SWIG_fail;
29317 if (arg2 == NULL) {
29318 SWIG_null_ref("wxAcceleratorTable");
29319 }
29320 if (SWIG_arg_fail(2)) SWIG_fail;
29321 }
29322 {
29323 PyThreadState* __tstate = wxPyBeginAllowThreads();
29324 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29325
29326 wxPyEndAllowThreads(__tstate);
29327 if (PyErr_Occurred()) SWIG_fail;
29328 }
29329 Py_INCREF(Py_None); resultobj = Py_None;
29330 return resultobj;
29331 fail:
29332 return NULL;
29333 }
29334
29335
29336 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29337 PyObject *resultobj;
29338 wxWindow *arg1 = (wxWindow *) 0 ;
29339 wxAcceleratorTable *result;
29340 PyObject * obj0 = 0 ;
29341 char *kwnames[] = {
29342 (char *) "self", NULL
29343 };
29344
29345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29347 if (SWIG_arg_fail(1)) SWIG_fail;
29348 {
29349 PyThreadState* __tstate = wxPyBeginAllowThreads();
29350 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29351
29352 wxPyEndAllowThreads(__tstate);
29353 if (PyErr_Occurred()) SWIG_fail;
29354 }
29355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29356 return resultobj;
29357 fail:
29358 return NULL;
29359 }
29360
29361
29362 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29363 PyObject *resultobj;
29364 wxWindow *arg1 = (wxWindow *) 0 ;
29365 int arg2 ;
29366 int arg3 ;
29367 int arg4 ;
29368 bool result;
29369 PyObject * obj0 = 0 ;
29370 PyObject * obj1 = 0 ;
29371 PyObject * obj2 = 0 ;
29372 PyObject * obj3 = 0 ;
29373 char *kwnames[] = {
29374 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29375 };
29376
29377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29379 if (SWIG_arg_fail(1)) SWIG_fail;
29380 {
29381 arg2 = (int)(SWIG_As_int(obj1));
29382 if (SWIG_arg_fail(2)) SWIG_fail;
29383 }
29384 {
29385 arg3 = (int)(SWIG_As_int(obj2));
29386 if (SWIG_arg_fail(3)) SWIG_fail;
29387 }
29388 {
29389 arg4 = (int)(SWIG_As_int(obj3));
29390 if (SWIG_arg_fail(4)) SWIG_fail;
29391 }
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29395
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 {
29400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29401 }
29402 return resultobj;
29403 fail:
29404 return NULL;
29405 }
29406
29407
29408 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29409 PyObject *resultobj;
29410 wxWindow *arg1 = (wxWindow *) 0 ;
29411 int arg2 ;
29412 bool result;
29413 PyObject * obj0 = 0 ;
29414 PyObject * obj1 = 0 ;
29415 char *kwnames[] = {
29416 (char *) "self",(char *) "hotkeyId", NULL
29417 };
29418
29419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29421 if (SWIG_arg_fail(1)) SWIG_fail;
29422 {
29423 arg2 = (int)(SWIG_As_int(obj1));
29424 if (SWIG_arg_fail(2)) SWIG_fail;
29425 }
29426 {
29427 PyThreadState* __tstate = wxPyBeginAllowThreads();
29428 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29429
29430 wxPyEndAllowThreads(__tstate);
29431 if (PyErr_Occurred()) SWIG_fail;
29432 }
29433 {
29434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29435 }
29436 return resultobj;
29437 fail:
29438 return NULL;
29439 }
29440
29441
29442 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29443 PyObject *resultobj;
29444 wxWindow *arg1 = (wxWindow *) 0 ;
29445 wxPoint *arg2 = 0 ;
29446 wxPoint result;
29447 wxPoint temp2 ;
29448 PyObject * obj0 = 0 ;
29449 PyObject * obj1 = 0 ;
29450 char *kwnames[] = {
29451 (char *) "self",(char *) "pt", NULL
29452 };
29453
29454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29456 if (SWIG_arg_fail(1)) SWIG_fail;
29457 {
29458 arg2 = &temp2;
29459 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29460 }
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29464
29465 wxPyEndAllowThreads(__tstate);
29466 if (PyErr_Occurred()) SWIG_fail;
29467 }
29468 {
29469 wxPoint * resultptr;
29470 resultptr = new wxPoint((wxPoint &)(result));
29471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29472 }
29473 return resultobj;
29474 fail:
29475 return NULL;
29476 }
29477
29478
29479 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29480 PyObject *resultobj;
29481 wxWindow *arg1 = (wxWindow *) 0 ;
29482 wxSize *arg2 = 0 ;
29483 wxSize result;
29484 wxSize temp2 ;
29485 PyObject * obj0 = 0 ;
29486 PyObject * obj1 = 0 ;
29487 char *kwnames[] = {
29488 (char *) "self",(char *) "sz", NULL
29489 };
29490
29491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29493 if (SWIG_arg_fail(1)) SWIG_fail;
29494 {
29495 arg2 = &temp2;
29496 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29497 }
29498 {
29499 PyThreadState* __tstate = wxPyBeginAllowThreads();
29500 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29501
29502 wxPyEndAllowThreads(__tstate);
29503 if (PyErr_Occurred()) SWIG_fail;
29504 }
29505 {
29506 wxSize * resultptr;
29507 resultptr = new wxSize((wxSize &)(result));
29508 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29509 }
29510 return resultobj;
29511 fail:
29512 return NULL;
29513 }
29514
29515
29516 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj;
29518 wxWindow *arg1 = (wxWindow *) 0 ;
29519 wxPoint *arg2 = 0 ;
29520 wxPoint result;
29521 wxPoint temp2 ;
29522 PyObject * obj0 = 0 ;
29523 PyObject * obj1 = 0 ;
29524 char *kwnames[] = {
29525 (char *) "self",(char *) "pt", NULL
29526 };
29527
29528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29530 if (SWIG_arg_fail(1)) SWIG_fail;
29531 {
29532 arg2 = &temp2;
29533 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29534 }
29535 {
29536 PyThreadState* __tstate = wxPyBeginAllowThreads();
29537 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29538
29539 wxPyEndAllowThreads(__tstate);
29540 if (PyErr_Occurred()) SWIG_fail;
29541 }
29542 {
29543 wxPoint * resultptr;
29544 resultptr = new wxPoint((wxPoint &)(result));
29545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29546 }
29547 return resultobj;
29548 fail:
29549 return NULL;
29550 }
29551
29552
29553 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29554 PyObject *resultobj;
29555 wxWindow *arg1 = (wxWindow *) 0 ;
29556 wxSize *arg2 = 0 ;
29557 wxSize result;
29558 wxSize temp2 ;
29559 PyObject * obj0 = 0 ;
29560 PyObject * obj1 = 0 ;
29561 char *kwnames[] = {
29562 (char *) "self",(char *) "sz", NULL
29563 };
29564
29565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29567 if (SWIG_arg_fail(1)) SWIG_fail;
29568 {
29569 arg2 = &temp2;
29570 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29571 }
29572 {
29573 PyThreadState* __tstate = wxPyBeginAllowThreads();
29574 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29575
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 {
29580 wxSize * resultptr;
29581 resultptr = new wxSize((wxSize &)(result));
29582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29583 }
29584 return resultobj;
29585 fail:
29586 return NULL;
29587 }
29588
29589
29590 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29591 PyObject *resultobj;
29592 wxWindow *arg1 = (wxWindow *) 0 ;
29593 wxPoint *arg2 = 0 ;
29594 wxPoint result;
29595 wxPoint temp2 ;
29596 PyObject * obj0 = 0 ;
29597 PyObject * obj1 = 0 ;
29598 char *kwnames[] = {
29599 (char *) "self",(char *) "pt", NULL
29600 };
29601
29602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29604 if (SWIG_arg_fail(1)) SWIG_fail;
29605 {
29606 arg2 = &temp2;
29607 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29608 }
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29612
29613 wxPyEndAllowThreads(__tstate);
29614 if (PyErr_Occurred()) SWIG_fail;
29615 }
29616 {
29617 wxPoint * resultptr;
29618 resultptr = new wxPoint((wxPoint &)(result));
29619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29620 }
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29628 PyObject *resultobj;
29629 wxWindow *arg1 = (wxWindow *) 0 ;
29630 wxSize *arg2 = 0 ;
29631 wxSize result;
29632 wxSize temp2 ;
29633 PyObject * obj0 = 0 ;
29634 PyObject * obj1 = 0 ;
29635 char *kwnames[] = {
29636 (char *) "self",(char *) "sz", NULL
29637 };
29638
29639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29641 if (SWIG_arg_fail(1)) SWIG_fail;
29642 {
29643 arg2 = &temp2;
29644 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29645 }
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29649
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 {
29654 wxSize * resultptr;
29655 resultptr = new wxSize((wxSize &)(result));
29656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29657 }
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29665 PyObject *resultobj;
29666 wxWindow *arg1 = (wxWindow *) 0 ;
29667 int arg2 ;
29668 int arg3 ;
29669 PyObject * obj0 = 0 ;
29670 PyObject * obj1 = 0 ;
29671 PyObject * obj2 = 0 ;
29672 char *kwnames[] = {
29673 (char *) "self",(char *) "x",(char *) "y", NULL
29674 };
29675
29676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29678 if (SWIG_arg_fail(1)) SWIG_fail;
29679 {
29680 arg2 = (int)(SWIG_As_int(obj1));
29681 if (SWIG_arg_fail(2)) SWIG_fail;
29682 }
29683 {
29684 arg3 = (int)(SWIG_As_int(obj2));
29685 if (SWIG_arg_fail(3)) SWIG_fail;
29686 }
29687 {
29688 PyThreadState* __tstate = wxPyBeginAllowThreads();
29689 (arg1)->WarpPointer(arg2,arg3);
29690
29691 wxPyEndAllowThreads(__tstate);
29692 if (PyErr_Occurred()) SWIG_fail;
29693 }
29694 Py_INCREF(Py_None); resultobj = Py_None;
29695 return resultobj;
29696 fail:
29697 return NULL;
29698 }
29699
29700
29701 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29702 PyObject *resultobj;
29703 wxWindow *arg1 = (wxWindow *) 0 ;
29704 PyObject * obj0 = 0 ;
29705 char *kwnames[] = {
29706 (char *) "self", NULL
29707 };
29708
29709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29711 if (SWIG_arg_fail(1)) SWIG_fail;
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 (arg1)->CaptureMouse();
29715
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 Py_INCREF(Py_None); resultobj = Py_None;
29720 return resultobj;
29721 fail:
29722 return NULL;
29723 }
29724
29725
29726 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29727 PyObject *resultobj;
29728 wxWindow *arg1 = (wxWindow *) 0 ;
29729 PyObject * obj0 = 0 ;
29730 char *kwnames[] = {
29731 (char *) "self", NULL
29732 };
29733
29734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29736 if (SWIG_arg_fail(1)) SWIG_fail;
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 (arg1)->ReleaseMouse();
29740
29741 wxPyEndAllowThreads(__tstate);
29742 if (PyErr_Occurred()) SWIG_fail;
29743 }
29744 Py_INCREF(Py_None); resultobj = Py_None;
29745 return resultobj;
29746 fail:
29747 return NULL;
29748 }
29749
29750
29751 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29752 PyObject *resultobj;
29753 wxWindow *result;
29754 char *kwnames[] = {
29755 NULL
29756 };
29757
29758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29759 {
29760 if (!wxPyCheckForApp()) SWIG_fail;
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 result = (wxWindow *)wxWindow::GetCapture();
29763
29764 wxPyEndAllowThreads(__tstate);
29765 if (PyErr_Occurred()) SWIG_fail;
29766 }
29767 {
29768 resultobj = wxPyMake_wxObject(result, 0);
29769 }
29770 return resultobj;
29771 fail:
29772 return NULL;
29773 }
29774
29775
29776 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29777 PyObject *resultobj;
29778 wxWindow *arg1 = (wxWindow *) 0 ;
29779 bool result;
29780 PyObject * obj0 = 0 ;
29781 char *kwnames[] = {
29782 (char *) "self", NULL
29783 };
29784
29785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29787 if (SWIG_arg_fail(1)) SWIG_fail;
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (bool)((wxWindow const *)arg1)->HasCapture();
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 {
29796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29797 }
29798 return resultobj;
29799 fail:
29800 return NULL;
29801 }
29802
29803
29804 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29805 PyObject *resultobj;
29806 wxWindow *arg1 = (wxWindow *) 0 ;
29807 bool arg2 = (bool) true ;
29808 wxRect *arg3 = (wxRect *) NULL ;
29809 PyObject * obj0 = 0 ;
29810 PyObject * obj1 = 0 ;
29811 PyObject * obj2 = 0 ;
29812 char *kwnames[] = {
29813 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29814 };
29815
29816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29818 if (SWIG_arg_fail(1)) SWIG_fail;
29819 if (obj1) {
29820 {
29821 arg2 = (bool)(SWIG_As_bool(obj1));
29822 if (SWIG_arg_fail(2)) SWIG_fail;
29823 }
29824 }
29825 if (obj2) {
29826 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29827 if (SWIG_arg_fail(3)) SWIG_fail;
29828 }
29829 {
29830 PyThreadState* __tstate = wxPyBeginAllowThreads();
29831 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29832
29833 wxPyEndAllowThreads(__tstate);
29834 if (PyErr_Occurred()) SWIG_fail;
29835 }
29836 Py_INCREF(Py_None); resultobj = Py_None;
29837 return resultobj;
29838 fail:
29839 return NULL;
29840 }
29841
29842
29843 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29844 PyObject *resultobj;
29845 wxWindow *arg1 = (wxWindow *) 0 ;
29846 wxRect *arg2 = 0 ;
29847 bool arg3 = (bool) true ;
29848 wxRect temp2 ;
29849 PyObject * obj0 = 0 ;
29850 PyObject * obj1 = 0 ;
29851 PyObject * obj2 = 0 ;
29852 char *kwnames[] = {
29853 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29854 };
29855
29856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29858 if (SWIG_arg_fail(1)) SWIG_fail;
29859 {
29860 arg2 = &temp2;
29861 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29862 }
29863 if (obj2) {
29864 {
29865 arg3 = (bool)(SWIG_As_bool(obj2));
29866 if (SWIG_arg_fail(3)) SWIG_fail;
29867 }
29868 }
29869 {
29870 PyThreadState* __tstate = wxPyBeginAllowThreads();
29871 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29872
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 Py_INCREF(Py_None); resultobj = Py_None;
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29884 PyObject *resultobj;
29885 wxWindow *arg1 = (wxWindow *) 0 ;
29886 PyObject * obj0 = 0 ;
29887 char *kwnames[] = {
29888 (char *) "self", NULL
29889 };
29890
29891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29893 if (SWIG_arg_fail(1)) SWIG_fail;
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 (arg1)->Update();
29897
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 Py_INCREF(Py_None); resultobj = Py_None;
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29909 PyObject *resultobj;
29910 wxWindow *arg1 = (wxWindow *) 0 ;
29911 PyObject * obj0 = 0 ;
29912 char *kwnames[] = {
29913 (char *) "self", NULL
29914 };
29915
29916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29918 if (SWIG_arg_fail(1)) SWIG_fail;
29919 {
29920 PyThreadState* __tstate = wxPyBeginAllowThreads();
29921 (arg1)->ClearBackground();
29922
29923 wxPyEndAllowThreads(__tstate);
29924 if (PyErr_Occurred()) SWIG_fail;
29925 }
29926 Py_INCREF(Py_None); resultobj = Py_None;
29927 return resultobj;
29928 fail:
29929 return NULL;
29930 }
29931
29932
29933 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29934 PyObject *resultobj;
29935 wxWindow *arg1 = (wxWindow *) 0 ;
29936 PyObject * obj0 = 0 ;
29937 char *kwnames[] = {
29938 (char *) "self", NULL
29939 };
29940
29941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29943 if (SWIG_arg_fail(1)) SWIG_fail;
29944 {
29945 PyThreadState* __tstate = wxPyBeginAllowThreads();
29946 (arg1)->Freeze();
29947
29948 wxPyEndAllowThreads(__tstate);
29949 if (PyErr_Occurred()) SWIG_fail;
29950 }
29951 Py_INCREF(Py_None); resultobj = Py_None;
29952 return resultobj;
29953 fail:
29954 return NULL;
29955 }
29956
29957
29958 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29959 PyObject *resultobj;
29960 wxWindow *arg1 = (wxWindow *) 0 ;
29961 PyObject * obj0 = 0 ;
29962 char *kwnames[] = {
29963 (char *) "self", NULL
29964 };
29965
29966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29968 if (SWIG_arg_fail(1)) SWIG_fail;
29969 {
29970 PyThreadState* __tstate = wxPyBeginAllowThreads();
29971 (arg1)->Thaw();
29972
29973 wxPyEndAllowThreads(__tstate);
29974 if (PyErr_Occurred()) SWIG_fail;
29975 }
29976 Py_INCREF(Py_None); resultobj = Py_None;
29977 return resultobj;
29978 fail:
29979 return NULL;
29980 }
29981
29982
29983 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29984 PyObject *resultobj;
29985 wxWindow *arg1 = (wxWindow *) 0 ;
29986 wxDC *arg2 = 0 ;
29987 PyObject * obj0 = 0 ;
29988 PyObject * obj1 = 0 ;
29989 char *kwnames[] = {
29990 (char *) "self",(char *) "dc", NULL
29991 };
29992
29993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29995 if (SWIG_arg_fail(1)) SWIG_fail;
29996 {
29997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29998 if (SWIG_arg_fail(2)) SWIG_fail;
29999 if (arg2 == NULL) {
30000 SWIG_null_ref("wxDC");
30001 }
30002 if (SWIG_arg_fail(2)) SWIG_fail;
30003 }
30004 {
30005 PyThreadState* __tstate = wxPyBeginAllowThreads();
30006 (arg1)->PrepareDC(*arg2);
30007
30008 wxPyEndAllowThreads(__tstate);
30009 if (PyErr_Occurred()) SWIG_fail;
30010 }
30011 Py_INCREF(Py_None); resultobj = Py_None;
30012 return resultobj;
30013 fail:
30014 return NULL;
30015 }
30016
30017
30018 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30019 PyObject *resultobj;
30020 wxWindow *arg1 = (wxWindow *) 0 ;
30021 wxRegion *result;
30022 PyObject * obj0 = 0 ;
30023 char *kwnames[] = {
30024 (char *) "self", NULL
30025 };
30026
30027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30029 if (SWIG_arg_fail(1)) SWIG_fail;
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 {
30033 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30034 result = (wxRegion *) &_result_ref;
30035 }
30036
30037 wxPyEndAllowThreads(__tstate);
30038 if (PyErr_Occurred()) SWIG_fail;
30039 }
30040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30048 PyObject *resultobj;
30049 wxWindow *arg1 = (wxWindow *) 0 ;
30050 wxRect result;
30051 PyObject * obj0 = 0 ;
30052 char *kwnames[] = {
30053 (char *) "self", NULL
30054 };
30055
30056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30058 if (SWIG_arg_fail(1)) SWIG_fail;
30059 {
30060 PyThreadState* __tstate = wxPyBeginAllowThreads();
30061 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30062
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 {
30067 wxRect * resultptr;
30068 resultptr = new wxRect((wxRect &)(result));
30069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30070 }
30071 return resultobj;
30072 fail:
30073 return NULL;
30074 }
30075
30076
30077 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30078 PyObject *resultobj;
30079 wxWindow *arg1 = (wxWindow *) 0 ;
30080 int arg2 ;
30081 int arg3 ;
30082 int arg4 = (int) 1 ;
30083 int arg5 = (int) 1 ;
30084 bool result;
30085 PyObject * obj0 = 0 ;
30086 PyObject * obj1 = 0 ;
30087 PyObject * obj2 = 0 ;
30088 PyObject * obj3 = 0 ;
30089 PyObject * obj4 = 0 ;
30090 char *kwnames[] = {
30091 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30092 };
30093
30094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30096 if (SWIG_arg_fail(1)) SWIG_fail;
30097 {
30098 arg2 = (int)(SWIG_As_int(obj1));
30099 if (SWIG_arg_fail(2)) SWIG_fail;
30100 }
30101 {
30102 arg3 = (int)(SWIG_As_int(obj2));
30103 if (SWIG_arg_fail(3)) SWIG_fail;
30104 }
30105 if (obj3) {
30106 {
30107 arg4 = (int)(SWIG_As_int(obj3));
30108 if (SWIG_arg_fail(4)) SWIG_fail;
30109 }
30110 }
30111 if (obj4) {
30112 {
30113 arg5 = (int)(SWIG_As_int(obj4));
30114 if (SWIG_arg_fail(5)) SWIG_fail;
30115 }
30116 }
30117 {
30118 PyThreadState* __tstate = wxPyBeginAllowThreads();
30119 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30120
30121 wxPyEndAllowThreads(__tstate);
30122 if (PyErr_Occurred()) SWIG_fail;
30123 }
30124 {
30125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30126 }
30127 return resultobj;
30128 fail:
30129 return NULL;
30130 }
30131
30132
30133 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30134 PyObject *resultobj;
30135 wxWindow *arg1 = (wxWindow *) 0 ;
30136 wxPoint *arg2 = 0 ;
30137 bool result;
30138 wxPoint temp2 ;
30139 PyObject * obj0 = 0 ;
30140 PyObject * obj1 = 0 ;
30141 char *kwnames[] = {
30142 (char *) "self",(char *) "pt", NULL
30143 };
30144
30145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30147 if (SWIG_arg_fail(1)) SWIG_fail;
30148 {
30149 arg2 = &temp2;
30150 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30151 }
30152 {
30153 PyThreadState* __tstate = wxPyBeginAllowThreads();
30154 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30155
30156 wxPyEndAllowThreads(__tstate);
30157 if (PyErr_Occurred()) SWIG_fail;
30158 }
30159 {
30160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30161 }
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30169 PyObject *resultobj;
30170 wxWindow *arg1 = (wxWindow *) 0 ;
30171 wxRect *arg2 = 0 ;
30172 bool result;
30173 wxRect temp2 ;
30174 PyObject * obj0 = 0 ;
30175 PyObject * obj1 = 0 ;
30176 char *kwnames[] = {
30177 (char *) "self",(char *) "rect", NULL
30178 };
30179
30180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30182 if (SWIG_arg_fail(1)) SWIG_fail;
30183 {
30184 arg2 = &temp2;
30185 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30186 }
30187 {
30188 PyThreadState* __tstate = wxPyBeginAllowThreads();
30189 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30190
30191 wxPyEndAllowThreads(__tstate);
30192 if (PyErr_Occurred()) SWIG_fail;
30193 }
30194 {
30195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30196 }
30197 return resultobj;
30198 fail:
30199 return NULL;
30200 }
30201
30202
30203 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30204 PyObject *resultobj;
30205 wxWindow *arg1 = (wxWindow *) 0 ;
30206 wxVisualAttributes result;
30207 PyObject * obj0 = 0 ;
30208 char *kwnames[] = {
30209 (char *) "self", NULL
30210 };
30211
30212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30214 if (SWIG_arg_fail(1)) SWIG_fail;
30215 {
30216 PyThreadState* __tstate = wxPyBeginAllowThreads();
30217 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30218
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 {
30223 wxVisualAttributes * resultptr;
30224 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30225 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30226 }
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30234 PyObject *resultobj;
30235 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30236 wxVisualAttributes result;
30237 PyObject * obj0 = 0 ;
30238 char *kwnames[] = {
30239 (char *) "variant", NULL
30240 };
30241
30242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30243 if (obj0) {
30244 {
30245 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
30246 if (SWIG_arg_fail(1)) SWIG_fail;
30247 }
30248 }
30249 {
30250 if (!wxPyCheckForApp()) SWIG_fail;
30251 PyThreadState* __tstate = wxPyBeginAllowThreads();
30252 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
30253
30254 wxPyEndAllowThreads(__tstate);
30255 if (PyErr_Occurred()) SWIG_fail;
30256 }
30257 {
30258 wxVisualAttributes * resultptr;
30259 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30261 }
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj;
30270 wxWindow *arg1 = (wxWindow *) 0 ;
30271 wxColour *arg2 = 0 ;
30272 bool result;
30273 wxColour temp2 ;
30274 PyObject * obj0 = 0 ;
30275 PyObject * obj1 = 0 ;
30276 char *kwnames[] = {
30277 (char *) "self",(char *) "colour", NULL
30278 };
30279
30280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30282 if (SWIG_arg_fail(1)) SWIG_fail;
30283 {
30284 arg2 = &temp2;
30285 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30286 }
30287 {
30288 PyThreadState* __tstate = wxPyBeginAllowThreads();
30289 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30290
30291 wxPyEndAllowThreads(__tstate);
30292 if (PyErr_Occurred()) SWIG_fail;
30293 }
30294 {
30295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30296 }
30297 return resultobj;
30298 fail:
30299 return NULL;
30300 }
30301
30302
30303 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30304 PyObject *resultobj;
30305 wxWindow *arg1 = (wxWindow *) 0 ;
30306 wxColour *arg2 = 0 ;
30307 wxColour temp2 ;
30308 PyObject * obj0 = 0 ;
30309 PyObject * obj1 = 0 ;
30310 char *kwnames[] = {
30311 (char *) "self",(char *) "colour", NULL
30312 };
30313
30314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30316 if (SWIG_arg_fail(1)) SWIG_fail;
30317 {
30318 arg2 = &temp2;
30319 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30320 }
30321 {
30322 PyThreadState* __tstate = wxPyBeginAllowThreads();
30323 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30324
30325 wxPyEndAllowThreads(__tstate);
30326 if (PyErr_Occurred()) SWIG_fail;
30327 }
30328 Py_INCREF(Py_None); resultobj = Py_None;
30329 return resultobj;
30330 fail:
30331 return NULL;
30332 }
30333
30334
30335 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30336 PyObject *resultobj;
30337 wxWindow *arg1 = (wxWindow *) 0 ;
30338 wxColour *arg2 = 0 ;
30339 bool result;
30340 wxColour temp2 ;
30341 PyObject * obj0 = 0 ;
30342 PyObject * obj1 = 0 ;
30343 char *kwnames[] = {
30344 (char *) "self",(char *) "colour", NULL
30345 };
30346
30347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30349 if (SWIG_arg_fail(1)) SWIG_fail;
30350 {
30351 arg2 = &temp2;
30352 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30353 }
30354 {
30355 PyThreadState* __tstate = wxPyBeginAllowThreads();
30356 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30357
30358 wxPyEndAllowThreads(__tstate);
30359 if (PyErr_Occurred()) SWIG_fail;
30360 }
30361 {
30362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30363 }
30364 return resultobj;
30365 fail:
30366 return NULL;
30367 }
30368
30369
30370 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30371 PyObject *resultobj;
30372 wxWindow *arg1 = (wxWindow *) 0 ;
30373 wxColour *arg2 = 0 ;
30374 wxColour temp2 ;
30375 PyObject * obj0 = 0 ;
30376 PyObject * obj1 = 0 ;
30377 char *kwnames[] = {
30378 (char *) "self",(char *) "colour", NULL
30379 };
30380
30381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30383 if (SWIG_arg_fail(1)) SWIG_fail;
30384 {
30385 arg2 = &temp2;
30386 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30387 }
30388 {
30389 PyThreadState* __tstate = wxPyBeginAllowThreads();
30390 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30391
30392 wxPyEndAllowThreads(__tstate);
30393 if (PyErr_Occurred()) SWIG_fail;
30394 }
30395 Py_INCREF(Py_None); resultobj = Py_None;
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30403 PyObject *resultobj;
30404 wxWindow *arg1 = (wxWindow *) 0 ;
30405 wxColour result;
30406 PyObject * obj0 = 0 ;
30407 char *kwnames[] = {
30408 (char *) "self", NULL
30409 };
30410
30411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30413 if (SWIG_arg_fail(1)) SWIG_fail;
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30417
30418 wxPyEndAllowThreads(__tstate);
30419 if (PyErr_Occurred()) SWIG_fail;
30420 }
30421 {
30422 wxColour * resultptr;
30423 resultptr = new wxColour((wxColour &)(result));
30424 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30425 }
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj;
30434 wxWindow *arg1 = (wxWindow *) 0 ;
30435 wxColour result;
30436 PyObject * obj0 = 0 ;
30437 char *kwnames[] = {
30438 (char *) "self", NULL
30439 };
30440
30441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30443 if (SWIG_arg_fail(1)) SWIG_fail;
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 result = ((wxWindow const *)arg1)->GetForegroundColour();
30447
30448 wxPyEndAllowThreads(__tstate);
30449 if (PyErr_Occurred()) SWIG_fail;
30450 }
30451 {
30452 wxColour * resultptr;
30453 resultptr = new wxColour((wxColour &)(result));
30454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30455 }
30456 return resultobj;
30457 fail:
30458 return NULL;
30459 }
30460
30461
30462 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30463 PyObject *resultobj;
30464 wxWindow *arg1 = (wxWindow *) 0 ;
30465 bool result;
30466 PyObject * obj0 = 0 ;
30467 char *kwnames[] = {
30468 (char *) "self", NULL
30469 };
30470
30471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30473 if (SWIG_arg_fail(1)) SWIG_fail;
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30477
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 {
30482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30483 }
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30491 PyObject *resultobj;
30492 wxWindow *arg1 = (wxWindow *) 0 ;
30493 bool result;
30494 PyObject * obj0 = 0 ;
30495 char *kwnames[] = {
30496 (char *) "self", NULL
30497 };
30498
30499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30501 if (SWIG_arg_fail(1)) SWIG_fail;
30502 {
30503 PyThreadState* __tstate = wxPyBeginAllowThreads();
30504 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30505
30506 wxPyEndAllowThreads(__tstate);
30507 if (PyErr_Occurred()) SWIG_fail;
30508 }
30509 {
30510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30511 }
30512 return resultobj;
30513 fail:
30514 return NULL;
30515 }
30516
30517
30518 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30519 PyObject *resultobj;
30520 wxWindow *arg1 = (wxWindow *) 0 ;
30521 wxBackgroundStyle arg2 ;
30522 bool result;
30523 PyObject * obj0 = 0 ;
30524 PyObject * obj1 = 0 ;
30525 char *kwnames[] = {
30526 (char *) "self",(char *) "style", NULL
30527 };
30528
30529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30531 if (SWIG_arg_fail(1)) SWIG_fail;
30532 {
30533 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
30534 if (SWIG_arg_fail(2)) SWIG_fail;
30535 }
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
30539
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 {
30544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30545 }
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj;
30554 wxWindow *arg1 = (wxWindow *) 0 ;
30555 wxBackgroundStyle result;
30556 PyObject * obj0 = 0 ;
30557 char *kwnames[] = {
30558 (char *) "self", NULL
30559 };
30560
30561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30563 if (SWIG_arg_fail(1)) SWIG_fail;
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30567
30568 wxPyEndAllowThreads(__tstate);
30569 if (PyErr_Occurred()) SWIG_fail;
30570 }
30571 resultobj = SWIG_From_int((result));
30572 return resultobj;
30573 fail:
30574 return NULL;
30575 }
30576
30577
30578 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30579 PyObject *resultobj;
30580 wxWindow *arg1 = (wxWindow *) 0 ;
30581 bool result;
30582 PyObject * obj0 = 0 ;
30583 char *kwnames[] = {
30584 (char *) "self", NULL
30585 };
30586
30587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30589 if (SWIG_arg_fail(1)) SWIG_fail;
30590 {
30591 PyThreadState* __tstate = wxPyBeginAllowThreads();
30592 result = (bool)(arg1)->HasTransparentBackground();
30593
30594 wxPyEndAllowThreads(__tstate);
30595 if (PyErr_Occurred()) SWIG_fail;
30596 }
30597 {
30598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30599 }
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj;
30608 wxWindow *arg1 = (wxWindow *) 0 ;
30609 wxCursor *arg2 = 0 ;
30610 bool result;
30611 PyObject * obj0 = 0 ;
30612 PyObject * obj1 = 0 ;
30613 char *kwnames[] = {
30614 (char *) "self",(char *) "cursor", NULL
30615 };
30616
30617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30619 if (SWIG_arg_fail(1)) SWIG_fail;
30620 {
30621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30622 if (SWIG_arg_fail(2)) SWIG_fail;
30623 if (arg2 == NULL) {
30624 SWIG_null_ref("wxCursor");
30625 }
30626 if (SWIG_arg_fail(2)) SWIG_fail;
30627 }
30628 {
30629 PyThreadState* __tstate = wxPyBeginAllowThreads();
30630 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30631
30632 wxPyEndAllowThreads(__tstate);
30633 if (PyErr_Occurred()) SWIG_fail;
30634 }
30635 {
30636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30637 }
30638 return resultobj;
30639 fail:
30640 return NULL;
30641 }
30642
30643
30644 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30645 PyObject *resultobj;
30646 wxWindow *arg1 = (wxWindow *) 0 ;
30647 wxCursor result;
30648 PyObject * obj0 = 0 ;
30649 char *kwnames[] = {
30650 (char *) "self", NULL
30651 };
30652
30653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30655 if (SWIG_arg_fail(1)) SWIG_fail;
30656 {
30657 PyThreadState* __tstate = wxPyBeginAllowThreads();
30658 result = (arg1)->GetCursor();
30659
30660 wxPyEndAllowThreads(__tstate);
30661 if (PyErr_Occurred()) SWIG_fail;
30662 }
30663 {
30664 wxCursor * resultptr;
30665 resultptr = new wxCursor((wxCursor &)(result));
30666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30667 }
30668 return resultobj;
30669 fail:
30670 return NULL;
30671 }
30672
30673
30674 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30675 PyObject *resultobj;
30676 wxWindow *arg1 = (wxWindow *) 0 ;
30677 wxFont *arg2 = 0 ;
30678 bool result;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681 char *kwnames[] = {
30682 (char *) "self",(char *) "font", NULL
30683 };
30684
30685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30687 if (SWIG_arg_fail(1)) SWIG_fail;
30688 {
30689 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30690 if (SWIG_arg_fail(2)) SWIG_fail;
30691 if (arg2 == NULL) {
30692 SWIG_null_ref("wxFont");
30693 }
30694 if (SWIG_arg_fail(2)) SWIG_fail;
30695 }
30696 {
30697 PyThreadState* __tstate = wxPyBeginAllowThreads();
30698 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30699
30700 wxPyEndAllowThreads(__tstate);
30701 if (PyErr_Occurred()) SWIG_fail;
30702 }
30703 {
30704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30705 }
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30713 PyObject *resultobj;
30714 wxWindow *arg1 = (wxWindow *) 0 ;
30715 wxFont *arg2 = 0 ;
30716 PyObject * obj0 = 0 ;
30717 PyObject * obj1 = 0 ;
30718 char *kwnames[] = {
30719 (char *) "self",(char *) "font", NULL
30720 };
30721
30722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30724 if (SWIG_arg_fail(1)) SWIG_fail;
30725 {
30726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30727 if (SWIG_arg_fail(2)) SWIG_fail;
30728 if (arg2 == NULL) {
30729 SWIG_null_ref("wxFont");
30730 }
30731 if (SWIG_arg_fail(2)) SWIG_fail;
30732 }
30733 {
30734 PyThreadState* __tstate = wxPyBeginAllowThreads();
30735 (arg1)->SetOwnFont((wxFont const &)*arg2);
30736
30737 wxPyEndAllowThreads(__tstate);
30738 if (PyErr_Occurred()) SWIG_fail;
30739 }
30740 Py_INCREF(Py_None); resultobj = Py_None;
30741 return resultobj;
30742 fail:
30743 return NULL;
30744 }
30745
30746
30747 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30748 PyObject *resultobj;
30749 wxWindow *arg1 = (wxWindow *) 0 ;
30750 wxFont result;
30751 PyObject * obj0 = 0 ;
30752 char *kwnames[] = {
30753 (char *) "self", NULL
30754 };
30755
30756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30758 if (SWIG_arg_fail(1)) SWIG_fail;
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 result = (arg1)->GetFont();
30762
30763 wxPyEndAllowThreads(__tstate);
30764 if (PyErr_Occurred()) SWIG_fail;
30765 }
30766 {
30767 wxFont * resultptr;
30768 resultptr = new wxFont((wxFont &)(result));
30769 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30770 }
30771 return resultobj;
30772 fail:
30773 return NULL;
30774 }
30775
30776
30777 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30778 PyObject *resultobj;
30779 wxWindow *arg1 = (wxWindow *) 0 ;
30780 wxCaret *arg2 = (wxCaret *) 0 ;
30781 PyObject * obj0 = 0 ;
30782 PyObject * obj1 = 0 ;
30783 char *kwnames[] = {
30784 (char *) "self",(char *) "caret", NULL
30785 };
30786
30787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30789 if (SWIG_arg_fail(1)) SWIG_fail;
30790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30791 if (SWIG_arg_fail(2)) SWIG_fail;
30792 {
30793 PyThreadState* __tstate = wxPyBeginAllowThreads();
30794 (arg1)->SetCaret(arg2);
30795
30796 wxPyEndAllowThreads(__tstate);
30797 if (PyErr_Occurred()) SWIG_fail;
30798 }
30799 Py_INCREF(Py_None); resultobj = Py_None;
30800 return resultobj;
30801 fail:
30802 return NULL;
30803 }
30804
30805
30806 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30807 PyObject *resultobj;
30808 wxWindow *arg1 = (wxWindow *) 0 ;
30809 wxCaret *result;
30810 PyObject * obj0 = 0 ;
30811 char *kwnames[] = {
30812 (char *) "self", NULL
30813 };
30814
30815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30817 if (SWIG_arg_fail(1)) SWIG_fail;
30818 {
30819 PyThreadState* __tstate = wxPyBeginAllowThreads();
30820 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30821
30822 wxPyEndAllowThreads(__tstate);
30823 if (PyErr_Occurred()) SWIG_fail;
30824 }
30825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30826 return resultobj;
30827 fail:
30828 return NULL;
30829 }
30830
30831
30832 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30833 PyObject *resultobj;
30834 wxWindow *arg1 = (wxWindow *) 0 ;
30835 int result;
30836 PyObject * obj0 = 0 ;
30837 char *kwnames[] = {
30838 (char *) "self", NULL
30839 };
30840
30841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30843 if (SWIG_arg_fail(1)) SWIG_fail;
30844 {
30845 PyThreadState* __tstate = wxPyBeginAllowThreads();
30846 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30847
30848 wxPyEndAllowThreads(__tstate);
30849 if (PyErr_Occurred()) SWIG_fail;
30850 }
30851 {
30852 resultobj = SWIG_From_int((int)(result));
30853 }
30854 return resultobj;
30855 fail:
30856 return NULL;
30857 }
30858
30859
30860 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30861 PyObject *resultobj;
30862 wxWindow *arg1 = (wxWindow *) 0 ;
30863 int result;
30864 PyObject * obj0 = 0 ;
30865 char *kwnames[] = {
30866 (char *) "self", NULL
30867 };
30868
30869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30871 if (SWIG_arg_fail(1)) SWIG_fail;
30872 {
30873 PyThreadState* __tstate = wxPyBeginAllowThreads();
30874 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30875
30876 wxPyEndAllowThreads(__tstate);
30877 if (PyErr_Occurred()) SWIG_fail;
30878 }
30879 {
30880 resultobj = SWIG_From_int((int)(result));
30881 }
30882 return resultobj;
30883 fail:
30884 return NULL;
30885 }
30886
30887
30888 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30889 PyObject *resultobj;
30890 wxWindow *arg1 = (wxWindow *) 0 ;
30891 wxString *arg2 = 0 ;
30892 int *arg3 = (int *) 0 ;
30893 int *arg4 = (int *) 0 ;
30894 bool temp2 = false ;
30895 int temp3 ;
30896 int res3 = 0 ;
30897 int temp4 ;
30898 int res4 = 0 ;
30899 PyObject * obj0 = 0 ;
30900 PyObject * obj1 = 0 ;
30901 char *kwnames[] = {
30902 (char *) "self",(char *) "string", NULL
30903 };
30904
30905 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30906 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30909 if (SWIG_arg_fail(1)) SWIG_fail;
30910 {
30911 arg2 = wxString_in_helper(obj1);
30912 if (arg2 == NULL) SWIG_fail;
30913 temp2 = true;
30914 }
30915 {
30916 PyThreadState* __tstate = wxPyBeginAllowThreads();
30917 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30918
30919 wxPyEndAllowThreads(__tstate);
30920 if (PyErr_Occurred()) SWIG_fail;
30921 }
30922 Py_INCREF(Py_None); resultobj = Py_None;
30923 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30924 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30925 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30926 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30927 {
30928 if (temp2)
30929 delete arg2;
30930 }
30931 return resultobj;
30932 fail:
30933 {
30934 if (temp2)
30935 delete arg2;
30936 }
30937 return NULL;
30938 }
30939
30940
30941 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30942 PyObject *resultobj;
30943 wxWindow *arg1 = (wxWindow *) 0 ;
30944 wxString *arg2 = 0 ;
30945 int *arg3 = (int *) 0 ;
30946 int *arg4 = (int *) 0 ;
30947 int *arg5 = (int *) 0 ;
30948 int *arg6 = (int *) 0 ;
30949 wxFont *arg7 = (wxFont *) NULL ;
30950 bool temp2 = false ;
30951 int temp3 ;
30952 int res3 = 0 ;
30953 int temp4 ;
30954 int res4 = 0 ;
30955 int temp5 ;
30956 int res5 = 0 ;
30957 int temp6 ;
30958 int res6 = 0 ;
30959 PyObject * obj0 = 0 ;
30960 PyObject * obj1 = 0 ;
30961 PyObject * obj2 = 0 ;
30962 char *kwnames[] = {
30963 (char *) "self",(char *) "string",(char *) "font", NULL
30964 };
30965
30966 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30967 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30968 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30969 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30972 if (SWIG_arg_fail(1)) SWIG_fail;
30973 {
30974 arg2 = wxString_in_helper(obj1);
30975 if (arg2 == NULL) SWIG_fail;
30976 temp2 = true;
30977 }
30978 if (obj2) {
30979 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30980 if (SWIG_arg_fail(7)) SWIG_fail;
30981 }
30982 {
30983 PyThreadState* __tstate = wxPyBeginAllowThreads();
30984 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30985
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 Py_INCREF(Py_None); resultobj = Py_None;
30990 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30991 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30992 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30993 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30994 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30995 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30996 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30997 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30998 {
30999 if (temp2)
31000 delete arg2;
31001 }
31002 return resultobj;
31003 fail:
31004 {
31005 if (temp2)
31006 delete arg2;
31007 }
31008 return NULL;
31009 }
31010
31011
31012 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31013 PyObject *resultobj;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 int *arg2 = (int *) 0 ;
31016 int *arg3 = (int *) 0 ;
31017 int temp2 ;
31018 int res2 = 0 ;
31019 int temp3 ;
31020 int res3 = 0 ;
31021 PyObject * obj0 = 0 ;
31022 PyObject * obj1 = 0 ;
31023 PyObject * obj2 = 0 ;
31024 char *kwnames[] = {
31025 (char *) "self",(char *) "x",(char *) "y", NULL
31026 };
31027
31028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31030 if (SWIG_arg_fail(1)) SWIG_fail;
31031 {
31032 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31033 temp2 = SWIG_As_int(obj1);
31034 if (SWIG_arg_fail(2)) SWIG_fail;
31035 arg2 = &temp2;
31036 res2 = SWIG_NEWOBJ;
31037 }
31038 }
31039 {
31040 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31041 temp3 = SWIG_As_int(obj2);
31042 if (SWIG_arg_fail(3)) SWIG_fail;
31043 arg3 = &temp3;
31044 res3 = SWIG_NEWOBJ;
31045 }
31046 }
31047 {
31048 PyThreadState* __tstate = wxPyBeginAllowThreads();
31049 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31050
31051 wxPyEndAllowThreads(__tstate);
31052 if (PyErr_Occurred()) SWIG_fail;
31053 }
31054 Py_INCREF(Py_None); resultobj = Py_None;
31055 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31056 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31057 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31058 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31059 return resultobj;
31060 fail:
31061 return NULL;
31062 }
31063
31064
31065 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31066 PyObject *resultobj;
31067 wxWindow *arg1 = (wxWindow *) 0 ;
31068 int *arg2 = (int *) 0 ;
31069 int *arg3 = (int *) 0 ;
31070 int temp2 ;
31071 int res2 = 0 ;
31072 int temp3 ;
31073 int res3 = 0 ;
31074 PyObject * obj0 = 0 ;
31075 PyObject * obj1 = 0 ;
31076 PyObject * obj2 = 0 ;
31077 char *kwnames[] = {
31078 (char *) "self",(char *) "x",(char *) "y", NULL
31079 };
31080
31081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31083 if (SWIG_arg_fail(1)) SWIG_fail;
31084 {
31085 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31086 temp2 = SWIG_As_int(obj1);
31087 if (SWIG_arg_fail(2)) SWIG_fail;
31088 arg2 = &temp2;
31089 res2 = SWIG_NEWOBJ;
31090 }
31091 }
31092 {
31093 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31094 temp3 = SWIG_As_int(obj2);
31095 if (SWIG_arg_fail(3)) SWIG_fail;
31096 arg3 = &temp3;
31097 res3 = SWIG_NEWOBJ;
31098 }
31099 }
31100 {
31101 PyThreadState* __tstate = wxPyBeginAllowThreads();
31102 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31103
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 Py_INCREF(Py_None); resultobj = Py_None;
31108 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31109 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31110 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31111 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31112 return resultobj;
31113 fail:
31114 return NULL;
31115 }
31116
31117
31118 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31119 PyObject *resultobj;
31120 wxWindow *arg1 = (wxWindow *) 0 ;
31121 wxPoint *arg2 = 0 ;
31122 wxPoint result;
31123 wxPoint temp2 ;
31124 PyObject * obj0 = 0 ;
31125 PyObject * obj1 = 0 ;
31126 char *kwnames[] = {
31127 (char *) "self",(char *) "pt", NULL
31128 };
31129
31130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31132 if (SWIG_arg_fail(1)) SWIG_fail;
31133 {
31134 arg2 = &temp2;
31135 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31136 }
31137 {
31138 PyThreadState* __tstate = wxPyBeginAllowThreads();
31139 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31140
31141 wxPyEndAllowThreads(__tstate);
31142 if (PyErr_Occurred()) SWIG_fail;
31143 }
31144 {
31145 wxPoint * resultptr;
31146 resultptr = new wxPoint((wxPoint &)(result));
31147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31148 }
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj;
31157 wxWindow *arg1 = (wxWindow *) 0 ;
31158 wxPoint *arg2 = 0 ;
31159 wxPoint result;
31160 wxPoint temp2 ;
31161 PyObject * obj0 = 0 ;
31162 PyObject * obj1 = 0 ;
31163 char *kwnames[] = {
31164 (char *) "self",(char *) "pt", NULL
31165 };
31166
31167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31169 if (SWIG_arg_fail(1)) SWIG_fail;
31170 {
31171 arg2 = &temp2;
31172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31173 }
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31177
31178 wxPyEndAllowThreads(__tstate);
31179 if (PyErr_Occurred()) SWIG_fail;
31180 }
31181 {
31182 wxPoint * resultptr;
31183 resultptr = new wxPoint((wxPoint &)(result));
31184 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31185 }
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31193 PyObject *resultobj;
31194 wxWindow *arg1 = (wxWindow *) 0 ;
31195 int arg2 ;
31196 int arg3 ;
31197 wxHitTest result;
31198 PyObject * obj0 = 0 ;
31199 PyObject * obj1 = 0 ;
31200 PyObject * obj2 = 0 ;
31201 char *kwnames[] = {
31202 (char *) "self",(char *) "x",(char *) "y", NULL
31203 };
31204
31205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31207 if (SWIG_arg_fail(1)) SWIG_fail;
31208 {
31209 arg2 = (int)(SWIG_As_int(obj1));
31210 if (SWIG_arg_fail(2)) SWIG_fail;
31211 }
31212 {
31213 arg3 = (int)(SWIG_As_int(obj2));
31214 if (SWIG_arg_fail(3)) SWIG_fail;
31215 }
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31219
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 resultobj = SWIG_From_int((result));
31224 return resultobj;
31225 fail:
31226 return NULL;
31227 }
31228
31229
31230 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31231 PyObject *resultobj;
31232 wxWindow *arg1 = (wxWindow *) 0 ;
31233 wxPoint *arg2 = 0 ;
31234 wxHitTest result;
31235 wxPoint temp2 ;
31236 PyObject * obj0 = 0 ;
31237 PyObject * obj1 = 0 ;
31238 char *kwnames[] = {
31239 (char *) "self",(char *) "pt", NULL
31240 };
31241
31242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31244 if (SWIG_arg_fail(1)) SWIG_fail;
31245 {
31246 arg2 = &temp2;
31247 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31248 }
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31252
31253 wxPyEndAllowThreads(__tstate);
31254 if (PyErr_Occurred()) SWIG_fail;
31255 }
31256 resultobj = SWIG_From_int((result));
31257 return resultobj;
31258 fail:
31259 return NULL;
31260 }
31261
31262
31263 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31264 PyObject *resultobj;
31265 wxWindow *arg1 = (wxWindow *) 0 ;
31266 long arg2 ;
31267 wxBorder result;
31268 PyObject * obj0 = 0 ;
31269 PyObject * obj1 = 0 ;
31270
31271 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31273 if (SWIG_arg_fail(1)) SWIG_fail;
31274 {
31275 arg2 = (long)(SWIG_As_long(obj1));
31276 if (SWIG_arg_fail(2)) SWIG_fail;
31277 }
31278 {
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31281
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_From_int((result));
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31293 PyObject *resultobj;
31294 wxWindow *arg1 = (wxWindow *) 0 ;
31295 wxBorder result;
31296 PyObject * obj0 = 0 ;
31297
31298 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31300 if (SWIG_arg_fail(1)) SWIG_fail;
31301 {
31302 PyThreadState* __tstate = wxPyBeginAllowThreads();
31303 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31304
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 resultobj = SWIG_From_int((result));
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31316 int argc;
31317 PyObject *argv[3];
31318 int ii;
31319
31320 argc = PyObject_Length(args);
31321 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31322 argv[ii] = PyTuple_GetItem(args,ii);
31323 }
31324 if (argc == 1) {
31325 int _v;
31326 {
31327 void *ptr;
31328 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31329 _v = 0;
31330 PyErr_Clear();
31331 } else {
31332 _v = 1;
31333 }
31334 }
31335 if (_v) {
31336 return _wrap_Window_GetBorder__SWIG_1(self,args);
31337 }
31338 }
31339 if (argc == 2) {
31340 int _v;
31341 {
31342 void *ptr;
31343 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31344 _v = 0;
31345 PyErr_Clear();
31346 } else {
31347 _v = 1;
31348 }
31349 }
31350 if (_v) {
31351 _v = SWIG_Check_long(argv[1]);
31352 if (_v) {
31353 return _wrap_Window_GetBorder__SWIG_0(self,args);
31354 }
31355 }
31356 }
31357
31358 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31359 return NULL;
31360 }
31361
31362
31363 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31364 PyObject *resultobj;
31365 wxWindow *arg1 = (wxWindow *) 0 ;
31366 long arg2 = (long) wxUPDATE_UI_NONE ;
31367 PyObject * obj0 = 0 ;
31368 PyObject * obj1 = 0 ;
31369 char *kwnames[] = {
31370 (char *) "self",(char *) "flags", NULL
31371 };
31372
31373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31375 if (SWIG_arg_fail(1)) SWIG_fail;
31376 if (obj1) {
31377 {
31378 arg2 = (long)(SWIG_As_long(obj1));
31379 if (SWIG_arg_fail(2)) SWIG_fail;
31380 }
31381 }
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 (arg1)->UpdateWindowUI(arg2);
31385
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 Py_INCREF(Py_None); resultobj = Py_None;
31390 return resultobj;
31391 fail:
31392 return NULL;
31393 }
31394
31395
31396 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31397 PyObject *resultobj;
31398 wxWindow *arg1 = (wxWindow *) 0 ;
31399 wxMenu *arg2 = (wxMenu *) 0 ;
31400 int arg3 = (int) -1 ;
31401 int arg4 = (int) -1 ;
31402 bool result;
31403 PyObject * obj0 = 0 ;
31404 PyObject * obj1 = 0 ;
31405 PyObject * obj2 = 0 ;
31406 PyObject * obj3 = 0 ;
31407 char *kwnames[] = {
31408 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31409 };
31410
31411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31413 if (SWIG_arg_fail(1)) SWIG_fail;
31414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31415 if (SWIG_arg_fail(2)) SWIG_fail;
31416 if (obj2) {
31417 {
31418 arg3 = (int)(SWIG_As_int(obj2));
31419 if (SWIG_arg_fail(3)) SWIG_fail;
31420 }
31421 }
31422 if (obj3) {
31423 {
31424 arg4 = (int)(SWIG_As_int(obj3));
31425 if (SWIG_arg_fail(4)) SWIG_fail;
31426 }
31427 }
31428 {
31429 PyThreadState* __tstate = wxPyBeginAllowThreads();
31430 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31431
31432 wxPyEndAllowThreads(__tstate);
31433 if (PyErr_Occurred()) SWIG_fail;
31434 }
31435 {
31436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31437 }
31438 return resultobj;
31439 fail:
31440 return NULL;
31441 }
31442
31443
31444 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31445 PyObject *resultobj;
31446 wxWindow *arg1 = (wxWindow *) 0 ;
31447 wxMenu *arg2 = (wxMenu *) 0 ;
31448 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31449 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31450 bool result;
31451 wxPoint temp3 ;
31452 PyObject * obj0 = 0 ;
31453 PyObject * obj1 = 0 ;
31454 PyObject * obj2 = 0 ;
31455 char *kwnames[] = {
31456 (char *) "self",(char *) "menu",(char *) "pos", NULL
31457 };
31458
31459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(1)) SWIG_fail;
31462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31463 if (SWIG_arg_fail(2)) SWIG_fail;
31464 if (obj2) {
31465 {
31466 arg3 = &temp3;
31467 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31468 }
31469 }
31470 {
31471 PyThreadState* __tstate = wxPyBeginAllowThreads();
31472 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31473
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 {
31478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31479 }
31480 return resultobj;
31481 fail:
31482 return NULL;
31483 }
31484
31485
31486 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31487 PyObject *resultobj;
31488 wxWindow *arg1 = (wxWindow *) 0 ;
31489 long result;
31490 PyObject * obj0 = 0 ;
31491 char *kwnames[] = {
31492 (char *) "self", NULL
31493 };
31494
31495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31497 if (SWIG_arg_fail(1)) SWIG_fail;
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 result = (long)wxWindow_GetHandle(arg1);
31501
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 {
31506 resultobj = SWIG_From_long((long)(result));
31507 }
31508 return resultobj;
31509 fail:
31510 return NULL;
31511 }
31512
31513
31514 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31515 PyObject *resultobj;
31516 wxWindow *arg1 = (wxWindow *) 0 ;
31517 long arg2 ;
31518 PyObject * obj0 = 0 ;
31519 PyObject * obj1 = 0 ;
31520 char *kwnames[] = {
31521 (char *) "self",(char *) "handle", NULL
31522 };
31523
31524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31526 if (SWIG_arg_fail(1)) SWIG_fail;
31527 {
31528 arg2 = (long)(SWIG_As_long(obj1));
31529 if (SWIG_arg_fail(2)) SWIG_fail;
31530 }
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 wxWindow_AssociateHandle(arg1,arg2);
31534
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 Py_INCREF(Py_None); resultobj = Py_None;
31539 return resultobj;
31540 fail:
31541 return NULL;
31542 }
31543
31544
31545 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31546 PyObject *resultobj;
31547 wxWindow *arg1 = (wxWindow *) 0 ;
31548 PyObject * obj0 = 0 ;
31549 char *kwnames[] = {
31550 (char *) "self", NULL
31551 };
31552
31553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31555 if (SWIG_arg_fail(1)) SWIG_fail;
31556 {
31557 PyThreadState* __tstate = wxPyBeginAllowThreads();
31558 (arg1)->DissociateHandle();
31559
31560 wxPyEndAllowThreads(__tstate);
31561 if (PyErr_Occurred()) SWIG_fail;
31562 }
31563 Py_INCREF(Py_None); resultobj = Py_None;
31564 return resultobj;
31565 fail:
31566 return NULL;
31567 }
31568
31569
31570 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31571 PyObject *resultobj;
31572 wxWindow *arg1 = (wxWindow *) 0 ;
31573 int arg2 ;
31574 bool result;
31575 PyObject * obj0 = 0 ;
31576 PyObject * obj1 = 0 ;
31577 char *kwnames[] = {
31578 (char *) "self",(char *) "orient", NULL
31579 };
31580
31581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31583 if (SWIG_arg_fail(1)) SWIG_fail;
31584 {
31585 arg2 = (int)(SWIG_As_int(obj1));
31586 if (SWIG_arg_fail(2)) SWIG_fail;
31587 }
31588 {
31589 PyThreadState* __tstate = wxPyBeginAllowThreads();
31590 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31591
31592 wxPyEndAllowThreads(__tstate);
31593 if (PyErr_Occurred()) SWIG_fail;
31594 }
31595 {
31596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31597 }
31598 return resultobj;
31599 fail:
31600 return NULL;
31601 }
31602
31603
31604 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31605 PyObject *resultobj;
31606 wxWindow *arg1 = (wxWindow *) 0 ;
31607 int arg2 ;
31608 int arg3 ;
31609 int arg4 ;
31610 int arg5 ;
31611 bool arg6 = (bool) true ;
31612 PyObject * obj0 = 0 ;
31613 PyObject * obj1 = 0 ;
31614 PyObject * obj2 = 0 ;
31615 PyObject * obj3 = 0 ;
31616 PyObject * obj4 = 0 ;
31617 PyObject * obj5 = 0 ;
31618 char *kwnames[] = {
31619 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31620 };
31621
31622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31624 if (SWIG_arg_fail(1)) SWIG_fail;
31625 {
31626 arg2 = (int)(SWIG_As_int(obj1));
31627 if (SWIG_arg_fail(2)) SWIG_fail;
31628 }
31629 {
31630 arg3 = (int)(SWIG_As_int(obj2));
31631 if (SWIG_arg_fail(3)) SWIG_fail;
31632 }
31633 {
31634 arg4 = (int)(SWIG_As_int(obj3));
31635 if (SWIG_arg_fail(4)) SWIG_fail;
31636 }
31637 {
31638 arg5 = (int)(SWIG_As_int(obj4));
31639 if (SWIG_arg_fail(5)) SWIG_fail;
31640 }
31641 if (obj5) {
31642 {
31643 arg6 = (bool)(SWIG_As_bool(obj5));
31644 if (SWIG_arg_fail(6)) SWIG_fail;
31645 }
31646 }
31647 {
31648 PyThreadState* __tstate = wxPyBeginAllowThreads();
31649 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31650
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 Py_INCREF(Py_None); resultobj = Py_None;
31655 return resultobj;
31656 fail:
31657 return NULL;
31658 }
31659
31660
31661 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31662 PyObject *resultobj;
31663 wxWindow *arg1 = (wxWindow *) 0 ;
31664 int arg2 ;
31665 int arg3 ;
31666 bool arg4 = (bool) true ;
31667 PyObject * obj0 = 0 ;
31668 PyObject * obj1 = 0 ;
31669 PyObject * obj2 = 0 ;
31670 PyObject * obj3 = 0 ;
31671 char *kwnames[] = {
31672 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31673 };
31674
31675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 {
31679 arg2 = (int)(SWIG_As_int(obj1));
31680 if (SWIG_arg_fail(2)) SWIG_fail;
31681 }
31682 {
31683 arg3 = (int)(SWIG_As_int(obj2));
31684 if (SWIG_arg_fail(3)) SWIG_fail;
31685 }
31686 if (obj3) {
31687 {
31688 arg4 = (bool)(SWIG_As_bool(obj3));
31689 if (SWIG_arg_fail(4)) SWIG_fail;
31690 }
31691 }
31692 {
31693 PyThreadState* __tstate = wxPyBeginAllowThreads();
31694 (arg1)->SetScrollPos(arg2,arg3,arg4);
31695
31696 wxPyEndAllowThreads(__tstate);
31697 if (PyErr_Occurred()) SWIG_fail;
31698 }
31699 Py_INCREF(Py_None); resultobj = Py_None;
31700 return resultobj;
31701 fail:
31702 return NULL;
31703 }
31704
31705
31706 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31707 PyObject *resultobj;
31708 wxWindow *arg1 = (wxWindow *) 0 ;
31709 int arg2 ;
31710 int result;
31711 PyObject * obj0 = 0 ;
31712 PyObject * obj1 = 0 ;
31713 char *kwnames[] = {
31714 (char *) "self",(char *) "orientation", NULL
31715 };
31716
31717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31719 if (SWIG_arg_fail(1)) SWIG_fail;
31720 {
31721 arg2 = (int)(SWIG_As_int(obj1));
31722 if (SWIG_arg_fail(2)) SWIG_fail;
31723 }
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31727
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 {
31732 resultobj = SWIG_From_int((int)(result));
31733 }
31734 return resultobj;
31735 fail:
31736 return NULL;
31737 }
31738
31739
31740 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31741 PyObject *resultobj;
31742 wxWindow *arg1 = (wxWindow *) 0 ;
31743 int arg2 ;
31744 int result;
31745 PyObject * obj0 = 0 ;
31746 PyObject * obj1 = 0 ;
31747 char *kwnames[] = {
31748 (char *) "self",(char *) "orientation", NULL
31749 };
31750
31751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31753 if (SWIG_arg_fail(1)) SWIG_fail;
31754 {
31755 arg2 = (int)(SWIG_As_int(obj1));
31756 if (SWIG_arg_fail(2)) SWIG_fail;
31757 }
31758 {
31759 PyThreadState* __tstate = wxPyBeginAllowThreads();
31760 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31761
31762 wxPyEndAllowThreads(__tstate);
31763 if (PyErr_Occurred()) SWIG_fail;
31764 }
31765 {
31766 resultobj = SWIG_From_int((int)(result));
31767 }
31768 return resultobj;
31769 fail:
31770 return NULL;
31771 }
31772
31773
31774 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31775 PyObject *resultobj;
31776 wxWindow *arg1 = (wxWindow *) 0 ;
31777 int arg2 ;
31778 int result;
31779 PyObject * obj0 = 0 ;
31780 PyObject * obj1 = 0 ;
31781 char *kwnames[] = {
31782 (char *) "self",(char *) "orientation", NULL
31783 };
31784
31785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31787 if (SWIG_arg_fail(1)) SWIG_fail;
31788 {
31789 arg2 = (int)(SWIG_As_int(obj1));
31790 if (SWIG_arg_fail(2)) SWIG_fail;
31791 }
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31795
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 {
31800 resultobj = SWIG_From_int((int)(result));
31801 }
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31809 PyObject *resultobj;
31810 wxWindow *arg1 = (wxWindow *) 0 ;
31811 int arg2 ;
31812 int arg3 ;
31813 wxRect *arg4 = (wxRect *) NULL ;
31814 PyObject * obj0 = 0 ;
31815 PyObject * obj1 = 0 ;
31816 PyObject * obj2 = 0 ;
31817 PyObject * obj3 = 0 ;
31818 char *kwnames[] = {
31819 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31820 };
31821
31822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31824 if (SWIG_arg_fail(1)) SWIG_fail;
31825 {
31826 arg2 = (int)(SWIG_As_int(obj1));
31827 if (SWIG_arg_fail(2)) SWIG_fail;
31828 }
31829 {
31830 arg3 = (int)(SWIG_As_int(obj2));
31831 if (SWIG_arg_fail(3)) SWIG_fail;
31832 }
31833 if (obj3) {
31834 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31835 if (SWIG_arg_fail(4)) SWIG_fail;
31836 }
31837 {
31838 PyThreadState* __tstate = wxPyBeginAllowThreads();
31839 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31840
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 Py_INCREF(Py_None); resultobj = Py_None;
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31852 PyObject *resultobj;
31853 wxWindow *arg1 = (wxWindow *) 0 ;
31854 int arg2 ;
31855 bool result;
31856 PyObject * obj0 = 0 ;
31857 PyObject * obj1 = 0 ;
31858 char *kwnames[] = {
31859 (char *) "self",(char *) "lines", NULL
31860 };
31861
31862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31864 if (SWIG_arg_fail(1)) SWIG_fail;
31865 {
31866 arg2 = (int)(SWIG_As_int(obj1));
31867 if (SWIG_arg_fail(2)) SWIG_fail;
31868 }
31869 {
31870 PyThreadState* __tstate = wxPyBeginAllowThreads();
31871 result = (bool)(arg1)->ScrollLines(arg2);
31872
31873 wxPyEndAllowThreads(__tstate);
31874 if (PyErr_Occurred()) SWIG_fail;
31875 }
31876 {
31877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31878 }
31879 return resultobj;
31880 fail:
31881 return NULL;
31882 }
31883
31884
31885 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31886 PyObject *resultobj;
31887 wxWindow *arg1 = (wxWindow *) 0 ;
31888 int arg2 ;
31889 bool result;
31890 PyObject * obj0 = 0 ;
31891 PyObject * obj1 = 0 ;
31892 char *kwnames[] = {
31893 (char *) "self",(char *) "pages", NULL
31894 };
31895
31896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31898 if (SWIG_arg_fail(1)) SWIG_fail;
31899 {
31900 arg2 = (int)(SWIG_As_int(obj1));
31901 if (SWIG_arg_fail(2)) SWIG_fail;
31902 }
31903 {
31904 PyThreadState* __tstate = wxPyBeginAllowThreads();
31905 result = (bool)(arg1)->ScrollPages(arg2);
31906
31907 wxPyEndAllowThreads(__tstate);
31908 if (PyErr_Occurred()) SWIG_fail;
31909 }
31910 {
31911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31912 }
31913 return resultobj;
31914 fail:
31915 return NULL;
31916 }
31917
31918
31919 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31920 PyObject *resultobj;
31921 wxWindow *arg1 = (wxWindow *) 0 ;
31922 bool result;
31923 PyObject * obj0 = 0 ;
31924 char *kwnames[] = {
31925 (char *) "self", NULL
31926 };
31927
31928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31930 if (SWIG_arg_fail(1)) SWIG_fail;
31931 {
31932 PyThreadState* __tstate = wxPyBeginAllowThreads();
31933 result = (bool)(arg1)->LineUp();
31934
31935 wxPyEndAllowThreads(__tstate);
31936 if (PyErr_Occurred()) SWIG_fail;
31937 }
31938 {
31939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31940 }
31941 return resultobj;
31942 fail:
31943 return NULL;
31944 }
31945
31946
31947 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31948 PyObject *resultobj;
31949 wxWindow *arg1 = (wxWindow *) 0 ;
31950 bool result;
31951 PyObject * obj0 = 0 ;
31952 char *kwnames[] = {
31953 (char *) "self", NULL
31954 };
31955
31956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31958 if (SWIG_arg_fail(1)) SWIG_fail;
31959 {
31960 PyThreadState* __tstate = wxPyBeginAllowThreads();
31961 result = (bool)(arg1)->LineDown();
31962
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 {
31967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31968 }
31969 return resultobj;
31970 fail:
31971 return NULL;
31972 }
31973
31974
31975 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31976 PyObject *resultobj;
31977 wxWindow *arg1 = (wxWindow *) 0 ;
31978 bool result;
31979 PyObject * obj0 = 0 ;
31980 char *kwnames[] = {
31981 (char *) "self", NULL
31982 };
31983
31984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31986 if (SWIG_arg_fail(1)) SWIG_fail;
31987 {
31988 PyThreadState* __tstate = wxPyBeginAllowThreads();
31989 result = (bool)(arg1)->PageUp();
31990
31991 wxPyEndAllowThreads(__tstate);
31992 if (PyErr_Occurred()) SWIG_fail;
31993 }
31994 {
31995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31996 }
31997 return resultobj;
31998 fail:
31999 return NULL;
32000 }
32001
32002
32003 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32004 PyObject *resultobj;
32005 wxWindow *arg1 = (wxWindow *) 0 ;
32006 bool result;
32007 PyObject * obj0 = 0 ;
32008 char *kwnames[] = {
32009 (char *) "self", NULL
32010 };
32011
32012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32014 if (SWIG_arg_fail(1)) SWIG_fail;
32015 {
32016 PyThreadState* __tstate = wxPyBeginAllowThreads();
32017 result = (bool)(arg1)->PageDown();
32018
32019 wxPyEndAllowThreads(__tstate);
32020 if (PyErr_Occurred()) SWIG_fail;
32021 }
32022 {
32023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32024 }
32025 return resultobj;
32026 fail:
32027 return NULL;
32028 }
32029
32030
32031 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32032 PyObject *resultobj;
32033 wxWindow *arg1 = (wxWindow *) 0 ;
32034 wxString *arg2 = 0 ;
32035 bool temp2 = false ;
32036 PyObject * obj0 = 0 ;
32037 PyObject * obj1 = 0 ;
32038 char *kwnames[] = {
32039 (char *) "self",(char *) "text", NULL
32040 };
32041
32042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32044 if (SWIG_arg_fail(1)) SWIG_fail;
32045 {
32046 arg2 = wxString_in_helper(obj1);
32047 if (arg2 == NULL) SWIG_fail;
32048 temp2 = true;
32049 }
32050 {
32051 PyThreadState* __tstate = wxPyBeginAllowThreads();
32052 (arg1)->SetHelpText((wxString const &)*arg2);
32053
32054 wxPyEndAllowThreads(__tstate);
32055 if (PyErr_Occurred()) SWIG_fail;
32056 }
32057 Py_INCREF(Py_None); resultobj = Py_None;
32058 {
32059 if (temp2)
32060 delete arg2;
32061 }
32062 return resultobj;
32063 fail:
32064 {
32065 if (temp2)
32066 delete arg2;
32067 }
32068 return NULL;
32069 }
32070
32071
32072 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32073 PyObject *resultobj;
32074 wxWindow *arg1 = (wxWindow *) 0 ;
32075 wxString *arg2 = 0 ;
32076 bool temp2 = false ;
32077 PyObject * obj0 = 0 ;
32078 PyObject * obj1 = 0 ;
32079 char *kwnames[] = {
32080 (char *) "self",(char *) "text", NULL
32081 };
32082
32083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32085 if (SWIG_arg_fail(1)) SWIG_fail;
32086 {
32087 arg2 = wxString_in_helper(obj1);
32088 if (arg2 == NULL) SWIG_fail;
32089 temp2 = true;
32090 }
32091 {
32092 PyThreadState* __tstate = wxPyBeginAllowThreads();
32093 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32094
32095 wxPyEndAllowThreads(__tstate);
32096 if (PyErr_Occurred()) SWIG_fail;
32097 }
32098 Py_INCREF(Py_None); resultobj = Py_None;
32099 {
32100 if (temp2)
32101 delete arg2;
32102 }
32103 return resultobj;
32104 fail:
32105 {
32106 if (temp2)
32107 delete arg2;
32108 }
32109 return NULL;
32110 }
32111
32112
32113 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32114 PyObject *resultobj;
32115 wxWindow *arg1 = (wxWindow *) 0 ;
32116 wxString result;
32117 PyObject * obj0 = 0 ;
32118 char *kwnames[] = {
32119 (char *) "self", NULL
32120 };
32121
32122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32124 if (SWIG_arg_fail(1)) SWIG_fail;
32125 {
32126 PyThreadState* __tstate = wxPyBeginAllowThreads();
32127 result = ((wxWindow const *)arg1)->GetHelpText();
32128
32129 wxPyEndAllowThreads(__tstate);
32130 if (PyErr_Occurred()) SWIG_fail;
32131 }
32132 {
32133 #if wxUSE_UNICODE
32134 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32135 #else
32136 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32137 #endif
32138 }
32139 return resultobj;
32140 fail:
32141 return NULL;
32142 }
32143
32144
32145 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32146 PyObject *resultobj;
32147 wxWindow *arg1 = (wxWindow *) 0 ;
32148 wxString *arg2 = 0 ;
32149 bool temp2 = false ;
32150 PyObject * obj0 = 0 ;
32151 PyObject * obj1 = 0 ;
32152 char *kwnames[] = {
32153 (char *) "self",(char *) "tip", NULL
32154 };
32155
32156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32158 if (SWIG_arg_fail(1)) SWIG_fail;
32159 {
32160 arg2 = wxString_in_helper(obj1);
32161 if (arg2 == NULL) SWIG_fail;
32162 temp2 = true;
32163 }
32164 {
32165 PyThreadState* __tstate = wxPyBeginAllowThreads();
32166 (arg1)->SetToolTip((wxString const &)*arg2);
32167
32168 wxPyEndAllowThreads(__tstate);
32169 if (PyErr_Occurred()) SWIG_fail;
32170 }
32171 Py_INCREF(Py_None); resultobj = Py_None;
32172 {
32173 if (temp2)
32174 delete arg2;
32175 }
32176 return resultobj;
32177 fail:
32178 {
32179 if (temp2)
32180 delete arg2;
32181 }
32182 return NULL;
32183 }
32184
32185
32186 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32187 PyObject *resultobj;
32188 wxWindow *arg1 = (wxWindow *) 0 ;
32189 wxToolTip *arg2 = (wxToolTip *) 0 ;
32190 PyObject * obj0 = 0 ;
32191 PyObject * obj1 = 0 ;
32192 char *kwnames[] = {
32193 (char *) "self",(char *) "tip", NULL
32194 };
32195
32196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32198 if (SWIG_arg_fail(1)) SWIG_fail;
32199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
32200 if (SWIG_arg_fail(2)) SWIG_fail;
32201 {
32202 PyThreadState* __tstate = wxPyBeginAllowThreads();
32203 (arg1)->SetToolTip(arg2);
32204
32205 wxPyEndAllowThreads(__tstate);
32206 if (PyErr_Occurred()) SWIG_fail;
32207 }
32208 Py_INCREF(Py_None); resultobj = Py_None;
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32216 PyObject *resultobj;
32217 wxWindow *arg1 = (wxWindow *) 0 ;
32218 wxToolTip *result;
32219 PyObject * obj0 = 0 ;
32220 char *kwnames[] = {
32221 (char *) "self", NULL
32222 };
32223
32224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32226 if (SWIG_arg_fail(1)) SWIG_fail;
32227 {
32228 PyThreadState* __tstate = wxPyBeginAllowThreads();
32229 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32230
32231 wxPyEndAllowThreads(__tstate);
32232 if (PyErr_Occurred()) SWIG_fail;
32233 }
32234 {
32235 resultobj = wxPyMake_wxObject(result, 0);
32236 }
32237 return resultobj;
32238 fail:
32239 return NULL;
32240 }
32241
32242
32243 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32244 PyObject *resultobj;
32245 wxWindow *arg1 = (wxWindow *) 0 ;
32246 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32247 PyObject * obj0 = 0 ;
32248 PyObject * obj1 = 0 ;
32249 char *kwnames[] = {
32250 (char *) "self",(char *) "dropTarget", NULL
32251 };
32252
32253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32255 if (SWIG_arg_fail(1)) SWIG_fail;
32256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32257 if (SWIG_arg_fail(2)) SWIG_fail;
32258 {
32259 PyThreadState* __tstate = wxPyBeginAllowThreads();
32260 (arg1)->SetDropTarget(arg2);
32261
32262 wxPyEndAllowThreads(__tstate);
32263 if (PyErr_Occurred()) SWIG_fail;
32264 }
32265 Py_INCREF(Py_None); resultobj = Py_None;
32266 return resultobj;
32267 fail:
32268 return NULL;
32269 }
32270
32271
32272 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32273 PyObject *resultobj;
32274 wxWindow *arg1 = (wxWindow *) 0 ;
32275 wxPyDropTarget *result;
32276 PyObject * obj0 = 0 ;
32277 char *kwnames[] = {
32278 (char *) "self", NULL
32279 };
32280
32281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32283 if (SWIG_arg_fail(1)) SWIG_fail;
32284 {
32285 PyThreadState* __tstate = wxPyBeginAllowThreads();
32286 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32287
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32292 return resultobj;
32293 fail:
32294 return NULL;
32295 }
32296
32297
32298 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32299 PyObject *resultobj;
32300 wxWindow *arg1 = (wxWindow *) 0 ;
32301 bool arg2 ;
32302 PyObject * obj0 = 0 ;
32303 PyObject * obj1 = 0 ;
32304 char *kwnames[] = {
32305 (char *) "self",(char *) "accept", NULL
32306 };
32307
32308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32310 if (SWIG_arg_fail(1)) SWIG_fail;
32311 {
32312 arg2 = (bool)(SWIG_As_bool(obj1));
32313 if (SWIG_arg_fail(2)) SWIG_fail;
32314 }
32315 {
32316 PyThreadState* __tstate = wxPyBeginAllowThreads();
32317 wxWindow_DragAcceptFiles(arg1,arg2);
32318
32319 wxPyEndAllowThreads(__tstate);
32320 if (PyErr_Occurred()) SWIG_fail;
32321 }
32322 Py_INCREF(Py_None); resultobj = Py_None;
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32330 PyObject *resultobj;
32331 wxWindow *arg1 = (wxWindow *) 0 ;
32332 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32333 PyObject * obj0 = 0 ;
32334 PyObject * obj1 = 0 ;
32335 char *kwnames[] = {
32336 (char *) "self",(char *) "constraints", NULL
32337 };
32338
32339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32341 if (SWIG_arg_fail(1)) SWIG_fail;
32342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32343 if (SWIG_arg_fail(2)) SWIG_fail;
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 (arg1)->SetConstraints(arg2);
32347
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 Py_INCREF(Py_None); resultobj = Py_None;
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32359 PyObject *resultobj;
32360 wxWindow *arg1 = (wxWindow *) 0 ;
32361 wxLayoutConstraints *result;
32362 PyObject * obj0 = 0 ;
32363 char *kwnames[] = {
32364 (char *) "self", NULL
32365 };
32366
32367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32369 if (SWIG_arg_fail(1)) SWIG_fail;
32370 {
32371 PyThreadState* __tstate = wxPyBeginAllowThreads();
32372 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32373
32374 wxPyEndAllowThreads(__tstate);
32375 if (PyErr_Occurred()) SWIG_fail;
32376 }
32377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32378 return resultobj;
32379 fail:
32380 return NULL;
32381 }
32382
32383
32384 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32385 PyObject *resultobj;
32386 wxWindow *arg1 = (wxWindow *) 0 ;
32387 bool arg2 ;
32388 PyObject * obj0 = 0 ;
32389 PyObject * obj1 = 0 ;
32390 char *kwnames[] = {
32391 (char *) "self",(char *) "autoLayout", NULL
32392 };
32393
32394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32396 if (SWIG_arg_fail(1)) SWIG_fail;
32397 {
32398 arg2 = (bool)(SWIG_As_bool(obj1));
32399 if (SWIG_arg_fail(2)) SWIG_fail;
32400 }
32401 {
32402 PyThreadState* __tstate = wxPyBeginAllowThreads();
32403 (arg1)->SetAutoLayout(arg2);
32404
32405 wxPyEndAllowThreads(__tstate);
32406 if (PyErr_Occurred()) SWIG_fail;
32407 }
32408 Py_INCREF(Py_None); resultobj = Py_None;
32409 return resultobj;
32410 fail:
32411 return NULL;
32412 }
32413
32414
32415 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32416 PyObject *resultobj;
32417 wxWindow *arg1 = (wxWindow *) 0 ;
32418 bool result;
32419 PyObject * obj0 = 0 ;
32420 char *kwnames[] = {
32421 (char *) "self", NULL
32422 };
32423
32424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32426 if (SWIG_arg_fail(1)) SWIG_fail;
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32430
32431 wxPyEndAllowThreads(__tstate);
32432 if (PyErr_Occurred()) SWIG_fail;
32433 }
32434 {
32435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32436 }
32437 return resultobj;
32438 fail:
32439 return NULL;
32440 }
32441
32442
32443 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32444 PyObject *resultobj;
32445 wxWindow *arg1 = (wxWindow *) 0 ;
32446 bool result;
32447 PyObject * obj0 = 0 ;
32448 char *kwnames[] = {
32449 (char *) "self", NULL
32450 };
32451
32452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32454 if (SWIG_arg_fail(1)) SWIG_fail;
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 result = (bool)(arg1)->Layout();
32458
32459 wxPyEndAllowThreads(__tstate);
32460 if (PyErr_Occurred()) SWIG_fail;
32461 }
32462 {
32463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32464 }
32465 return resultobj;
32466 fail:
32467 return NULL;
32468 }
32469
32470
32471 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32472 PyObject *resultobj;
32473 wxWindow *arg1 = (wxWindow *) 0 ;
32474 wxSizer *arg2 = (wxSizer *) 0 ;
32475 bool arg3 = (bool) true ;
32476 PyObject * obj0 = 0 ;
32477 PyObject * obj1 = 0 ;
32478 PyObject * obj2 = 0 ;
32479 char *kwnames[] = {
32480 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32481 };
32482
32483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32485 if (SWIG_arg_fail(1)) SWIG_fail;
32486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32487 if (SWIG_arg_fail(2)) SWIG_fail;
32488 if (obj2) {
32489 {
32490 arg3 = (bool)(SWIG_As_bool(obj2));
32491 if (SWIG_arg_fail(3)) SWIG_fail;
32492 }
32493 }
32494 {
32495 PyThreadState* __tstate = wxPyBeginAllowThreads();
32496 (arg1)->SetSizer(arg2,arg3);
32497
32498 wxPyEndAllowThreads(__tstate);
32499 if (PyErr_Occurred()) SWIG_fail;
32500 }
32501 Py_INCREF(Py_None); resultobj = Py_None;
32502 return resultobj;
32503 fail:
32504 return NULL;
32505 }
32506
32507
32508 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32509 PyObject *resultobj;
32510 wxWindow *arg1 = (wxWindow *) 0 ;
32511 wxSizer *arg2 = (wxSizer *) 0 ;
32512 bool arg3 = (bool) true ;
32513 PyObject * obj0 = 0 ;
32514 PyObject * obj1 = 0 ;
32515 PyObject * obj2 = 0 ;
32516 char *kwnames[] = {
32517 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32518 };
32519
32520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32522 if (SWIG_arg_fail(1)) SWIG_fail;
32523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32524 if (SWIG_arg_fail(2)) SWIG_fail;
32525 if (obj2) {
32526 {
32527 arg3 = (bool)(SWIG_As_bool(obj2));
32528 if (SWIG_arg_fail(3)) SWIG_fail;
32529 }
32530 }
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 (arg1)->SetSizerAndFit(arg2,arg3);
32534
32535 wxPyEndAllowThreads(__tstate);
32536 if (PyErr_Occurred()) SWIG_fail;
32537 }
32538 Py_INCREF(Py_None); resultobj = Py_None;
32539 return resultobj;
32540 fail:
32541 return NULL;
32542 }
32543
32544
32545 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32546 PyObject *resultobj;
32547 wxWindow *arg1 = (wxWindow *) 0 ;
32548 wxSizer *result;
32549 PyObject * obj0 = 0 ;
32550 char *kwnames[] = {
32551 (char *) "self", NULL
32552 };
32553
32554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32556 if (SWIG_arg_fail(1)) SWIG_fail;
32557 {
32558 PyThreadState* __tstate = wxPyBeginAllowThreads();
32559 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32560
32561 wxPyEndAllowThreads(__tstate);
32562 if (PyErr_Occurred()) SWIG_fail;
32563 }
32564 {
32565 resultobj = wxPyMake_wxObject(result, 0);
32566 }
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32574 PyObject *resultobj;
32575 wxWindow *arg1 = (wxWindow *) 0 ;
32576 wxSizer *arg2 = (wxSizer *) 0 ;
32577 PyObject * obj0 = 0 ;
32578 PyObject * obj1 = 0 ;
32579 char *kwnames[] = {
32580 (char *) "self",(char *) "sizer", NULL
32581 };
32582
32583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32585 if (SWIG_arg_fail(1)) SWIG_fail;
32586 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32587 if (SWIG_arg_fail(2)) SWIG_fail;
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 (arg1)->SetContainingSizer(arg2);
32591
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 Py_INCREF(Py_None); resultobj = Py_None;
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32603 PyObject *resultobj;
32604 wxWindow *arg1 = (wxWindow *) 0 ;
32605 wxSizer *result;
32606 PyObject * obj0 = 0 ;
32607 char *kwnames[] = {
32608 (char *) "self", NULL
32609 };
32610
32611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32613 if (SWIG_arg_fail(1)) SWIG_fail;
32614 {
32615 PyThreadState* __tstate = wxPyBeginAllowThreads();
32616 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32617
32618 wxPyEndAllowThreads(__tstate);
32619 if (PyErr_Occurred()) SWIG_fail;
32620 }
32621 {
32622 resultobj = wxPyMake_wxObject(result, 0);
32623 }
32624 return resultobj;
32625 fail:
32626 return NULL;
32627 }
32628
32629
32630 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32631 PyObject *resultobj;
32632 wxWindow *arg1 = (wxWindow *) 0 ;
32633 PyObject * obj0 = 0 ;
32634 char *kwnames[] = {
32635 (char *) "self", NULL
32636 };
32637
32638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32640 if (SWIG_arg_fail(1)) SWIG_fail;
32641 {
32642 PyThreadState* __tstate = wxPyBeginAllowThreads();
32643 (arg1)->InheritAttributes();
32644
32645 wxPyEndAllowThreads(__tstate);
32646 if (PyErr_Occurred()) SWIG_fail;
32647 }
32648 Py_INCREF(Py_None); resultobj = Py_None;
32649 return resultobj;
32650 fail:
32651 return NULL;
32652 }
32653
32654
32655 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32656 PyObject *resultobj;
32657 wxWindow *arg1 = (wxWindow *) 0 ;
32658 bool result;
32659 PyObject * obj0 = 0 ;
32660 char *kwnames[] = {
32661 (char *) "self", NULL
32662 };
32663
32664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32666 if (SWIG_arg_fail(1)) SWIG_fail;
32667 {
32668 PyThreadState* __tstate = wxPyBeginAllowThreads();
32669 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32670
32671 wxPyEndAllowThreads(__tstate);
32672 if (PyErr_Occurred()) SWIG_fail;
32673 }
32674 {
32675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32676 }
32677 return resultobj;
32678 fail:
32679 return NULL;
32680 }
32681
32682
32683 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32684 PyObject *obj;
32685 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32686 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32687 Py_INCREF(obj);
32688 return Py_BuildValue((char *)"");
32689 }
32690 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32691 PyObject *resultobj;
32692 long arg1 ;
32693 wxWindow *arg2 = (wxWindow *) NULL ;
32694 wxWindow *result;
32695 PyObject * obj0 = 0 ;
32696 PyObject * obj1 = 0 ;
32697 char *kwnames[] = {
32698 (char *) "id",(char *) "parent", NULL
32699 };
32700
32701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32702 {
32703 arg1 = (long)(SWIG_As_long(obj0));
32704 if (SWIG_arg_fail(1)) SWIG_fail;
32705 }
32706 if (obj1) {
32707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32708 if (SWIG_arg_fail(2)) SWIG_fail;
32709 }
32710 {
32711 if (!wxPyCheckForApp()) SWIG_fail;
32712 PyThreadState* __tstate = wxPyBeginAllowThreads();
32713 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32714
32715 wxPyEndAllowThreads(__tstate);
32716 if (PyErr_Occurred()) SWIG_fail;
32717 }
32718 {
32719 resultobj = wxPyMake_wxObject(result, 0);
32720 }
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32728 PyObject *resultobj;
32729 wxString *arg1 = 0 ;
32730 wxWindow *arg2 = (wxWindow *) NULL ;
32731 wxWindow *result;
32732 bool temp1 = false ;
32733 PyObject * obj0 = 0 ;
32734 PyObject * obj1 = 0 ;
32735 char *kwnames[] = {
32736 (char *) "name",(char *) "parent", NULL
32737 };
32738
32739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32740 {
32741 arg1 = wxString_in_helper(obj0);
32742 if (arg1 == NULL) SWIG_fail;
32743 temp1 = true;
32744 }
32745 if (obj1) {
32746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32747 if (SWIG_arg_fail(2)) SWIG_fail;
32748 }
32749 {
32750 if (!wxPyCheckForApp()) SWIG_fail;
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32753
32754 wxPyEndAllowThreads(__tstate);
32755 if (PyErr_Occurred()) SWIG_fail;
32756 }
32757 {
32758 resultobj = wxPyMake_wxObject(result, 0);
32759 }
32760 {
32761 if (temp1)
32762 delete arg1;
32763 }
32764 return resultobj;
32765 fail:
32766 {
32767 if (temp1)
32768 delete arg1;
32769 }
32770 return NULL;
32771 }
32772
32773
32774 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32775 PyObject *resultobj;
32776 wxString *arg1 = 0 ;
32777 wxWindow *arg2 = (wxWindow *) NULL ;
32778 wxWindow *result;
32779 bool temp1 = false ;
32780 PyObject * obj0 = 0 ;
32781 PyObject * obj1 = 0 ;
32782 char *kwnames[] = {
32783 (char *) "label",(char *) "parent", NULL
32784 };
32785
32786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32787 {
32788 arg1 = wxString_in_helper(obj0);
32789 if (arg1 == NULL) SWIG_fail;
32790 temp1 = true;
32791 }
32792 if (obj1) {
32793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32794 if (SWIG_arg_fail(2)) SWIG_fail;
32795 }
32796 {
32797 if (!wxPyCheckForApp()) SWIG_fail;
32798 PyThreadState* __tstate = wxPyBeginAllowThreads();
32799 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32800
32801 wxPyEndAllowThreads(__tstate);
32802 if (PyErr_Occurred()) SWIG_fail;
32803 }
32804 {
32805 resultobj = wxPyMake_wxObject(result, 0);
32806 }
32807 {
32808 if (temp1)
32809 delete arg1;
32810 }
32811 return resultobj;
32812 fail:
32813 {
32814 if (temp1)
32815 delete arg1;
32816 }
32817 return NULL;
32818 }
32819
32820
32821 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32822 PyObject *resultobj;
32823 wxWindow *arg1 = (wxWindow *) 0 ;
32824 unsigned long arg2 ;
32825 wxWindow *result;
32826 PyObject * obj0 = 0 ;
32827 PyObject * obj1 = 0 ;
32828 char *kwnames[] = {
32829 (char *) "parent",(char *) "_hWnd", NULL
32830 };
32831
32832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32834 if (SWIG_arg_fail(1)) SWIG_fail;
32835 {
32836 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32837 if (SWIG_arg_fail(2)) SWIG_fail;
32838 }
32839 {
32840 PyThreadState* __tstate = wxPyBeginAllowThreads();
32841 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32842
32843 wxPyEndAllowThreads(__tstate);
32844 if (PyErr_Occurred()) SWIG_fail;
32845 }
32846 {
32847 resultobj = wxPyMake_wxObject(result, 0);
32848 }
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32856 PyObject *resultobj;
32857 PyObject *result;
32858 char *kwnames[] = {
32859 NULL
32860 };
32861
32862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32863 {
32864 PyThreadState* __tstate = wxPyBeginAllowThreads();
32865 result = (PyObject *)GetTopLevelWindows();
32866
32867 wxPyEndAllowThreads(__tstate);
32868 if (PyErr_Occurred()) SWIG_fail;
32869 }
32870 resultobj = result;
32871 return resultobj;
32872 fail:
32873 return NULL;
32874 }
32875
32876
32877 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32878 PyObject *resultobj;
32879 wxValidator *result;
32880 char *kwnames[] = {
32881 NULL
32882 };
32883
32884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32885 {
32886 PyThreadState* __tstate = wxPyBeginAllowThreads();
32887 result = (wxValidator *)new wxValidator();
32888
32889 wxPyEndAllowThreads(__tstate);
32890 if (PyErr_Occurred()) SWIG_fail;
32891 }
32892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32893 return resultobj;
32894 fail:
32895 return NULL;
32896 }
32897
32898
32899 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32900 PyObject *resultobj;
32901 wxValidator *arg1 = (wxValidator *) 0 ;
32902 wxValidator *result;
32903 PyObject * obj0 = 0 ;
32904 char *kwnames[] = {
32905 (char *) "self", NULL
32906 };
32907
32908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32910 if (SWIG_arg_fail(1)) SWIG_fail;
32911 {
32912 PyThreadState* __tstate = wxPyBeginAllowThreads();
32913 result = (wxValidator *)(arg1)->Clone();
32914
32915 wxPyEndAllowThreads(__tstate);
32916 if (PyErr_Occurred()) SWIG_fail;
32917 }
32918 {
32919 resultobj = wxPyMake_wxObject(result, 0);
32920 }
32921 return resultobj;
32922 fail:
32923 return NULL;
32924 }
32925
32926
32927 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32928 PyObject *resultobj;
32929 wxValidator *arg1 = (wxValidator *) 0 ;
32930 wxWindow *arg2 = (wxWindow *) 0 ;
32931 bool result;
32932 PyObject * obj0 = 0 ;
32933 PyObject * obj1 = 0 ;
32934 char *kwnames[] = {
32935 (char *) "self",(char *) "parent", NULL
32936 };
32937
32938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32940 if (SWIG_arg_fail(1)) SWIG_fail;
32941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32942 if (SWIG_arg_fail(2)) SWIG_fail;
32943 {
32944 PyThreadState* __tstate = wxPyBeginAllowThreads();
32945 result = (bool)(arg1)->Validate(arg2);
32946
32947 wxPyEndAllowThreads(__tstate);
32948 if (PyErr_Occurred()) SWIG_fail;
32949 }
32950 {
32951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32952 }
32953 return resultobj;
32954 fail:
32955 return NULL;
32956 }
32957
32958
32959 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32960 PyObject *resultobj;
32961 wxValidator *arg1 = (wxValidator *) 0 ;
32962 bool result;
32963 PyObject * obj0 = 0 ;
32964 char *kwnames[] = {
32965 (char *) "self", NULL
32966 };
32967
32968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32970 if (SWIG_arg_fail(1)) SWIG_fail;
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 result = (bool)(arg1)->TransferToWindow();
32974
32975 wxPyEndAllowThreads(__tstate);
32976 if (PyErr_Occurred()) SWIG_fail;
32977 }
32978 {
32979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32980 }
32981 return resultobj;
32982 fail:
32983 return NULL;
32984 }
32985
32986
32987 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32988 PyObject *resultobj;
32989 wxValidator *arg1 = (wxValidator *) 0 ;
32990 bool result;
32991 PyObject * obj0 = 0 ;
32992 char *kwnames[] = {
32993 (char *) "self", NULL
32994 };
32995
32996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32998 if (SWIG_arg_fail(1)) SWIG_fail;
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = (bool)(arg1)->TransferFromWindow();
33002
33003 wxPyEndAllowThreads(__tstate);
33004 if (PyErr_Occurred()) SWIG_fail;
33005 }
33006 {
33007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33008 }
33009 return resultobj;
33010 fail:
33011 return NULL;
33012 }
33013
33014
33015 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33016 PyObject *resultobj;
33017 wxValidator *arg1 = (wxValidator *) 0 ;
33018 wxWindow *result;
33019 PyObject * obj0 = 0 ;
33020 char *kwnames[] = {
33021 (char *) "self", NULL
33022 };
33023
33024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33026 if (SWIG_arg_fail(1)) SWIG_fail;
33027 {
33028 PyThreadState* __tstate = wxPyBeginAllowThreads();
33029 result = (wxWindow *)(arg1)->GetWindow();
33030
33031 wxPyEndAllowThreads(__tstate);
33032 if (PyErr_Occurred()) SWIG_fail;
33033 }
33034 {
33035 resultobj = wxPyMake_wxObject(result, 0);
33036 }
33037 return resultobj;
33038 fail:
33039 return NULL;
33040 }
33041
33042
33043 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33044 PyObject *resultobj;
33045 wxValidator *arg1 = (wxValidator *) 0 ;
33046 wxWindow *arg2 = (wxWindow *) 0 ;
33047 PyObject * obj0 = 0 ;
33048 PyObject * obj1 = 0 ;
33049 char *kwnames[] = {
33050 (char *) "self",(char *) "window", NULL
33051 };
33052
33053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33055 if (SWIG_arg_fail(1)) SWIG_fail;
33056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33057 if (SWIG_arg_fail(2)) SWIG_fail;
33058 {
33059 PyThreadState* __tstate = wxPyBeginAllowThreads();
33060 (arg1)->SetWindow(arg2);
33061
33062 wxPyEndAllowThreads(__tstate);
33063 if (PyErr_Occurred()) SWIG_fail;
33064 }
33065 Py_INCREF(Py_None); resultobj = Py_None;
33066 return resultobj;
33067 fail:
33068 return NULL;
33069 }
33070
33071
33072 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33073 PyObject *resultobj;
33074 bool result;
33075 char *kwnames[] = {
33076 NULL
33077 };
33078
33079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33080 {
33081 PyThreadState* __tstate = wxPyBeginAllowThreads();
33082 result = (bool)wxValidator::IsSilent();
33083
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 {
33088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33089 }
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33097 PyObject *resultobj;
33098 int arg1 = (int) true ;
33099 PyObject * obj0 = 0 ;
33100 char *kwnames[] = {
33101 (char *) "doIt", NULL
33102 };
33103
33104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33105 if (obj0) {
33106 {
33107 arg1 = (int)(SWIG_As_int(obj0));
33108 if (SWIG_arg_fail(1)) SWIG_fail;
33109 }
33110 }
33111 {
33112 PyThreadState* __tstate = wxPyBeginAllowThreads();
33113 wxValidator::SetBellOnError(arg1);
33114
33115 wxPyEndAllowThreads(__tstate);
33116 if (PyErr_Occurred()) SWIG_fail;
33117 }
33118 Py_INCREF(Py_None); resultobj = Py_None;
33119 return resultobj;
33120 fail:
33121 return NULL;
33122 }
33123
33124
33125 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33126 PyObject *obj;
33127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33128 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33129 Py_INCREF(obj);
33130 return Py_BuildValue((char *)"");
33131 }
33132 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33133 PyObject *resultobj;
33134 wxPyValidator *result;
33135 char *kwnames[] = {
33136 NULL
33137 };
33138
33139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33140 {
33141 PyThreadState* __tstate = wxPyBeginAllowThreads();
33142 result = (wxPyValidator *)new wxPyValidator();
33143
33144 wxPyEndAllowThreads(__tstate);
33145 if (PyErr_Occurred()) SWIG_fail;
33146 }
33147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33148 return resultobj;
33149 fail:
33150 return NULL;
33151 }
33152
33153
33154 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33155 PyObject *resultobj;
33156 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33157 PyObject *arg2 = (PyObject *) 0 ;
33158 PyObject *arg3 = (PyObject *) 0 ;
33159 int arg4 = (int) true ;
33160 PyObject * obj0 = 0 ;
33161 PyObject * obj1 = 0 ;
33162 PyObject * obj2 = 0 ;
33163 PyObject * obj3 = 0 ;
33164 char *kwnames[] = {
33165 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33166 };
33167
33168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33170 if (SWIG_arg_fail(1)) SWIG_fail;
33171 arg2 = obj1;
33172 arg3 = obj2;
33173 if (obj3) {
33174 {
33175 arg4 = (int)(SWIG_As_int(obj3));
33176 if (SWIG_arg_fail(4)) SWIG_fail;
33177 }
33178 }
33179 {
33180 PyThreadState* __tstate = wxPyBeginAllowThreads();
33181 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33182
33183 wxPyEndAllowThreads(__tstate);
33184 if (PyErr_Occurred()) SWIG_fail;
33185 }
33186 Py_INCREF(Py_None); resultobj = Py_None;
33187 return resultobj;
33188 fail:
33189 return NULL;
33190 }
33191
33192
33193 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33194 PyObject *obj;
33195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33196 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33197 Py_INCREF(obj);
33198 return Py_BuildValue((char *)"");
33199 }
33200 static int _wrap_DefaultValidator_set(PyObject *) {
33201 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33202 return 1;
33203 }
33204
33205
33206 static PyObject *_wrap_DefaultValidator_get(void) {
33207 PyObject *pyobj;
33208
33209 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33210 return pyobj;
33211 }
33212
33213
33214 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33215 PyObject *resultobj;
33216 wxString const &arg1_defvalue = wxPyEmptyString ;
33217 wxString *arg1 = (wxString *) &arg1_defvalue ;
33218 long arg2 = (long) 0 ;
33219 wxMenu *result;
33220 bool temp1 = false ;
33221 PyObject * obj0 = 0 ;
33222 PyObject * obj1 = 0 ;
33223 char *kwnames[] = {
33224 (char *) "title",(char *) "style", NULL
33225 };
33226
33227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33228 if (obj0) {
33229 {
33230 arg1 = wxString_in_helper(obj0);
33231 if (arg1 == NULL) SWIG_fail;
33232 temp1 = true;
33233 }
33234 }
33235 if (obj1) {
33236 {
33237 arg2 = (long)(SWIG_As_long(obj1));
33238 if (SWIG_arg_fail(2)) SWIG_fail;
33239 }
33240 }
33241 {
33242 if (!wxPyCheckForApp()) SWIG_fail;
33243 PyThreadState* __tstate = wxPyBeginAllowThreads();
33244 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33245
33246 wxPyEndAllowThreads(__tstate);
33247 if (PyErr_Occurred()) SWIG_fail;
33248 }
33249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33250 {
33251 if (temp1)
33252 delete arg1;
33253 }
33254 return resultobj;
33255 fail:
33256 {
33257 if (temp1)
33258 delete arg1;
33259 }
33260 return NULL;
33261 }
33262
33263
33264 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33265 PyObject *resultobj;
33266 wxMenu *arg1 = (wxMenu *) 0 ;
33267 int arg2 ;
33268 wxString *arg3 = 0 ;
33269 wxString const &arg4_defvalue = wxPyEmptyString ;
33270 wxString *arg4 = (wxString *) &arg4_defvalue ;
33271 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33272 wxMenuItem *result;
33273 bool temp3 = false ;
33274 bool temp4 = false ;
33275 PyObject * obj0 = 0 ;
33276 PyObject * obj1 = 0 ;
33277 PyObject * obj2 = 0 ;
33278 PyObject * obj3 = 0 ;
33279 PyObject * obj4 = 0 ;
33280 char *kwnames[] = {
33281 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33282 };
33283
33284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33286 if (SWIG_arg_fail(1)) SWIG_fail;
33287 {
33288 arg2 = (int)(SWIG_As_int(obj1));
33289 if (SWIG_arg_fail(2)) SWIG_fail;
33290 }
33291 {
33292 arg3 = wxString_in_helper(obj2);
33293 if (arg3 == NULL) SWIG_fail;
33294 temp3 = true;
33295 }
33296 if (obj3) {
33297 {
33298 arg4 = wxString_in_helper(obj3);
33299 if (arg4 == NULL) SWIG_fail;
33300 temp4 = true;
33301 }
33302 }
33303 if (obj4) {
33304 {
33305 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33306 if (SWIG_arg_fail(5)) SWIG_fail;
33307 }
33308 }
33309 {
33310 PyThreadState* __tstate = wxPyBeginAllowThreads();
33311 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33312
33313 wxPyEndAllowThreads(__tstate);
33314 if (PyErr_Occurred()) SWIG_fail;
33315 }
33316 {
33317 resultobj = wxPyMake_wxObject(result, 0);
33318 }
33319 {
33320 if (temp3)
33321 delete arg3;
33322 }
33323 {
33324 if (temp4)
33325 delete arg4;
33326 }
33327 return resultobj;
33328 fail:
33329 {
33330 if (temp3)
33331 delete arg3;
33332 }
33333 {
33334 if (temp4)
33335 delete arg4;
33336 }
33337 return NULL;
33338 }
33339
33340
33341 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33342 PyObject *resultobj;
33343 wxMenu *arg1 = (wxMenu *) 0 ;
33344 wxMenuItem *result;
33345 PyObject * obj0 = 0 ;
33346 char *kwnames[] = {
33347 (char *) "self", NULL
33348 };
33349
33350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33352 if (SWIG_arg_fail(1)) SWIG_fail;
33353 {
33354 PyThreadState* __tstate = wxPyBeginAllowThreads();
33355 result = (wxMenuItem *)(arg1)->AppendSeparator();
33356
33357 wxPyEndAllowThreads(__tstate);
33358 if (PyErr_Occurred()) SWIG_fail;
33359 }
33360 {
33361 resultobj = wxPyMake_wxObject(result, 0);
33362 }
33363 return resultobj;
33364 fail:
33365 return NULL;
33366 }
33367
33368
33369 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33370 PyObject *resultobj;
33371 wxMenu *arg1 = (wxMenu *) 0 ;
33372 int arg2 ;
33373 wxString *arg3 = 0 ;
33374 wxString const &arg4_defvalue = wxPyEmptyString ;
33375 wxString *arg4 = (wxString *) &arg4_defvalue ;
33376 wxMenuItem *result;
33377 bool temp3 = false ;
33378 bool temp4 = false ;
33379 PyObject * obj0 = 0 ;
33380 PyObject * obj1 = 0 ;
33381 PyObject * obj2 = 0 ;
33382 PyObject * obj3 = 0 ;
33383 char *kwnames[] = {
33384 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33385 };
33386
33387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33389 if (SWIG_arg_fail(1)) SWIG_fail;
33390 {
33391 arg2 = (int)(SWIG_As_int(obj1));
33392 if (SWIG_arg_fail(2)) SWIG_fail;
33393 }
33394 {
33395 arg3 = wxString_in_helper(obj2);
33396 if (arg3 == NULL) SWIG_fail;
33397 temp3 = true;
33398 }
33399 if (obj3) {
33400 {
33401 arg4 = wxString_in_helper(obj3);
33402 if (arg4 == NULL) SWIG_fail;
33403 temp4 = true;
33404 }
33405 }
33406 {
33407 PyThreadState* __tstate = wxPyBeginAllowThreads();
33408 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33409
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 {
33414 resultobj = wxPyMake_wxObject(result, 0);
33415 }
33416 {
33417 if (temp3)
33418 delete arg3;
33419 }
33420 {
33421 if (temp4)
33422 delete arg4;
33423 }
33424 return resultobj;
33425 fail:
33426 {
33427 if (temp3)
33428 delete arg3;
33429 }
33430 {
33431 if (temp4)
33432 delete arg4;
33433 }
33434 return NULL;
33435 }
33436
33437
33438 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33439 PyObject *resultobj;
33440 wxMenu *arg1 = (wxMenu *) 0 ;
33441 int arg2 ;
33442 wxString *arg3 = 0 ;
33443 wxString const &arg4_defvalue = wxPyEmptyString ;
33444 wxString *arg4 = (wxString *) &arg4_defvalue ;
33445 wxMenuItem *result;
33446 bool temp3 = false ;
33447 bool temp4 = false ;
33448 PyObject * obj0 = 0 ;
33449 PyObject * obj1 = 0 ;
33450 PyObject * obj2 = 0 ;
33451 PyObject * obj3 = 0 ;
33452 char *kwnames[] = {
33453 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33454 };
33455
33456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33458 if (SWIG_arg_fail(1)) SWIG_fail;
33459 {
33460 arg2 = (int)(SWIG_As_int(obj1));
33461 if (SWIG_arg_fail(2)) SWIG_fail;
33462 }
33463 {
33464 arg3 = wxString_in_helper(obj2);
33465 if (arg3 == NULL) SWIG_fail;
33466 temp3 = true;
33467 }
33468 if (obj3) {
33469 {
33470 arg4 = wxString_in_helper(obj3);
33471 if (arg4 == NULL) SWIG_fail;
33472 temp4 = true;
33473 }
33474 }
33475 {
33476 PyThreadState* __tstate = wxPyBeginAllowThreads();
33477 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33478
33479 wxPyEndAllowThreads(__tstate);
33480 if (PyErr_Occurred()) SWIG_fail;
33481 }
33482 {
33483 resultobj = wxPyMake_wxObject(result, 0);
33484 }
33485 {
33486 if (temp3)
33487 delete arg3;
33488 }
33489 {
33490 if (temp4)
33491 delete arg4;
33492 }
33493 return resultobj;
33494 fail:
33495 {
33496 if (temp3)
33497 delete arg3;
33498 }
33499 {
33500 if (temp4)
33501 delete arg4;
33502 }
33503 return NULL;
33504 }
33505
33506
33507 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33508 PyObject *resultobj;
33509 wxMenu *arg1 = (wxMenu *) 0 ;
33510 int arg2 ;
33511 wxString *arg3 = 0 ;
33512 wxMenu *arg4 = (wxMenu *) 0 ;
33513 wxString const &arg5_defvalue = wxPyEmptyString ;
33514 wxString *arg5 = (wxString *) &arg5_defvalue ;
33515 wxMenuItem *result;
33516 bool temp3 = false ;
33517 bool temp5 = false ;
33518 PyObject * obj0 = 0 ;
33519 PyObject * obj1 = 0 ;
33520 PyObject * obj2 = 0 ;
33521 PyObject * obj3 = 0 ;
33522 PyObject * obj4 = 0 ;
33523 char *kwnames[] = {
33524 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33525 };
33526
33527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33529 if (SWIG_arg_fail(1)) SWIG_fail;
33530 {
33531 arg2 = (int)(SWIG_As_int(obj1));
33532 if (SWIG_arg_fail(2)) SWIG_fail;
33533 }
33534 {
33535 arg3 = wxString_in_helper(obj2);
33536 if (arg3 == NULL) SWIG_fail;
33537 temp3 = true;
33538 }
33539 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33540 if (SWIG_arg_fail(4)) SWIG_fail;
33541 if (obj4) {
33542 {
33543 arg5 = wxString_in_helper(obj4);
33544 if (arg5 == NULL) SWIG_fail;
33545 temp5 = true;
33546 }
33547 }
33548 {
33549 PyThreadState* __tstate = wxPyBeginAllowThreads();
33550 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33551
33552 wxPyEndAllowThreads(__tstate);
33553 if (PyErr_Occurred()) SWIG_fail;
33554 }
33555 {
33556 resultobj = wxPyMake_wxObject(result, 0);
33557 }
33558 {
33559 if (temp3)
33560 delete arg3;
33561 }
33562 {
33563 if (temp5)
33564 delete arg5;
33565 }
33566 return resultobj;
33567 fail:
33568 {
33569 if (temp3)
33570 delete arg3;
33571 }
33572 {
33573 if (temp5)
33574 delete arg5;
33575 }
33576 return NULL;
33577 }
33578
33579
33580 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33581 PyObject *resultobj;
33582 wxMenu *arg1 = (wxMenu *) 0 ;
33583 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33584 wxMenuItem *result;
33585 PyObject * obj0 = 0 ;
33586 PyObject * obj1 = 0 ;
33587 char *kwnames[] = {
33588 (char *) "self",(char *) "item", NULL
33589 };
33590
33591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33593 if (SWIG_arg_fail(1)) SWIG_fail;
33594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33595 if (SWIG_arg_fail(2)) SWIG_fail;
33596 {
33597 PyThreadState* __tstate = wxPyBeginAllowThreads();
33598 result = (wxMenuItem *)(arg1)->Append(arg2);
33599
33600 wxPyEndAllowThreads(__tstate);
33601 if (PyErr_Occurred()) SWIG_fail;
33602 }
33603 {
33604 resultobj = wxPyMake_wxObject(result, 0);
33605 }
33606 return resultobj;
33607 fail:
33608 return NULL;
33609 }
33610
33611
33612 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33613 PyObject *resultobj;
33614 wxMenu *arg1 = (wxMenu *) 0 ;
33615 PyObject * obj0 = 0 ;
33616 char *kwnames[] = {
33617 (char *) "self", NULL
33618 };
33619
33620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33622 if (SWIG_arg_fail(1)) SWIG_fail;
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 (arg1)->Break();
33626
33627 wxPyEndAllowThreads(__tstate);
33628 if (PyErr_Occurred()) SWIG_fail;
33629 }
33630 Py_INCREF(Py_None); resultobj = Py_None;
33631 return resultobj;
33632 fail:
33633 return NULL;
33634 }
33635
33636
33637 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33638 PyObject *resultobj;
33639 wxMenu *arg1 = (wxMenu *) 0 ;
33640 size_t arg2 ;
33641 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33642 wxMenuItem *result;
33643 PyObject * obj0 = 0 ;
33644 PyObject * obj1 = 0 ;
33645 PyObject * obj2 = 0 ;
33646 char *kwnames[] = {
33647 (char *) "self",(char *) "pos",(char *) "item", NULL
33648 };
33649
33650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33652 if (SWIG_arg_fail(1)) SWIG_fail;
33653 {
33654 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33655 if (SWIG_arg_fail(2)) SWIG_fail;
33656 }
33657 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33658 if (SWIG_arg_fail(3)) SWIG_fail;
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33662
33663 wxPyEndAllowThreads(__tstate);
33664 if (PyErr_Occurred()) SWIG_fail;
33665 }
33666 {
33667 resultobj = wxPyMake_wxObject(result, 0);
33668 }
33669 return resultobj;
33670 fail:
33671 return NULL;
33672 }
33673
33674
33675 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33676 PyObject *resultobj;
33677 wxMenu *arg1 = (wxMenu *) 0 ;
33678 size_t arg2 ;
33679 int arg3 ;
33680 wxString *arg4 = 0 ;
33681 wxString const &arg5_defvalue = wxPyEmptyString ;
33682 wxString *arg5 = (wxString *) &arg5_defvalue ;
33683 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33684 wxMenuItem *result;
33685 bool temp4 = false ;
33686 bool temp5 = false ;
33687 PyObject * obj0 = 0 ;
33688 PyObject * obj1 = 0 ;
33689 PyObject * obj2 = 0 ;
33690 PyObject * obj3 = 0 ;
33691 PyObject * obj4 = 0 ;
33692 PyObject * obj5 = 0 ;
33693 char *kwnames[] = {
33694 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33695 };
33696
33697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33699 if (SWIG_arg_fail(1)) SWIG_fail;
33700 {
33701 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33702 if (SWIG_arg_fail(2)) SWIG_fail;
33703 }
33704 {
33705 arg3 = (int)(SWIG_As_int(obj2));
33706 if (SWIG_arg_fail(3)) SWIG_fail;
33707 }
33708 {
33709 arg4 = wxString_in_helper(obj3);
33710 if (arg4 == NULL) SWIG_fail;
33711 temp4 = true;
33712 }
33713 if (obj4) {
33714 {
33715 arg5 = wxString_in_helper(obj4);
33716 if (arg5 == NULL) SWIG_fail;
33717 temp5 = true;
33718 }
33719 }
33720 if (obj5) {
33721 {
33722 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33723 if (SWIG_arg_fail(6)) SWIG_fail;
33724 }
33725 }
33726 {
33727 PyThreadState* __tstate = wxPyBeginAllowThreads();
33728 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33729
33730 wxPyEndAllowThreads(__tstate);
33731 if (PyErr_Occurred()) SWIG_fail;
33732 }
33733 {
33734 resultobj = wxPyMake_wxObject(result, 0);
33735 }
33736 {
33737 if (temp4)
33738 delete arg4;
33739 }
33740 {
33741 if (temp5)
33742 delete arg5;
33743 }
33744 return resultobj;
33745 fail:
33746 {
33747 if (temp4)
33748 delete arg4;
33749 }
33750 {
33751 if (temp5)
33752 delete arg5;
33753 }
33754 return NULL;
33755 }
33756
33757
33758 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33759 PyObject *resultobj;
33760 wxMenu *arg1 = (wxMenu *) 0 ;
33761 size_t arg2 ;
33762 wxMenuItem *result;
33763 PyObject * obj0 = 0 ;
33764 PyObject * obj1 = 0 ;
33765 char *kwnames[] = {
33766 (char *) "self",(char *) "pos", NULL
33767 };
33768
33769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33771 if (SWIG_arg_fail(1)) SWIG_fail;
33772 {
33773 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33774 if (SWIG_arg_fail(2)) SWIG_fail;
33775 }
33776 {
33777 PyThreadState* __tstate = wxPyBeginAllowThreads();
33778 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33779
33780 wxPyEndAllowThreads(__tstate);
33781 if (PyErr_Occurred()) SWIG_fail;
33782 }
33783 {
33784 resultobj = wxPyMake_wxObject(result, 0);
33785 }
33786 return resultobj;
33787 fail:
33788 return NULL;
33789 }
33790
33791
33792 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33793 PyObject *resultobj;
33794 wxMenu *arg1 = (wxMenu *) 0 ;
33795 size_t arg2 ;
33796 int arg3 ;
33797 wxString *arg4 = 0 ;
33798 wxString const &arg5_defvalue = wxPyEmptyString ;
33799 wxString *arg5 = (wxString *) &arg5_defvalue ;
33800 wxMenuItem *result;
33801 bool temp4 = false ;
33802 bool temp5 = false ;
33803 PyObject * obj0 = 0 ;
33804 PyObject * obj1 = 0 ;
33805 PyObject * obj2 = 0 ;
33806 PyObject * obj3 = 0 ;
33807 PyObject * obj4 = 0 ;
33808 char *kwnames[] = {
33809 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33810 };
33811
33812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33814 if (SWIG_arg_fail(1)) SWIG_fail;
33815 {
33816 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33817 if (SWIG_arg_fail(2)) SWIG_fail;
33818 }
33819 {
33820 arg3 = (int)(SWIG_As_int(obj2));
33821 if (SWIG_arg_fail(3)) SWIG_fail;
33822 }
33823 {
33824 arg4 = wxString_in_helper(obj3);
33825 if (arg4 == NULL) SWIG_fail;
33826 temp4 = true;
33827 }
33828 if (obj4) {
33829 {
33830 arg5 = wxString_in_helper(obj4);
33831 if (arg5 == NULL) SWIG_fail;
33832 temp5 = true;
33833 }
33834 }
33835 {
33836 PyThreadState* __tstate = wxPyBeginAllowThreads();
33837 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33838
33839 wxPyEndAllowThreads(__tstate);
33840 if (PyErr_Occurred()) SWIG_fail;
33841 }
33842 {
33843 resultobj = wxPyMake_wxObject(result, 0);
33844 }
33845 {
33846 if (temp4)
33847 delete arg4;
33848 }
33849 {
33850 if (temp5)
33851 delete arg5;
33852 }
33853 return resultobj;
33854 fail:
33855 {
33856 if (temp4)
33857 delete arg4;
33858 }
33859 {
33860 if (temp5)
33861 delete arg5;
33862 }
33863 return NULL;
33864 }
33865
33866
33867 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33868 PyObject *resultobj;
33869 wxMenu *arg1 = (wxMenu *) 0 ;
33870 size_t arg2 ;
33871 int arg3 ;
33872 wxString *arg4 = 0 ;
33873 wxString const &arg5_defvalue = wxPyEmptyString ;
33874 wxString *arg5 = (wxString *) &arg5_defvalue ;
33875 wxMenuItem *result;
33876 bool temp4 = false ;
33877 bool temp5 = false ;
33878 PyObject * obj0 = 0 ;
33879 PyObject * obj1 = 0 ;
33880 PyObject * obj2 = 0 ;
33881 PyObject * obj3 = 0 ;
33882 PyObject * obj4 = 0 ;
33883 char *kwnames[] = {
33884 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33885 };
33886
33887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33889 if (SWIG_arg_fail(1)) SWIG_fail;
33890 {
33891 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33892 if (SWIG_arg_fail(2)) SWIG_fail;
33893 }
33894 {
33895 arg3 = (int)(SWIG_As_int(obj2));
33896 if (SWIG_arg_fail(3)) SWIG_fail;
33897 }
33898 {
33899 arg4 = wxString_in_helper(obj3);
33900 if (arg4 == NULL) SWIG_fail;
33901 temp4 = true;
33902 }
33903 if (obj4) {
33904 {
33905 arg5 = wxString_in_helper(obj4);
33906 if (arg5 == NULL) SWIG_fail;
33907 temp5 = true;
33908 }
33909 }
33910 {
33911 PyThreadState* __tstate = wxPyBeginAllowThreads();
33912 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33913
33914 wxPyEndAllowThreads(__tstate);
33915 if (PyErr_Occurred()) SWIG_fail;
33916 }
33917 {
33918 resultobj = wxPyMake_wxObject(result, 0);
33919 }
33920 {
33921 if (temp4)
33922 delete arg4;
33923 }
33924 {
33925 if (temp5)
33926 delete arg5;
33927 }
33928 return resultobj;
33929 fail:
33930 {
33931 if (temp4)
33932 delete arg4;
33933 }
33934 {
33935 if (temp5)
33936 delete arg5;
33937 }
33938 return NULL;
33939 }
33940
33941
33942 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33943 PyObject *resultobj;
33944 wxMenu *arg1 = (wxMenu *) 0 ;
33945 size_t arg2 ;
33946 int arg3 ;
33947 wxString *arg4 = 0 ;
33948 wxMenu *arg5 = (wxMenu *) 0 ;
33949 wxString const &arg6_defvalue = wxPyEmptyString ;
33950 wxString *arg6 = (wxString *) &arg6_defvalue ;
33951 wxMenuItem *result;
33952 bool temp4 = false ;
33953 bool temp6 = false ;
33954 PyObject * obj0 = 0 ;
33955 PyObject * obj1 = 0 ;
33956 PyObject * obj2 = 0 ;
33957 PyObject * obj3 = 0 ;
33958 PyObject * obj4 = 0 ;
33959 PyObject * obj5 = 0 ;
33960 char *kwnames[] = {
33961 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33962 };
33963
33964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33966 if (SWIG_arg_fail(1)) SWIG_fail;
33967 {
33968 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33969 if (SWIG_arg_fail(2)) SWIG_fail;
33970 }
33971 {
33972 arg3 = (int)(SWIG_As_int(obj2));
33973 if (SWIG_arg_fail(3)) SWIG_fail;
33974 }
33975 {
33976 arg4 = wxString_in_helper(obj3);
33977 if (arg4 == NULL) SWIG_fail;
33978 temp4 = true;
33979 }
33980 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33981 if (SWIG_arg_fail(5)) SWIG_fail;
33982 if (obj5) {
33983 {
33984 arg6 = wxString_in_helper(obj5);
33985 if (arg6 == NULL) SWIG_fail;
33986 temp6 = true;
33987 }
33988 }
33989 {
33990 PyThreadState* __tstate = wxPyBeginAllowThreads();
33991 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33992
33993 wxPyEndAllowThreads(__tstate);
33994 if (PyErr_Occurred()) SWIG_fail;
33995 }
33996 {
33997 resultobj = wxPyMake_wxObject(result, 0);
33998 }
33999 {
34000 if (temp4)
34001 delete arg4;
34002 }
34003 {
34004 if (temp6)
34005 delete arg6;
34006 }
34007 return resultobj;
34008 fail:
34009 {
34010 if (temp4)
34011 delete arg4;
34012 }
34013 {
34014 if (temp6)
34015 delete arg6;
34016 }
34017 return NULL;
34018 }
34019
34020
34021 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34022 PyObject *resultobj;
34023 wxMenu *arg1 = (wxMenu *) 0 ;
34024 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34025 wxMenuItem *result;
34026 PyObject * obj0 = 0 ;
34027 PyObject * obj1 = 0 ;
34028 char *kwnames[] = {
34029 (char *) "self",(char *) "item", NULL
34030 };
34031
34032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34034 if (SWIG_arg_fail(1)) SWIG_fail;
34035 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34036 if (SWIG_arg_fail(2)) SWIG_fail;
34037 {
34038 PyThreadState* __tstate = wxPyBeginAllowThreads();
34039 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34040
34041 wxPyEndAllowThreads(__tstate);
34042 if (PyErr_Occurred()) SWIG_fail;
34043 }
34044 {
34045 resultobj = wxPyMake_wxObject(result, 0);
34046 }
34047 return resultobj;
34048 fail:
34049 return NULL;
34050 }
34051
34052
34053 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34054 PyObject *resultobj;
34055 wxMenu *arg1 = (wxMenu *) 0 ;
34056 int arg2 ;
34057 wxString *arg3 = 0 ;
34058 wxString const &arg4_defvalue = wxPyEmptyString ;
34059 wxString *arg4 = (wxString *) &arg4_defvalue ;
34060 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34061 wxMenuItem *result;
34062 bool temp3 = false ;
34063 bool temp4 = false ;
34064 PyObject * obj0 = 0 ;
34065 PyObject * obj1 = 0 ;
34066 PyObject * obj2 = 0 ;
34067 PyObject * obj3 = 0 ;
34068 PyObject * obj4 = 0 ;
34069 char *kwnames[] = {
34070 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34071 };
34072
34073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34075 if (SWIG_arg_fail(1)) SWIG_fail;
34076 {
34077 arg2 = (int)(SWIG_As_int(obj1));
34078 if (SWIG_arg_fail(2)) SWIG_fail;
34079 }
34080 {
34081 arg3 = wxString_in_helper(obj2);
34082 if (arg3 == NULL) SWIG_fail;
34083 temp3 = true;
34084 }
34085 if (obj3) {
34086 {
34087 arg4 = wxString_in_helper(obj3);
34088 if (arg4 == NULL) SWIG_fail;
34089 temp4 = true;
34090 }
34091 }
34092 if (obj4) {
34093 {
34094 arg5 = (wxItemKind)(SWIG_As_int(obj4));
34095 if (SWIG_arg_fail(5)) SWIG_fail;
34096 }
34097 }
34098 {
34099 PyThreadState* __tstate = wxPyBeginAllowThreads();
34100 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
34101
34102 wxPyEndAllowThreads(__tstate);
34103 if (PyErr_Occurred()) SWIG_fail;
34104 }
34105 {
34106 resultobj = wxPyMake_wxObject(result, 0);
34107 }
34108 {
34109 if (temp3)
34110 delete arg3;
34111 }
34112 {
34113 if (temp4)
34114 delete arg4;
34115 }
34116 return resultobj;
34117 fail:
34118 {
34119 if (temp3)
34120 delete arg3;
34121 }
34122 {
34123 if (temp4)
34124 delete arg4;
34125 }
34126 return NULL;
34127 }
34128
34129
34130 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34131 PyObject *resultobj;
34132 wxMenu *arg1 = (wxMenu *) 0 ;
34133 wxMenuItem *result;
34134 PyObject * obj0 = 0 ;
34135 char *kwnames[] = {
34136 (char *) "self", NULL
34137 };
34138
34139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34141 if (SWIG_arg_fail(1)) SWIG_fail;
34142 {
34143 PyThreadState* __tstate = wxPyBeginAllowThreads();
34144 result = (wxMenuItem *)(arg1)->PrependSeparator();
34145
34146 wxPyEndAllowThreads(__tstate);
34147 if (PyErr_Occurred()) SWIG_fail;
34148 }
34149 {
34150 resultobj = wxPyMake_wxObject(result, 0);
34151 }
34152 return resultobj;
34153 fail:
34154 return NULL;
34155 }
34156
34157
34158 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34159 PyObject *resultobj;
34160 wxMenu *arg1 = (wxMenu *) 0 ;
34161 int arg2 ;
34162 wxString *arg3 = 0 ;
34163 wxString const &arg4_defvalue = wxPyEmptyString ;
34164 wxString *arg4 = (wxString *) &arg4_defvalue ;
34165 wxMenuItem *result;
34166 bool temp3 = false ;
34167 bool temp4 = false ;
34168 PyObject * obj0 = 0 ;
34169 PyObject * obj1 = 0 ;
34170 PyObject * obj2 = 0 ;
34171 PyObject * obj3 = 0 ;
34172 char *kwnames[] = {
34173 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34174 };
34175
34176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34178 if (SWIG_arg_fail(1)) SWIG_fail;
34179 {
34180 arg2 = (int)(SWIG_As_int(obj1));
34181 if (SWIG_arg_fail(2)) SWIG_fail;
34182 }
34183 {
34184 arg3 = wxString_in_helper(obj2);
34185 if (arg3 == NULL) SWIG_fail;
34186 temp3 = true;
34187 }
34188 if (obj3) {
34189 {
34190 arg4 = wxString_in_helper(obj3);
34191 if (arg4 == NULL) SWIG_fail;
34192 temp4 = true;
34193 }
34194 }
34195 {
34196 PyThreadState* __tstate = wxPyBeginAllowThreads();
34197 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34198
34199 wxPyEndAllowThreads(__tstate);
34200 if (PyErr_Occurred()) SWIG_fail;
34201 }
34202 {
34203 resultobj = wxPyMake_wxObject(result, 0);
34204 }
34205 {
34206 if (temp3)
34207 delete arg3;
34208 }
34209 {
34210 if (temp4)
34211 delete arg4;
34212 }
34213 return resultobj;
34214 fail:
34215 {
34216 if (temp3)
34217 delete arg3;
34218 }
34219 {
34220 if (temp4)
34221 delete arg4;
34222 }
34223 return NULL;
34224 }
34225
34226
34227 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34228 PyObject *resultobj;
34229 wxMenu *arg1 = (wxMenu *) 0 ;
34230 int arg2 ;
34231 wxString *arg3 = 0 ;
34232 wxString const &arg4_defvalue = wxPyEmptyString ;
34233 wxString *arg4 = (wxString *) &arg4_defvalue ;
34234 wxMenuItem *result;
34235 bool temp3 = false ;
34236 bool temp4 = false ;
34237 PyObject * obj0 = 0 ;
34238 PyObject * obj1 = 0 ;
34239 PyObject * obj2 = 0 ;
34240 PyObject * obj3 = 0 ;
34241 char *kwnames[] = {
34242 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34243 };
34244
34245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34247 if (SWIG_arg_fail(1)) SWIG_fail;
34248 {
34249 arg2 = (int)(SWIG_As_int(obj1));
34250 if (SWIG_arg_fail(2)) SWIG_fail;
34251 }
34252 {
34253 arg3 = wxString_in_helper(obj2);
34254 if (arg3 == NULL) SWIG_fail;
34255 temp3 = true;
34256 }
34257 if (obj3) {
34258 {
34259 arg4 = wxString_in_helper(obj3);
34260 if (arg4 == NULL) SWIG_fail;
34261 temp4 = true;
34262 }
34263 }
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34267
34268 wxPyEndAllowThreads(__tstate);
34269 if (PyErr_Occurred()) SWIG_fail;
34270 }
34271 {
34272 resultobj = wxPyMake_wxObject(result, 0);
34273 }
34274 {
34275 if (temp3)
34276 delete arg3;
34277 }
34278 {
34279 if (temp4)
34280 delete arg4;
34281 }
34282 return resultobj;
34283 fail:
34284 {
34285 if (temp3)
34286 delete arg3;
34287 }
34288 {
34289 if (temp4)
34290 delete arg4;
34291 }
34292 return NULL;
34293 }
34294
34295
34296 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34297 PyObject *resultobj;
34298 wxMenu *arg1 = (wxMenu *) 0 ;
34299 int arg2 ;
34300 wxString *arg3 = 0 ;
34301 wxMenu *arg4 = (wxMenu *) 0 ;
34302 wxString const &arg5_defvalue = wxPyEmptyString ;
34303 wxString *arg5 = (wxString *) &arg5_defvalue ;
34304 wxMenuItem *result;
34305 bool temp3 = false ;
34306 bool temp5 = false ;
34307 PyObject * obj0 = 0 ;
34308 PyObject * obj1 = 0 ;
34309 PyObject * obj2 = 0 ;
34310 PyObject * obj3 = 0 ;
34311 PyObject * obj4 = 0 ;
34312 char *kwnames[] = {
34313 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34314 };
34315
34316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34318 if (SWIG_arg_fail(1)) SWIG_fail;
34319 {
34320 arg2 = (int)(SWIG_As_int(obj1));
34321 if (SWIG_arg_fail(2)) SWIG_fail;
34322 }
34323 {
34324 arg3 = wxString_in_helper(obj2);
34325 if (arg3 == NULL) SWIG_fail;
34326 temp3 = true;
34327 }
34328 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34329 if (SWIG_arg_fail(4)) SWIG_fail;
34330 if (obj4) {
34331 {
34332 arg5 = wxString_in_helper(obj4);
34333 if (arg5 == NULL) SWIG_fail;
34334 temp5 = true;
34335 }
34336 }
34337 {
34338 PyThreadState* __tstate = wxPyBeginAllowThreads();
34339 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34340
34341 wxPyEndAllowThreads(__tstate);
34342 if (PyErr_Occurred()) SWIG_fail;
34343 }
34344 {
34345 resultobj = wxPyMake_wxObject(result, 0);
34346 }
34347 {
34348 if (temp3)
34349 delete arg3;
34350 }
34351 {
34352 if (temp5)
34353 delete arg5;
34354 }
34355 return resultobj;
34356 fail:
34357 {
34358 if (temp3)
34359 delete arg3;
34360 }
34361 {
34362 if (temp5)
34363 delete arg5;
34364 }
34365 return NULL;
34366 }
34367
34368
34369 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34370 PyObject *resultobj;
34371 wxMenu *arg1 = (wxMenu *) 0 ;
34372 int arg2 ;
34373 wxMenuItem *result;
34374 PyObject * obj0 = 0 ;
34375 PyObject * obj1 = 0 ;
34376 char *kwnames[] = {
34377 (char *) "self",(char *) "id", NULL
34378 };
34379
34380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34382 if (SWIG_arg_fail(1)) SWIG_fail;
34383 {
34384 arg2 = (int)(SWIG_As_int(obj1));
34385 if (SWIG_arg_fail(2)) SWIG_fail;
34386 }
34387 {
34388 PyThreadState* __tstate = wxPyBeginAllowThreads();
34389 result = (wxMenuItem *)(arg1)->Remove(arg2);
34390
34391 wxPyEndAllowThreads(__tstate);
34392 if (PyErr_Occurred()) SWIG_fail;
34393 }
34394 {
34395 resultobj = wxPyMake_wxObject(result, 0);
34396 }
34397 return resultobj;
34398 fail:
34399 return NULL;
34400 }
34401
34402
34403 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34404 PyObject *resultobj;
34405 wxMenu *arg1 = (wxMenu *) 0 ;
34406 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34407 wxMenuItem *result;
34408 PyObject * obj0 = 0 ;
34409 PyObject * obj1 = 0 ;
34410 char *kwnames[] = {
34411 (char *) "self",(char *) "item", NULL
34412 };
34413
34414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34416 if (SWIG_arg_fail(1)) SWIG_fail;
34417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34418 if (SWIG_arg_fail(2)) SWIG_fail;
34419 {
34420 PyThreadState* __tstate = wxPyBeginAllowThreads();
34421 result = (wxMenuItem *)(arg1)->Remove(arg2);
34422
34423 wxPyEndAllowThreads(__tstate);
34424 if (PyErr_Occurred()) SWIG_fail;
34425 }
34426 {
34427 resultobj = wxPyMake_wxObject(result, 0);
34428 }
34429 return resultobj;
34430 fail:
34431 return NULL;
34432 }
34433
34434
34435 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34436 PyObject *resultobj;
34437 wxMenu *arg1 = (wxMenu *) 0 ;
34438 int arg2 ;
34439 bool result;
34440 PyObject * obj0 = 0 ;
34441 PyObject * obj1 = 0 ;
34442 char *kwnames[] = {
34443 (char *) "self",(char *) "id", NULL
34444 };
34445
34446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34448 if (SWIG_arg_fail(1)) SWIG_fail;
34449 {
34450 arg2 = (int)(SWIG_As_int(obj1));
34451 if (SWIG_arg_fail(2)) SWIG_fail;
34452 }
34453 {
34454 PyThreadState* __tstate = wxPyBeginAllowThreads();
34455 result = (bool)(arg1)->Delete(arg2);
34456
34457 wxPyEndAllowThreads(__tstate);
34458 if (PyErr_Occurred()) SWIG_fail;
34459 }
34460 {
34461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34462 }
34463 return resultobj;
34464 fail:
34465 return NULL;
34466 }
34467
34468
34469 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34470 PyObject *resultobj;
34471 wxMenu *arg1 = (wxMenu *) 0 ;
34472 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34473 bool result;
34474 PyObject * obj0 = 0 ;
34475 PyObject * obj1 = 0 ;
34476 char *kwnames[] = {
34477 (char *) "self",(char *) "item", NULL
34478 };
34479
34480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34482 if (SWIG_arg_fail(1)) SWIG_fail;
34483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34484 if (SWIG_arg_fail(2)) SWIG_fail;
34485 {
34486 PyThreadState* __tstate = wxPyBeginAllowThreads();
34487 result = (bool)(arg1)->Delete(arg2);
34488
34489 wxPyEndAllowThreads(__tstate);
34490 if (PyErr_Occurred()) SWIG_fail;
34491 }
34492 {
34493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34494 }
34495 return resultobj;
34496 fail:
34497 return NULL;
34498 }
34499
34500
34501 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34502 PyObject *resultobj;
34503 wxMenu *arg1 = (wxMenu *) 0 ;
34504 PyObject * obj0 = 0 ;
34505 char *kwnames[] = {
34506 (char *) "self", NULL
34507 };
34508
34509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34511 if (SWIG_arg_fail(1)) SWIG_fail;
34512 {
34513 PyThreadState* __tstate = wxPyBeginAllowThreads();
34514 wxMenu_Destroy(arg1);
34515
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 Py_INCREF(Py_None); resultobj = Py_None;
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34527 PyObject *resultobj;
34528 wxMenu *arg1 = (wxMenu *) 0 ;
34529 int arg2 ;
34530 bool result;
34531 PyObject * obj0 = 0 ;
34532 PyObject * obj1 = 0 ;
34533 char *kwnames[] = {
34534 (char *) "self",(char *) "id", NULL
34535 };
34536
34537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34539 if (SWIG_arg_fail(1)) SWIG_fail;
34540 {
34541 arg2 = (int)(SWIG_As_int(obj1));
34542 if (SWIG_arg_fail(2)) SWIG_fail;
34543 }
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 result = (bool)(arg1)->Destroy(arg2);
34547
34548 wxPyEndAllowThreads(__tstate);
34549 if (PyErr_Occurred()) SWIG_fail;
34550 }
34551 {
34552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34553 }
34554 return resultobj;
34555 fail:
34556 return NULL;
34557 }
34558
34559
34560 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34561 PyObject *resultobj;
34562 wxMenu *arg1 = (wxMenu *) 0 ;
34563 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34564 bool result;
34565 PyObject * obj0 = 0 ;
34566 PyObject * obj1 = 0 ;
34567 char *kwnames[] = {
34568 (char *) "self",(char *) "item", NULL
34569 };
34570
34571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34573 if (SWIG_arg_fail(1)) SWIG_fail;
34574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34575 if (SWIG_arg_fail(2)) SWIG_fail;
34576 {
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 result = (bool)(arg1)->Destroy(arg2);
34579
34580 wxPyEndAllowThreads(__tstate);
34581 if (PyErr_Occurred()) SWIG_fail;
34582 }
34583 {
34584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34585 }
34586 return resultobj;
34587 fail:
34588 return NULL;
34589 }
34590
34591
34592 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34593 PyObject *resultobj;
34594 wxMenu *arg1 = (wxMenu *) 0 ;
34595 size_t result;
34596 PyObject * obj0 = 0 ;
34597 char *kwnames[] = {
34598 (char *) "self", NULL
34599 };
34600
34601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34603 if (SWIG_arg_fail(1)) SWIG_fail;
34604 {
34605 PyThreadState* __tstate = wxPyBeginAllowThreads();
34606 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34607
34608 wxPyEndAllowThreads(__tstate);
34609 if (PyErr_Occurred()) SWIG_fail;
34610 }
34611 {
34612 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34613 }
34614 return resultobj;
34615 fail:
34616 return NULL;
34617 }
34618
34619
34620 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34621 PyObject *resultobj;
34622 wxMenu *arg1 = (wxMenu *) 0 ;
34623 PyObject *result;
34624 PyObject * obj0 = 0 ;
34625 char *kwnames[] = {
34626 (char *) "self", NULL
34627 };
34628
34629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34631 if (SWIG_arg_fail(1)) SWIG_fail;
34632 {
34633 PyThreadState* __tstate = wxPyBeginAllowThreads();
34634 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34635
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 resultobj = result;
34640 return resultobj;
34641 fail:
34642 return NULL;
34643 }
34644
34645
34646 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34647 PyObject *resultobj;
34648 wxMenu *arg1 = (wxMenu *) 0 ;
34649 wxString *arg2 = 0 ;
34650 int result;
34651 bool temp2 = false ;
34652 PyObject * obj0 = 0 ;
34653 PyObject * obj1 = 0 ;
34654 char *kwnames[] = {
34655 (char *) "self",(char *) "item", NULL
34656 };
34657
34658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34660 if (SWIG_arg_fail(1)) SWIG_fail;
34661 {
34662 arg2 = wxString_in_helper(obj1);
34663 if (arg2 == NULL) SWIG_fail;
34664 temp2 = true;
34665 }
34666 {
34667 PyThreadState* __tstate = wxPyBeginAllowThreads();
34668 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34669
34670 wxPyEndAllowThreads(__tstate);
34671 if (PyErr_Occurred()) SWIG_fail;
34672 }
34673 {
34674 resultobj = SWIG_From_int((int)(result));
34675 }
34676 {
34677 if (temp2)
34678 delete arg2;
34679 }
34680 return resultobj;
34681 fail:
34682 {
34683 if (temp2)
34684 delete arg2;
34685 }
34686 return NULL;
34687 }
34688
34689
34690 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34691 PyObject *resultobj;
34692 wxMenu *arg1 = (wxMenu *) 0 ;
34693 int arg2 ;
34694 wxMenuItem *result;
34695 PyObject * obj0 = 0 ;
34696 PyObject * obj1 = 0 ;
34697 char *kwnames[] = {
34698 (char *) "self",(char *) "id", NULL
34699 };
34700
34701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34703 if (SWIG_arg_fail(1)) SWIG_fail;
34704 {
34705 arg2 = (int)(SWIG_As_int(obj1));
34706 if (SWIG_arg_fail(2)) SWIG_fail;
34707 }
34708 {
34709 PyThreadState* __tstate = wxPyBeginAllowThreads();
34710 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34711
34712 wxPyEndAllowThreads(__tstate);
34713 if (PyErr_Occurred()) SWIG_fail;
34714 }
34715 {
34716 resultobj = wxPyMake_wxObject(result, 0);
34717 }
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34725 PyObject *resultobj;
34726 wxMenu *arg1 = (wxMenu *) 0 ;
34727 size_t arg2 ;
34728 wxMenuItem *result;
34729 PyObject * obj0 = 0 ;
34730 PyObject * obj1 = 0 ;
34731 char *kwnames[] = {
34732 (char *) "self",(char *) "position", NULL
34733 };
34734
34735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34737 if (SWIG_arg_fail(1)) SWIG_fail;
34738 {
34739 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34740 if (SWIG_arg_fail(2)) SWIG_fail;
34741 }
34742 {
34743 PyThreadState* __tstate = wxPyBeginAllowThreads();
34744 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34745
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 {
34750 resultobj = wxPyMake_wxObject(result, 0);
34751 }
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34759 PyObject *resultobj;
34760 wxMenu *arg1 = (wxMenu *) 0 ;
34761 int arg2 ;
34762 bool arg3 ;
34763 PyObject * obj0 = 0 ;
34764 PyObject * obj1 = 0 ;
34765 PyObject * obj2 = 0 ;
34766 char *kwnames[] = {
34767 (char *) "self",(char *) "id",(char *) "enable", NULL
34768 };
34769
34770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34772 if (SWIG_arg_fail(1)) SWIG_fail;
34773 {
34774 arg2 = (int)(SWIG_As_int(obj1));
34775 if (SWIG_arg_fail(2)) SWIG_fail;
34776 }
34777 {
34778 arg3 = (bool)(SWIG_As_bool(obj2));
34779 if (SWIG_arg_fail(3)) SWIG_fail;
34780 }
34781 {
34782 PyThreadState* __tstate = wxPyBeginAllowThreads();
34783 (arg1)->Enable(arg2,arg3);
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_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34796 PyObject *resultobj;
34797 wxMenu *arg1 = (wxMenu *) 0 ;
34798 int arg2 ;
34799 bool result;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 char *kwnames[] = {
34803 (char *) "self",(char *) "id", NULL
34804 };
34805
34806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34808 if (SWIG_arg_fail(1)) SWIG_fail;
34809 {
34810 arg2 = (int)(SWIG_As_int(obj1));
34811 if (SWIG_arg_fail(2)) SWIG_fail;
34812 }
34813 {
34814 PyThreadState* __tstate = wxPyBeginAllowThreads();
34815 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34816
34817 wxPyEndAllowThreads(__tstate);
34818 if (PyErr_Occurred()) SWIG_fail;
34819 }
34820 {
34821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34822 }
34823 return resultobj;
34824 fail:
34825 return NULL;
34826 }
34827
34828
34829 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34830 PyObject *resultobj;
34831 wxMenu *arg1 = (wxMenu *) 0 ;
34832 int arg2 ;
34833 bool arg3 ;
34834 PyObject * obj0 = 0 ;
34835 PyObject * obj1 = 0 ;
34836 PyObject * obj2 = 0 ;
34837 char *kwnames[] = {
34838 (char *) "self",(char *) "id",(char *) "check", NULL
34839 };
34840
34841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34843 if (SWIG_arg_fail(1)) SWIG_fail;
34844 {
34845 arg2 = (int)(SWIG_As_int(obj1));
34846 if (SWIG_arg_fail(2)) SWIG_fail;
34847 }
34848 {
34849 arg3 = (bool)(SWIG_As_bool(obj2));
34850 if (SWIG_arg_fail(3)) SWIG_fail;
34851 }
34852 {
34853 PyThreadState* __tstate = wxPyBeginAllowThreads();
34854 (arg1)->Check(arg2,arg3);
34855
34856 wxPyEndAllowThreads(__tstate);
34857 if (PyErr_Occurred()) SWIG_fail;
34858 }
34859 Py_INCREF(Py_None); resultobj = Py_None;
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34867 PyObject *resultobj;
34868 wxMenu *arg1 = (wxMenu *) 0 ;
34869 int arg2 ;
34870 bool result;
34871 PyObject * obj0 = 0 ;
34872 PyObject * obj1 = 0 ;
34873 char *kwnames[] = {
34874 (char *) "self",(char *) "id", NULL
34875 };
34876
34877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34879 if (SWIG_arg_fail(1)) SWIG_fail;
34880 {
34881 arg2 = (int)(SWIG_As_int(obj1));
34882 if (SWIG_arg_fail(2)) SWIG_fail;
34883 }
34884 {
34885 PyThreadState* __tstate = wxPyBeginAllowThreads();
34886 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34887
34888 wxPyEndAllowThreads(__tstate);
34889 if (PyErr_Occurred()) SWIG_fail;
34890 }
34891 {
34892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34893 }
34894 return resultobj;
34895 fail:
34896 return NULL;
34897 }
34898
34899
34900 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34901 PyObject *resultobj;
34902 wxMenu *arg1 = (wxMenu *) 0 ;
34903 int arg2 ;
34904 wxString *arg3 = 0 ;
34905 bool temp3 = false ;
34906 PyObject * obj0 = 0 ;
34907 PyObject * obj1 = 0 ;
34908 PyObject * obj2 = 0 ;
34909 char *kwnames[] = {
34910 (char *) "self",(char *) "id",(char *) "label", NULL
34911 };
34912
34913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34915 if (SWIG_arg_fail(1)) SWIG_fail;
34916 {
34917 arg2 = (int)(SWIG_As_int(obj1));
34918 if (SWIG_arg_fail(2)) SWIG_fail;
34919 }
34920 {
34921 arg3 = wxString_in_helper(obj2);
34922 if (arg3 == NULL) SWIG_fail;
34923 temp3 = true;
34924 }
34925 {
34926 PyThreadState* __tstate = wxPyBeginAllowThreads();
34927 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34928
34929 wxPyEndAllowThreads(__tstate);
34930 if (PyErr_Occurred()) SWIG_fail;
34931 }
34932 Py_INCREF(Py_None); resultobj = Py_None;
34933 {
34934 if (temp3)
34935 delete arg3;
34936 }
34937 return resultobj;
34938 fail:
34939 {
34940 if (temp3)
34941 delete arg3;
34942 }
34943 return NULL;
34944 }
34945
34946
34947 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34948 PyObject *resultobj;
34949 wxMenu *arg1 = (wxMenu *) 0 ;
34950 int arg2 ;
34951 wxString result;
34952 PyObject * obj0 = 0 ;
34953 PyObject * obj1 = 0 ;
34954 char *kwnames[] = {
34955 (char *) "self",(char *) "id", NULL
34956 };
34957
34958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34960 if (SWIG_arg_fail(1)) SWIG_fail;
34961 {
34962 arg2 = (int)(SWIG_As_int(obj1));
34963 if (SWIG_arg_fail(2)) SWIG_fail;
34964 }
34965 {
34966 PyThreadState* __tstate = wxPyBeginAllowThreads();
34967 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34968
34969 wxPyEndAllowThreads(__tstate);
34970 if (PyErr_Occurred()) SWIG_fail;
34971 }
34972 {
34973 #if wxUSE_UNICODE
34974 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34975 #else
34976 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34977 #endif
34978 }
34979 return resultobj;
34980 fail:
34981 return NULL;
34982 }
34983
34984
34985 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34986 PyObject *resultobj;
34987 wxMenu *arg1 = (wxMenu *) 0 ;
34988 int arg2 ;
34989 wxString *arg3 = 0 ;
34990 bool temp3 = false ;
34991 PyObject * obj0 = 0 ;
34992 PyObject * obj1 = 0 ;
34993 PyObject * obj2 = 0 ;
34994 char *kwnames[] = {
34995 (char *) "self",(char *) "id",(char *) "helpString", NULL
34996 };
34997
34998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35000 if (SWIG_arg_fail(1)) SWIG_fail;
35001 {
35002 arg2 = (int)(SWIG_As_int(obj1));
35003 if (SWIG_arg_fail(2)) SWIG_fail;
35004 }
35005 {
35006 arg3 = wxString_in_helper(obj2);
35007 if (arg3 == NULL) SWIG_fail;
35008 temp3 = true;
35009 }
35010 {
35011 PyThreadState* __tstate = wxPyBeginAllowThreads();
35012 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35013
35014 wxPyEndAllowThreads(__tstate);
35015 if (PyErr_Occurred()) SWIG_fail;
35016 }
35017 Py_INCREF(Py_None); resultobj = Py_None;
35018 {
35019 if (temp3)
35020 delete arg3;
35021 }
35022 return resultobj;
35023 fail:
35024 {
35025 if (temp3)
35026 delete arg3;
35027 }
35028 return NULL;
35029 }
35030
35031
35032 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35033 PyObject *resultobj;
35034 wxMenu *arg1 = (wxMenu *) 0 ;
35035 int arg2 ;
35036 wxString result;
35037 PyObject * obj0 = 0 ;
35038 PyObject * obj1 = 0 ;
35039 char *kwnames[] = {
35040 (char *) "self",(char *) "id", NULL
35041 };
35042
35043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35045 if (SWIG_arg_fail(1)) SWIG_fail;
35046 {
35047 arg2 = (int)(SWIG_As_int(obj1));
35048 if (SWIG_arg_fail(2)) SWIG_fail;
35049 }
35050 {
35051 PyThreadState* __tstate = wxPyBeginAllowThreads();
35052 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35053
35054 wxPyEndAllowThreads(__tstate);
35055 if (PyErr_Occurred()) SWIG_fail;
35056 }
35057 {
35058 #if wxUSE_UNICODE
35059 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35060 #else
35061 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35062 #endif
35063 }
35064 return resultobj;
35065 fail:
35066 return NULL;
35067 }
35068
35069
35070 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35071 PyObject *resultobj;
35072 wxMenu *arg1 = (wxMenu *) 0 ;
35073 wxString *arg2 = 0 ;
35074 bool temp2 = false ;
35075 PyObject * obj0 = 0 ;
35076 PyObject * obj1 = 0 ;
35077 char *kwnames[] = {
35078 (char *) "self",(char *) "title", NULL
35079 };
35080
35081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35083 if (SWIG_arg_fail(1)) SWIG_fail;
35084 {
35085 arg2 = wxString_in_helper(obj1);
35086 if (arg2 == NULL) SWIG_fail;
35087 temp2 = true;
35088 }
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 (arg1)->SetTitle((wxString const &)*arg2);
35092
35093 wxPyEndAllowThreads(__tstate);
35094 if (PyErr_Occurred()) SWIG_fail;
35095 }
35096 Py_INCREF(Py_None); resultobj = Py_None;
35097 {
35098 if (temp2)
35099 delete arg2;
35100 }
35101 return resultobj;
35102 fail:
35103 {
35104 if (temp2)
35105 delete arg2;
35106 }
35107 return NULL;
35108 }
35109
35110
35111 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35112 PyObject *resultobj;
35113 wxMenu *arg1 = (wxMenu *) 0 ;
35114 wxString result;
35115 PyObject * obj0 = 0 ;
35116 char *kwnames[] = {
35117 (char *) "self", NULL
35118 };
35119
35120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35122 if (SWIG_arg_fail(1)) SWIG_fail;
35123 {
35124 PyThreadState* __tstate = wxPyBeginAllowThreads();
35125 result = ((wxMenu const *)arg1)->GetTitle();
35126
35127 wxPyEndAllowThreads(__tstate);
35128 if (PyErr_Occurred()) SWIG_fail;
35129 }
35130 {
35131 #if wxUSE_UNICODE
35132 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35133 #else
35134 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35135 #endif
35136 }
35137 return resultobj;
35138 fail:
35139 return NULL;
35140 }
35141
35142
35143 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35144 PyObject *resultobj;
35145 wxMenu *arg1 = (wxMenu *) 0 ;
35146 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35147 PyObject * obj0 = 0 ;
35148 PyObject * obj1 = 0 ;
35149 char *kwnames[] = {
35150 (char *) "self",(char *) "handler", NULL
35151 };
35152
35153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35155 if (SWIG_arg_fail(1)) SWIG_fail;
35156 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35157 if (SWIG_arg_fail(2)) SWIG_fail;
35158 {
35159 PyThreadState* __tstate = wxPyBeginAllowThreads();
35160 (arg1)->SetEventHandler(arg2);
35161
35162 wxPyEndAllowThreads(__tstate);
35163 if (PyErr_Occurred()) SWIG_fail;
35164 }
35165 Py_INCREF(Py_None); resultobj = Py_None;
35166 return resultobj;
35167 fail:
35168 return NULL;
35169 }
35170
35171
35172 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35173 PyObject *resultobj;
35174 wxMenu *arg1 = (wxMenu *) 0 ;
35175 wxEvtHandler *result;
35176 PyObject * obj0 = 0 ;
35177 char *kwnames[] = {
35178 (char *) "self", NULL
35179 };
35180
35181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35183 if (SWIG_arg_fail(1)) SWIG_fail;
35184 {
35185 PyThreadState* __tstate = wxPyBeginAllowThreads();
35186 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35187
35188 wxPyEndAllowThreads(__tstate);
35189 if (PyErr_Occurred()) SWIG_fail;
35190 }
35191 {
35192 resultobj = wxPyMake_wxObject(result, 0);
35193 }
35194 return resultobj;
35195 fail:
35196 return NULL;
35197 }
35198
35199
35200 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35201 PyObject *resultobj;
35202 wxMenu *arg1 = (wxMenu *) 0 ;
35203 wxWindow *arg2 = (wxWindow *) 0 ;
35204 PyObject * obj0 = 0 ;
35205 PyObject * obj1 = 0 ;
35206 char *kwnames[] = {
35207 (char *) "self",(char *) "win", NULL
35208 };
35209
35210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35212 if (SWIG_arg_fail(1)) SWIG_fail;
35213 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35214 if (SWIG_arg_fail(2)) SWIG_fail;
35215 {
35216 PyThreadState* __tstate = wxPyBeginAllowThreads();
35217 (arg1)->SetInvokingWindow(arg2);
35218
35219 wxPyEndAllowThreads(__tstate);
35220 if (PyErr_Occurred()) SWIG_fail;
35221 }
35222 Py_INCREF(Py_None); resultobj = Py_None;
35223 return resultobj;
35224 fail:
35225 return NULL;
35226 }
35227
35228
35229 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35230 PyObject *resultobj;
35231 wxMenu *arg1 = (wxMenu *) 0 ;
35232 wxWindow *result;
35233 PyObject * obj0 = 0 ;
35234 char *kwnames[] = {
35235 (char *) "self", NULL
35236 };
35237
35238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35240 if (SWIG_arg_fail(1)) SWIG_fail;
35241 {
35242 PyThreadState* __tstate = wxPyBeginAllowThreads();
35243 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35244
35245 wxPyEndAllowThreads(__tstate);
35246 if (PyErr_Occurred()) SWIG_fail;
35247 }
35248 {
35249 resultobj = wxPyMake_wxObject(result, 0);
35250 }
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35258 PyObject *resultobj;
35259 wxMenu *arg1 = (wxMenu *) 0 ;
35260 long result;
35261 PyObject * obj0 = 0 ;
35262 char *kwnames[] = {
35263 (char *) "self", NULL
35264 };
35265
35266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35268 if (SWIG_arg_fail(1)) SWIG_fail;
35269 {
35270 PyThreadState* __tstate = wxPyBeginAllowThreads();
35271 result = (long)((wxMenu const *)arg1)->GetStyle();
35272
35273 wxPyEndAllowThreads(__tstate);
35274 if (PyErr_Occurred()) SWIG_fail;
35275 }
35276 {
35277 resultobj = SWIG_From_long((long)(result));
35278 }
35279 return resultobj;
35280 fail:
35281 return NULL;
35282 }
35283
35284
35285 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35286 PyObject *resultobj;
35287 wxMenu *arg1 = (wxMenu *) 0 ;
35288 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35289 PyObject * obj0 = 0 ;
35290 PyObject * obj1 = 0 ;
35291 char *kwnames[] = {
35292 (char *) "self",(char *) "source", NULL
35293 };
35294
35295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35297 if (SWIG_arg_fail(1)) SWIG_fail;
35298 if (obj1) {
35299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35300 if (SWIG_arg_fail(2)) SWIG_fail;
35301 }
35302 {
35303 PyThreadState* __tstate = wxPyBeginAllowThreads();
35304 (arg1)->UpdateUI(arg2);
35305
35306 wxPyEndAllowThreads(__tstate);
35307 if (PyErr_Occurred()) SWIG_fail;
35308 }
35309 Py_INCREF(Py_None); resultobj = Py_None;
35310 return resultobj;
35311 fail:
35312 return NULL;
35313 }
35314
35315
35316 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35317 PyObject *resultobj;
35318 wxMenu *arg1 = (wxMenu *) 0 ;
35319 wxMenuBar *result;
35320 PyObject * obj0 = 0 ;
35321 char *kwnames[] = {
35322 (char *) "self", NULL
35323 };
35324
35325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35327 if (SWIG_arg_fail(1)) SWIG_fail;
35328 {
35329 PyThreadState* __tstate = wxPyBeginAllowThreads();
35330 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35331
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 {
35336 resultobj = wxPyMake_wxObject(result, 0);
35337 }
35338 return resultobj;
35339 fail:
35340 return NULL;
35341 }
35342
35343
35344 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35345 PyObject *resultobj;
35346 wxMenu *arg1 = (wxMenu *) 0 ;
35347 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35348 PyObject * obj0 = 0 ;
35349 PyObject * obj1 = 0 ;
35350 char *kwnames[] = {
35351 (char *) "self",(char *) "menubar", NULL
35352 };
35353
35354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35356 if (SWIG_arg_fail(1)) SWIG_fail;
35357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35358 if (SWIG_arg_fail(2)) SWIG_fail;
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 (arg1)->Attach(arg2);
35362
35363 wxPyEndAllowThreads(__tstate);
35364 if (PyErr_Occurred()) SWIG_fail;
35365 }
35366 Py_INCREF(Py_None); resultobj = Py_None;
35367 return resultobj;
35368 fail:
35369 return NULL;
35370 }
35371
35372
35373 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35374 PyObject *resultobj;
35375 wxMenu *arg1 = (wxMenu *) 0 ;
35376 PyObject * obj0 = 0 ;
35377 char *kwnames[] = {
35378 (char *) "self", NULL
35379 };
35380
35381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35383 if (SWIG_arg_fail(1)) SWIG_fail;
35384 {
35385 PyThreadState* __tstate = wxPyBeginAllowThreads();
35386 (arg1)->Detach();
35387
35388 wxPyEndAllowThreads(__tstate);
35389 if (PyErr_Occurred()) SWIG_fail;
35390 }
35391 Py_INCREF(Py_None); resultobj = Py_None;
35392 return resultobj;
35393 fail:
35394 return NULL;
35395 }
35396
35397
35398 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35399 PyObject *resultobj;
35400 wxMenu *arg1 = (wxMenu *) 0 ;
35401 bool result;
35402 PyObject * obj0 = 0 ;
35403 char *kwnames[] = {
35404 (char *) "self", NULL
35405 };
35406
35407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35409 if (SWIG_arg_fail(1)) SWIG_fail;
35410 {
35411 PyThreadState* __tstate = wxPyBeginAllowThreads();
35412 result = (bool)((wxMenu const *)arg1)->IsAttached();
35413
35414 wxPyEndAllowThreads(__tstate);
35415 if (PyErr_Occurred()) SWIG_fail;
35416 }
35417 {
35418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35419 }
35420 return resultobj;
35421 fail:
35422 return NULL;
35423 }
35424
35425
35426 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35427 PyObject *resultobj;
35428 wxMenu *arg1 = (wxMenu *) 0 ;
35429 wxMenu *arg2 = (wxMenu *) 0 ;
35430 PyObject * obj0 = 0 ;
35431 PyObject * obj1 = 0 ;
35432 char *kwnames[] = {
35433 (char *) "self",(char *) "parent", NULL
35434 };
35435
35436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35438 if (SWIG_arg_fail(1)) SWIG_fail;
35439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35440 if (SWIG_arg_fail(2)) SWIG_fail;
35441 {
35442 PyThreadState* __tstate = wxPyBeginAllowThreads();
35443 (arg1)->SetParent(arg2);
35444
35445 wxPyEndAllowThreads(__tstate);
35446 if (PyErr_Occurred()) SWIG_fail;
35447 }
35448 Py_INCREF(Py_None); resultobj = Py_None;
35449 return resultobj;
35450 fail:
35451 return NULL;
35452 }
35453
35454
35455 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35456 PyObject *resultobj;
35457 wxMenu *arg1 = (wxMenu *) 0 ;
35458 wxMenu *result;
35459 PyObject * obj0 = 0 ;
35460 char *kwnames[] = {
35461 (char *) "self", NULL
35462 };
35463
35464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35466 if (SWIG_arg_fail(1)) SWIG_fail;
35467 {
35468 PyThreadState* __tstate = wxPyBeginAllowThreads();
35469 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35470
35471 wxPyEndAllowThreads(__tstate);
35472 if (PyErr_Occurred()) SWIG_fail;
35473 }
35474 {
35475 resultobj = wxPyMake_wxObject(result, 0);
35476 }
35477 return resultobj;
35478 fail:
35479 return NULL;
35480 }
35481
35482
35483 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35484 PyObject *obj;
35485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35486 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35487 Py_INCREF(obj);
35488 return Py_BuildValue((char *)"");
35489 }
35490 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35491 PyObject *resultobj;
35492 long arg1 = (long) 0 ;
35493 wxMenuBar *result;
35494 PyObject * obj0 = 0 ;
35495 char *kwnames[] = {
35496 (char *) "style", NULL
35497 };
35498
35499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35500 if (obj0) {
35501 {
35502 arg1 = (long)(SWIG_As_long(obj0));
35503 if (SWIG_arg_fail(1)) SWIG_fail;
35504 }
35505 }
35506 {
35507 if (!wxPyCheckForApp()) SWIG_fail;
35508 PyThreadState* __tstate = wxPyBeginAllowThreads();
35509 result = (wxMenuBar *)new wxMenuBar(arg1);
35510
35511 wxPyEndAllowThreads(__tstate);
35512 if (PyErr_Occurred()) SWIG_fail;
35513 }
35514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35515 return resultobj;
35516 fail:
35517 return NULL;
35518 }
35519
35520
35521 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35522 PyObject *resultobj;
35523 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35524 wxMenu *arg2 = (wxMenu *) 0 ;
35525 wxString *arg3 = 0 ;
35526 bool result;
35527 bool temp3 = false ;
35528 PyObject * obj0 = 0 ;
35529 PyObject * obj1 = 0 ;
35530 PyObject * obj2 = 0 ;
35531 char *kwnames[] = {
35532 (char *) "self",(char *) "menu",(char *) "title", NULL
35533 };
35534
35535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35537 if (SWIG_arg_fail(1)) SWIG_fail;
35538 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35539 if (SWIG_arg_fail(2)) SWIG_fail;
35540 {
35541 arg3 = wxString_in_helper(obj2);
35542 if (arg3 == NULL) SWIG_fail;
35543 temp3 = true;
35544 }
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35548
35549 wxPyEndAllowThreads(__tstate);
35550 if (PyErr_Occurred()) SWIG_fail;
35551 }
35552 {
35553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35554 }
35555 {
35556 if (temp3)
35557 delete arg3;
35558 }
35559 return resultobj;
35560 fail:
35561 {
35562 if (temp3)
35563 delete arg3;
35564 }
35565 return NULL;
35566 }
35567
35568
35569 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35570 PyObject *resultobj;
35571 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35572 size_t arg2 ;
35573 wxMenu *arg3 = (wxMenu *) 0 ;
35574 wxString *arg4 = 0 ;
35575 bool result;
35576 bool temp4 = false ;
35577 PyObject * obj0 = 0 ;
35578 PyObject * obj1 = 0 ;
35579 PyObject * obj2 = 0 ;
35580 PyObject * obj3 = 0 ;
35581 char *kwnames[] = {
35582 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35583 };
35584
35585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35587 if (SWIG_arg_fail(1)) SWIG_fail;
35588 {
35589 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35590 if (SWIG_arg_fail(2)) SWIG_fail;
35591 }
35592 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35593 if (SWIG_arg_fail(3)) SWIG_fail;
35594 {
35595 arg4 = wxString_in_helper(obj3);
35596 if (arg4 == NULL) SWIG_fail;
35597 temp4 = true;
35598 }
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35602
35603 wxPyEndAllowThreads(__tstate);
35604 if (PyErr_Occurred()) SWIG_fail;
35605 }
35606 {
35607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35608 }
35609 {
35610 if (temp4)
35611 delete arg4;
35612 }
35613 return resultobj;
35614 fail:
35615 {
35616 if (temp4)
35617 delete arg4;
35618 }
35619 return NULL;
35620 }
35621
35622
35623 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35624 PyObject *resultobj;
35625 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35626 size_t result;
35627 PyObject * obj0 = 0 ;
35628 char *kwnames[] = {
35629 (char *) "self", NULL
35630 };
35631
35632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35634 if (SWIG_arg_fail(1)) SWIG_fail;
35635 {
35636 PyThreadState* __tstate = wxPyBeginAllowThreads();
35637 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35638
35639 wxPyEndAllowThreads(__tstate);
35640 if (PyErr_Occurred()) SWIG_fail;
35641 }
35642 {
35643 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35644 }
35645 return resultobj;
35646 fail:
35647 return NULL;
35648 }
35649
35650
35651 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35652 PyObject *resultobj;
35653 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35654 size_t arg2 ;
35655 wxMenu *result;
35656 PyObject * obj0 = 0 ;
35657 PyObject * obj1 = 0 ;
35658 char *kwnames[] = {
35659 (char *) "self",(char *) "pos", NULL
35660 };
35661
35662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35664 if (SWIG_arg_fail(1)) SWIG_fail;
35665 {
35666 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35667 if (SWIG_arg_fail(2)) SWIG_fail;
35668 }
35669 {
35670 PyThreadState* __tstate = wxPyBeginAllowThreads();
35671 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35672
35673 wxPyEndAllowThreads(__tstate);
35674 if (PyErr_Occurred()) SWIG_fail;
35675 }
35676 {
35677 resultobj = wxPyMake_wxObject(result, 0);
35678 }
35679 return resultobj;
35680 fail:
35681 return NULL;
35682 }
35683
35684
35685 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35686 PyObject *resultobj;
35687 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35688 size_t arg2 ;
35689 wxMenu *arg3 = (wxMenu *) 0 ;
35690 wxString *arg4 = 0 ;
35691 wxMenu *result;
35692 bool temp4 = false ;
35693 PyObject * obj0 = 0 ;
35694 PyObject * obj1 = 0 ;
35695 PyObject * obj2 = 0 ;
35696 PyObject * obj3 = 0 ;
35697 char *kwnames[] = {
35698 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35699 };
35700
35701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35706 if (SWIG_arg_fail(2)) SWIG_fail;
35707 }
35708 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35709 if (SWIG_arg_fail(3)) SWIG_fail;
35710 {
35711 arg4 = wxString_in_helper(obj3);
35712 if (arg4 == NULL) SWIG_fail;
35713 temp4 = true;
35714 }
35715 {
35716 PyThreadState* __tstate = wxPyBeginAllowThreads();
35717 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35718
35719 wxPyEndAllowThreads(__tstate);
35720 if (PyErr_Occurred()) SWIG_fail;
35721 }
35722 {
35723 resultobj = wxPyMake_wxObject(result, 0);
35724 }
35725 {
35726 if (temp4)
35727 delete arg4;
35728 }
35729 return resultobj;
35730 fail:
35731 {
35732 if (temp4)
35733 delete arg4;
35734 }
35735 return NULL;
35736 }
35737
35738
35739 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35740 PyObject *resultobj;
35741 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35742 size_t arg2 ;
35743 wxMenu *result;
35744 PyObject * obj0 = 0 ;
35745 PyObject * obj1 = 0 ;
35746 char *kwnames[] = {
35747 (char *) "self",(char *) "pos", NULL
35748 };
35749
35750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35752 if (SWIG_arg_fail(1)) SWIG_fail;
35753 {
35754 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35755 if (SWIG_arg_fail(2)) SWIG_fail;
35756 }
35757 {
35758 PyThreadState* __tstate = wxPyBeginAllowThreads();
35759 result = (wxMenu *)(arg1)->Remove(arg2);
35760
35761 wxPyEndAllowThreads(__tstate);
35762 if (PyErr_Occurred()) SWIG_fail;
35763 }
35764 {
35765 resultobj = wxPyMake_wxObject(result, 0);
35766 }
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35774 PyObject *resultobj;
35775 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35776 size_t arg2 ;
35777 bool arg3 ;
35778 PyObject * obj0 = 0 ;
35779 PyObject * obj1 = 0 ;
35780 PyObject * obj2 = 0 ;
35781 char *kwnames[] = {
35782 (char *) "self",(char *) "pos",(char *) "enable", NULL
35783 };
35784
35785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35787 if (SWIG_arg_fail(1)) SWIG_fail;
35788 {
35789 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35790 if (SWIG_arg_fail(2)) SWIG_fail;
35791 }
35792 {
35793 arg3 = (bool)(SWIG_As_bool(obj2));
35794 if (SWIG_arg_fail(3)) SWIG_fail;
35795 }
35796 {
35797 PyThreadState* __tstate = wxPyBeginAllowThreads();
35798 (arg1)->EnableTop(arg2,arg3);
35799
35800 wxPyEndAllowThreads(__tstate);
35801 if (PyErr_Occurred()) SWIG_fail;
35802 }
35803 Py_INCREF(Py_None); resultobj = Py_None;
35804 return resultobj;
35805 fail:
35806 return NULL;
35807 }
35808
35809
35810 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35811 PyObject *resultobj;
35812 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35813 size_t arg2 ;
35814 bool result;
35815 PyObject * obj0 = 0 ;
35816 PyObject * obj1 = 0 ;
35817 char *kwnames[] = {
35818 (char *) "self",(char *) "pos", NULL
35819 };
35820
35821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35823 if (SWIG_arg_fail(1)) SWIG_fail;
35824 {
35825 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35826 if (SWIG_arg_fail(2)) SWIG_fail;
35827 }
35828 {
35829 PyThreadState* __tstate = wxPyBeginAllowThreads();
35830 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35831
35832 wxPyEndAllowThreads(__tstate);
35833 if (PyErr_Occurred()) SWIG_fail;
35834 }
35835 {
35836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35837 }
35838 return resultobj;
35839 fail:
35840 return NULL;
35841 }
35842
35843
35844 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35845 PyObject *resultobj;
35846 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35847 size_t arg2 ;
35848 wxString *arg3 = 0 ;
35849 bool temp3 = false ;
35850 PyObject * obj0 = 0 ;
35851 PyObject * obj1 = 0 ;
35852 PyObject * obj2 = 0 ;
35853 char *kwnames[] = {
35854 (char *) "self",(char *) "pos",(char *) "label", NULL
35855 };
35856
35857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35859 if (SWIG_arg_fail(1)) SWIG_fail;
35860 {
35861 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35862 if (SWIG_arg_fail(2)) SWIG_fail;
35863 }
35864 {
35865 arg3 = wxString_in_helper(obj2);
35866 if (arg3 == NULL) SWIG_fail;
35867 temp3 = true;
35868 }
35869 {
35870 PyThreadState* __tstate = wxPyBeginAllowThreads();
35871 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35872
35873 wxPyEndAllowThreads(__tstate);
35874 if (PyErr_Occurred()) SWIG_fail;
35875 }
35876 Py_INCREF(Py_None); resultobj = Py_None;
35877 {
35878 if (temp3)
35879 delete arg3;
35880 }
35881 return resultobj;
35882 fail:
35883 {
35884 if (temp3)
35885 delete arg3;
35886 }
35887 return NULL;
35888 }
35889
35890
35891 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35892 PyObject *resultobj;
35893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35894 size_t arg2 ;
35895 wxString result;
35896 PyObject * obj0 = 0 ;
35897 PyObject * obj1 = 0 ;
35898 char *kwnames[] = {
35899 (char *) "self",(char *) "pos", NULL
35900 };
35901
35902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35904 if (SWIG_arg_fail(1)) SWIG_fail;
35905 {
35906 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35907 if (SWIG_arg_fail(2)) SWIG_fail;
35908 }
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35912
35913 wxPyEndAllowThreads(__tstate);
35914 if (PyErr_Occurred()) SWIG_fail;
35915 }
35916 {
35917 #if wxUSE_UNICODE
35918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35919 #else
35920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35921 #endif
35922 }
35923 return resultobj;
35924 fail:
35925 return NULL;
35926 }
35927
35928
35929 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35930 PyObject *resultobj;
35931 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35932 wxString *arg2 = 0 ;
35933 wxString *arg3 = 0 ;
35934 int result;
35935 bool temp2 = false ;
35936 bool temp3 = false ;
35937 PyObject * obj0 = 0 ;
35938 PyObject * obj1 = 0 ;
35939 PyObject * obj2 = 0 ;
35940 char *kwnames[] = {
35941 (char *) "self",(char *) "menu",(char *) "item", NULL
35942 };
35943
35944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35946 if (SWIG_arg_fail(1)) SWIG_fail;
35947 {
35948 arg2 = wxString_in_helper(obj1);
35949 if (arg2 == NULL) SWIG_fail;
35950 temp2 = true;
35951 }
35952 {
35953 arg3 = wxString_in_helper(obj2);
35954 if (arg3 == NULL) SWIG_fail;
35955 temp3 = true;
35956 }
35957 {
35958 PyThreadState* __tstate = wxPyBeginAllowThreads();
35959 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35960
35961 wxPyEndAllowThreads(__tstate);
35962 if (PyErr_Occurred()) SWIG_fail;
35963 }
35964 {
35965 resultobj = SWIG_From_int((int)(result));
35966 }
35967 {
35968 if (temp2)
35969 delete arg2;
35970 }
35971 {
35972 if (temp3)
35973 delete arg3;
35974 }
35975 return resultobj;
35976 fail:
35977 {
35978 if (temp2)
35979 delete arg2;
35980 }
35981 {
35982 if (temp3)
35983 delete arg3;
35984 }
35985 return NULL;
35986 }
35987
35988
35989 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35990 PyObject *resultobj;
35991 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35992 int arg2 ;
35993 wxMenuItem *result;
35994 PyObject * obj0 = 0 ;
35995 PyObject * obj1 = 0 ;
35996 char *kwnames[] = {
35997 (char *) "self",(char *) "id", NULL
35998 };
35999
36000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36002 if (SWIG_arg_fail(1)) SWIG_fail;
36003 {
36004 arg2 = (int)(SWIG_As_int(obj1));
36005 if (SWIG_arg_fail(2)) SWIG_fail;
36006 }
36007 {
36008 PyThreadState* __tstate = wxPyBeginAllowThreads();
36009 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36010
36011 wxPyEndAllowThreads(__tstate);
36012 if (PyErr_Occurred()) SWIG_fail;
36013 }
36014 {
36015 resultobj = wxPyMake_wxObject(result, 0);
36016 }
36017 return resultobj;
36018 fail:
36019 return NULL;
36020 }
36021
36022
36023 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36024 PyObject *resultobj;
36025 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36026 wxString *arg2 = 0 ;
36027 int result;
36028 bool temp2 = false ;
36029 PyObject * obj0 = 0 ;
36030 PyObject * obj1 = 0 ;
36031 char *kwnames[] = {
36032 (char *) "self",(char *) "title", NULL
36033 };
36034
36035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36037 if (SWIG_arg_fail(1)) SWIG_fail;
36038 {
36039 arg2 = wxString_in_helper(obj1);
36040 if (arg2 == NULL) SWIG_fail;
36041 temp2 = true;
36042 }
36043 {
36044 PyThreadState* __tstate = wxPyBeginAllowThreads();
36045 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36046
36047 wxPyEndAllowThreads(__tstate);
36048 if (PyErr_Occurred()) SWIG_fail;
36049 }
36050 {
36051 resultobj = SWIG_From_int((int)(result));
36052 }
36053 {
36054 if (temp2)
36055 delete arg2;
36056 }
36057 return resultobj;
36058 fail:
36059 {
36060 if (temp2)
36061 delete arg2;
36062 }
36063 return NULL;
36064 }
36065
36066
36067 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36068 PyObject *resultobj;
36069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36070 int arg2 ;
36071 bool arg3 ;
36072 PyObject * obj0 = 0 ;
36073 PyObject * obj1 = 0 ;
36074 PyObject * obj2 = 0 ;
36075 char *kwnames[] = {
36076 (char *) "self",(char *) "id",(char *) "enable", NULL
36077 };
36078
36079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36081 if (SWIG_arg_fail(1)) SWIG_fail;
36082 {
36083 arg2 = (int)(SWIG_As_int(obj1));
36084 if (SWIG_arg_fail(2)) SWIG_fail;
36085 }
36086 {
36087 arg3 = (bool)(SWIG_As_bool(obj2));
36088 if (SWIG_arg_fail(3)) SWIG_fail;
36089 }
36090 {
36091 PyThreadState* __tstate = wxPyBeginAllowThreads();
36092 (arg1)->Enable(arg2,arg3);
36093
36094 wxPyEndAllowThreads(__tstate);
36095 if (PyErr_Occurred()) SWIG_fail;
36096 }
36097 Py_INCREF(Py_None); resultobj = Py_None;
36098 return resultobj;
36099 fail:
36100 return NULL;
36101 }
36102
36103
36104 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36105 PyObject *resultobj;
36106 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36107 int arg2 ;
36108 bool arg3 ;
36109 PyObject * obj0 = 0 ;
36110 PyObject * obj1 = 0 ;
36111 PyObject * obj2 = 0 ;
36112 char *kwnames[] = {
36113 (char *) "self",(char *) "id",(char *) "check", NULL
36114 };
36115
36116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36118 if (SWIG_arg_fail(1)) SWIG_fail;
36119 {
36120 arg2 = (int)(SWIG_As_int(obj1));
36121 if (SWIG_arg_fail(2)) SWIG_fail;
36122 }
36123 {
36124 arg3 = (bool)(SWIG_As_bool(obj2));
36125 if (SWIG_arg_fail(3)) SWIG_fail;
36126 }
36127 {
36128 PyThreadState* __tstate = wxPyBeginAllowThreads();
36129 (arg1)->Check(arg2,arg3);
36130
36131 wxPyEndAllowThreads(__tstate);
36132 if (PyErr_Occurred()) SWIG_fail;
36133 }
36134 Py_INCREF(Py_None); resultobj = Py_None;
36135 return resultobj;
36136 fail:
36137 return NULL;
36138 }
36139
36140
36141 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36142 PyObject *resultobj;
36143 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36144 int arg2 ;
36145 bool result;
36146 PyObject * obj0 = 0 ;
36147 PyObject * obj1 = 0 ;
36148 char *kwnames[] = {
36149 (char *) "self",(char *) "id", NULL
36150 };
36151
36152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36154 if (SWIG_arg_fail(1)) SWIG_fail;
36155 {
36156 arg2 = (int)(SWIG_As_int(obj1));
36157 if (SWIG_arg_fail(2)) SWIG_fail;
36158 }
36159 {
36160 PyThreadState* __tstate = wxPyBeginAllowThreads();
36161 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36162
36163 wxPyEndAllowThreads(__tstate);
36164 if (PyErr_Occurred()) SWIG_fail;
36165 }
36166 {
36167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36168 }
36169 return resultobj;
36170 fail:
36171 return NULL;
36172 }
36173
36174
36175 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36176 PyObject *resultobj;
36177 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36178 int arg2 ;
36179 bool result;
36180 PyObject * obj0 = 0 ;
36181 PyObject * obj1 = 0 ;
36182 char *kwnames[] = {
36183 (char *) "self",(char *) "id", NULL
36184 };
36185
36186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36188 if (SWIG_arg_fail(1)) SWIG_fail;
36189 {
36190 arg2 = (int)(SWIG_As_int(obj1));
36191 if (SWIG_arg_fail(2)) SWIG_fail;
36192 }
36193 {
36194 PyThreadState* __tstate = wxPyBeginAllowThreads();
36195 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36196
36197 wxPyEndAllowThreads(__tstate);
36198 if (PyErr_Occurred()) SWIG_fail;
36199 }
36200 {
36201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36202 }
36203 return resultobj;
36204 fail:
36205 return NULL;
36206 }
36207
36208
36209 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36210 PyObject *resultobj;
36211 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36212 int arg2 ;
36213 wxString *arg3 = 0 ;
36214 bool temp3 = false ;
36215 PyObject * obj0 = 0 ;
36216 PyObject * obj1 = 0 ;
36217 PyObject * obj2 = 0 ;
36218 char *kwnames[] = {
36219 (char *) "self",(char *) "id",(char *) "label", NULL
36220 };
36221
36222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36224 if (SWIG_arg_fail(1)) SWIG_fail;
36225 {
36226 arg2 = (int)(SWIG_As_int(obj1));
36227 if (SWIG_arg_fail(2)) SWIG_fail;
36228 }
36229 {
36230 arg3 = wxString_in_helper(obj2);
36231 if (arg3 == NULL) SWIG_fail;
36232 temp3 = true;
36233 }
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36237
36238 wxPyEndAllowThreads(__tstate);
36239 if (PyErr_Occurred()) SWIG_fail;
36240 }
36241 Py_INCREF(Py_None); resultobj = Py_None;
36242 {
36243 if (temp3)
36244 delete arg3;
36245 }
36246 return resultobj;
36247 fail:
36248 {
36249 if (temp3)
36250 delete arg3;
36251 }
36252 return NULL;
36253 }
36254
36255
36256 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36257 PyObject *resultobj;
36258 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36259 int arg2 ;
36260 wxString result;
36261 PyObject * obj0 = 0 ;
36262 PyObject * obj1 = 0 ;
36263 char *kwnames[] = {
36264 (char *) "self",(char *) "id", NULL
36265 };
36266
36267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36269 if (SWIG_arg_fail(1)) SWIG_fail;
36270 {
36271 arg2 = (int)(SWIG_As_int(obj1));
36272 if (SWIG_arg_fail(2)) SWIG_fail;
36273 }
36274 {
36275 PyThreadState* __tstate = wxPyBeginAllowThreads();
36276 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36277
36278 wxPyEndAllowThreads(__tstate);
36279 if (PyErr_Occurred()) SWIG_fail;
36280 }
36281 {
36282 #if wxUSE_UNICODE
36283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36284 #else
36285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36286 #endif
36287 }
36288 return resultobj;
36289 fail:
36290 return NULL;
36291 }
36292
36293
36294 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36295 PyObject *resultobj;
36296 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36297 int arg2 ;
36298 wxString *arg3 = 0 ;
36299 bool temp3 = false ;
36300 PyObject * obj0 = 0 ;
36301 PyObject * obj1 = 0 ;
36302 PyObject * obj2 = 0 ;
36303 char *kwnames[] = {
36304 (char *) "self",(char *) "id",(char *) "helpString", NULL
36305 };
36306
36307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36309 if (SWIG_arg_fail(1)) SWIG_fail;
36310 {
36311 arg2 = (int)(SWIG_As_int(obj1));
36312 if (SWIG_arg_fail(2)) SWIG_fail;
36313 }
36314 {
36315 arg3 = wxString_in_helper(obj2);
36316 if (arg3 == NULL) SWIG_fail;
36317 temp3 = true;
36318 }
36319 {
36320 PyThreadState* __tstate = wxPyBeginAllowThreads();
36321 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36322
36323 wxPyEndAllowThreads(__tstate);
36324 if (PyErr_Occurred()) SWIG_fail;
36325 }
36326 Py_INCREF(Py_None); resultobj = Py_None;
36327 {
36328 if (temp3)
36329 delete arg3;
36330 }
36331 return resultobj;
36332 fail:
36333 {
36334 if (temp3)
36335 delete arg3;
36336 }
36337 return NULL;
36338 }
36339
36340
36341 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36342 PyObject *resultobj;
36343 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36344 int arg2 ;
36345 wxString result;
36346 PyObject * obj0 = 0 ;
36347 PyObject * obj1 = 0 ;
36348 char *kwnames[] = {
36349 (char *) "self",(char *) "id", NULL
36350 };
36351
36352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36354 if (SWIG_arg_fail(1)) SWIG_fail;
36355 {
36356 arg2 = (int)(SWIG_As_int(obj1));
36357 if (SWIG_arg_fail(2)) SWIG_fail;
36358 }
36359 {
36360 PyThreadState* __tstate = wxPyBeginAllowThreads();
36361 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36362
36363 wxPyEndAllowThreads(__tstate);
36364 if (PyErr_Occurred()) SWIG_fail;
36365 }
36366 {
36367 #if wxUSE_UNICODE
36368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36369 #else
36370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36371 #endif
36372 }
36373 return resultobj;
36374 fail:
36375 return NULL;
36376 }
36377
36378
36379 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36380 PyObject *resultobj;
36381 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36382 wxFrame *result;
36383 PyObject * obj0 = 0 ;
36384 char *kwnames[] = {
36385 (char *) "self", NULL
36386 };
36387
36388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36390 if (SWIG_arg_fail(1)) SWIG_fail;
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36394
36395 wxPyEndAllowThreads(__tstate);
36396 if (PyErr_Occurred()) SWIG_fail;
36397 }
36398 {
36399 resultobj = wxPyMake_wxObject(result, 0);
36400 }
36401 return resultobj;
36402 fail:
36403 return NULL;
36404 }
36405
36406
36407 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36408 PyObject *resultobj;
36409 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36410 bool result;
36411 PyObject * obj0 = 0 ;
36412 char *kwnames[] = {
36413 (char *) "self", NULL
36414 };
36415
36416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36418 if (SWIG_arg_fail(1)) SWIG_fail;
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36422
36423 wxPyEndAllowThreads(__tstate);
36424 if (PyErr_Occurred()) SWIG_fail;
36425 }
36426 {
36427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36428 }
36429 return resultobj;
36430 fail:
36431 return NULL;
36432 }
36433
36434
36435 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36436 PyObject *resultobj;
36437 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36438 wxFrame *arg2 = (wxFrame *) 0 ;
36439 PyObject * obj0 = 0 ;
36440 PyObject * obj1 = 0 ;
36441 char *kwnames[] = {
36442 (char *) "self",(char *) "frame", NULL
36443 };
36444
36445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36447 if (SWIG_arg_fail(1)) SWIG_fail;
36448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36449 if (SWIG_arg_fail(2)) SWIG_fail;
36450 {
36451 PyThreadState* __tstate = wxPyBeginAllowThreads();
36452 (arg1)->Attach(arg2);
36453
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 Py_INCREF(Py_None); resultobj = Py_None;
36458 return resultobj;
36459 fail:
36460 return NULL;
36461 }
36462
36463
36464 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36465 PyObject *resultobj;
36466 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36467 PyObject * obj0 = 0 ;
36468 char *kwnames[] = {
36469 (char *) "self", NULL
36470 };
36471
36472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36474 if (SWIG_arg_fail(1)) SWIG_fail;
36475 {
36476 PyThreadState* __tstate = wxPyBeginAllowThreads();
36477 (arg1)->Detach();
36478
36479 wxPyEndAllowThreads(__tstate);
36480 if (PyErr_Occurred()) SWIG_fail;
36481 }
36482 Py_INCREF(Py_None); resultobj = Py_None;
36483 return resultobj;
36484 fail:
36485 return NULL;
36486 }
36487
36488
36489 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36490 PyObject *resultobj;
36491 bool arg1 ;
36492 PyObject * obj0 = 0 ;
36493 char *kwnames[] = {
36494 (char *) "enable", NULL
36495 };
36496
36497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36498 {
36499 arg1 = (bool)(SWIG_As_bool(obj0));
36500 if (SWIG_arg_fail(1)) SWIG_fail;
36501 }
36502 {
36503 PyThreadState* __tstate = wxPyBeginAllowThreads();
36504 MenuBar_SetAutoWindowMenu(arg1);
36505
36506 wxPyEndAllowThreads(__tstate);
36507 if (PyErr_Occurred()) SWIG_fail;
36508 }
36509 Py_INCREF(Py_None); resultobj = Py_None;
36510 return resultobj;
36511 fail:
36512 return NULL;
36513 }
36514
36515
36516 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36517 PyObject *resultobj;
36518 bool result;
36519 char *kwnames[] = {
36520 NULL
36521 };
36522
36523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36524 {
36525 PyThreadState* __tstate = wxPyBeginAllowThreads();
36526 result = (bool)MenuBar_GetAutoWindowMenu();
36527
36528 wxPyEndAllowThreads(__tstate);
36529 if (PyErr_Occurred()) SWIG_fail;
36530 }
36531 {
36532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36533 }
36534 return resultobj;
36535 fail:
36536 return NULL;
36537 }
36538
36539
36540 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36541 PyObject *obj;
36542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36543 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36544 Py_INCREF(obj);
36545 return Py_BuildValue((char *)"");
36546 }
36547 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36548 PyObject *resultobj;
36549 wxMenu *arg1 = (wxMenu *) NULL ;
36550 int arg2 = (int) wxID_ANY ;
36551 wxString const &arg3_defvalue = wxPyEmptyString ;
36552 wxString *arg3 = (wxString *) &arg3_defvalue ;
36553 wxString const &arg4_defvalue = wxPyEmptyString ;
36554 wxString *arg4 = (wxString *) &arg4_defvalue ;
36555 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36556 wxMenu *arg6 = (wxMenu *) NULL ;
36557 wxMenuItem *result;
36558 bool temp3 = false ;
36559 bool temp4 = false ;
36560 PyObject * obj0 = 0 ;
36561 PyObject * obj1 = 0 ;
36562 PyObject * obj2 = 0 ;
36563 PyObject * obj3 = 0 ;
36564 PyObject * obj4 = 0 ;
36565 PyObject * obj5 = 0 ;
36566 char *kwnames[] = {
36567 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36568 };
36569
36570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36571 if (obj0) {
36572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36573 if (SWIG_arg_fail(1)) SWIG_fail;
36574 }
36575 if (obj1) {
36576 {
36577 arg2 = (int)(SWIG_As_int(obj1));
36578 if (SWIG_arg_fail(2)) SWIG_fail;
36579 }
36580 }
36581 if (obj2) {
36582 {
36583 arg3 = wxString_in_helper(obj2);
36584 if (arg3 == NULL) SWIG_fail;
36585 temp3 = true;
36586 }
36587 }
36588 if (obj3) {
36589 {
36590 arg4 = wxString_in_helper(obj3);
36591 if (arg4 == NULL) SWIG_fail;
36592 temp4 = true;
36593 }
36594 }
36595 if (obj4) {
36596 {
36597 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36598 if (SWIG_arg_fail(5)) SWIG_fail;
36599 }
36600 }
36601 if (obj5) {
36602 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36603 if (SWIG_arg_fail(6)) SWIG_fail;
36604 }
36605 {
36606 PyThreadState* __tstate = wxPyBeginAllowThreads();
36607 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36608
36609 wxPyEndAllowThreads(__tstate);
36610 if (PyErr_Occurred()) SWIG_fail;
36611 }
36612 {
36613 resultobj = wxPyMake_wxObject(result, 1);
36614 }
36615 {
36616 if (temp3)
36617 delete arg3;
36618 }
36619 {
36620 if (temp4)
36621 delete arg4;
36622 }
36623 return resultobj;
36624 fail:
36625 {
36626 if (temp3)
36627 delete arg3;
36628 }
36629 {
36630 if (temp4)
36631 delete arg4;
36632 }
36633 return NULL;
36634 }
36635
36636
36637 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36638 PyObject *resultobj;
36639 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36640 wxMenu *result;
36641 PyObject * obj0 = 0 ;
36642 char *kwnames[] = {
36643 (char *) "self", NULL
36644 };
36645
36646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36648 if (SWIG_arg_fail(1)) SWIG_fail;
36649 {
36650 PyThreadState* __tstate = wxPyBeginAllowThreads();
36651 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36652
36653 wxPyEndAllowThreads(__tstate);
36654 if (PyErr_Occurred()) SWIG_fail;
36655 }
36656 {
36657 resultobj = wxPyMake_wxObject(result, 0);
36658 }
36659 return resultobj;
36660 fail:
36661 return NULL;
36662 }
36663
36664
36665 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36666 PyObject *resultobj;
36667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36668 wxMenu *arg2 = (wxMenu *) 0 ;
36669 PyObject * obj0 = 0 ;
36670 PyObject * obj1 = 0 ;
36671 char *kwnames[] = {
36672 (char *) "self",(char *) "menu", NULL
36673 };
36674
36675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36677 if (SWIG_arg_fail(1)) SWIG_fail;
36678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36679 if (SWIG_arg_fail(2)) SWIG_fail;
36680 {
36681 PyThreadState* __tstate = wxPyBeginAllowThreads();
36682 (arg1)->SetMenu(arg2);
36683
36684 wxPyEndAllowThreads(__tstate);
36685 if (PyErr_Occurred()) SWIG_fail;
36686 }
36687 Py_INCREF(Py_None); resultobj = Py_None;
36688 return resultobj;
36689 fail:
36690 return NULL;
36691 }
36692
36693
36694 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36695 PyObject *resultobj;
36696 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36697 int arg2 ;
36698 PyObject * obj0 = 0 ;
36699 PyObject * obj1 = 0 ;
36700 char *kwnames[] = {
36701 (char *) "self",(char *) "id", NULL
36702 };
36703
36704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36706 if (SWIG_arg_fail(1)) SWIG_fail;
36707 {
36708 arg2 = (int)(SWIG_As_int(obj1));
36709 if (SWIG_arg_fail(2)) SWIG_fail;
36710 }
36711 {
36712 PyThreadState* __tstate = wxPyBeginAllowThreads();
36713 (arg1)->SetId(arg2);
36714
36715 wxPyEndAllowThreads(__tstate);
36716 if (PyErr_Occurred()) SWIG_fail;
36717 }
36718 Py_INCREF(Py_None); resultobj = Py_None;
36719 return resultobj;
36720 fail:
36721 return NULL;
36722 }
36723
36724
36725 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36726 PyObject *resultobj;
36727 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36728 int result;
36729 PyObject * obj0 = 0 ;
36730 char *kwnames[] = {
36731 (char *) "self", NULL
36732 };
36733
36734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36736 if (SWIG_arg_fail(1)) SWIG_fail;
36737 {
36738 PyThreadState* __tstate = wxPyBeginAllowThreads();
36739 result = (int)((wxMenuItem const *)arg1)->GetId();
36740
36741 wxPyEndAllowThreads(__tstate);
36742 if (PyErr_Occurred()) SWIG_fail;
36743 }
36744 {
36745 resultobj = SWIG_From_int((int)(result));
36746 }
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36754 PyObject *resultobj;
36755 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36756 bool result;
36757 PyObject * obj0 = 0 ;
36758 char *kwnames[] = {
36759 (char *) "self", NULL
36760 };
36761
36762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36764 if (SWIG_arg_fail(1)) SWIG_fail;
36765 {
36766 PyThreadState* __tstate = wxPyBeginAllowThreads();
36767 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36768
36769 wxPyEndAllowThreads(__tstate);
36770 if (PyErr_Occurred()) SWIG_fail;
36771 }
36772 {
36773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36774 }
36775 return resultobj;
36776 fail:
36777 return NULL;
36778 }
36779
36780
36781 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36782 PyObject *resultobj;
36783 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36784 wxString *arg2 = 0 ;
36785 bool temp2 = false ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 char *kwnames[] = {
36789 (char *) "self",(char *) "str", NULL
36790 };
36791
36792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36794 if (SWIG_arg_fail(1)) SWIG_fail;
36795 {
36796 arg2 = wxString_in_helper(obj1);
36797 if (arg2 == NULL) SWIG_fail;
36798 temp2 = true;
36799 }
36800 {
36801 PyThreadState* __tstate = wxPyBeginAllowThreads();
36802 (arg1)->SetText((wxString const &)*arg2);
36803
36804 wxPyEndAllowThreads(__tstate);
36805 if (PyErr_Occurred()) SWIG_fail;
36806 }
36807 Py_INCREF(Py_None); resultobj = Py_None;
36808 {
36809 if (temp2)
36810 delete arg2;
36811 }
36812 return resultobj;
36813 fail:
36814 {
36815 if (temp2)
36816 delete arg2;
36817 }
36818 return NULL;
36819 }
36820
36821
36822 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36823 PyObject *resultobj;
36824 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36825 wxString result;
36826 PyObject * obj0 = 0 ;
36827 char *kwnames[] = {
36828 (char *) "self", NULL
36829 };
36830
36831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36833 if (SWIG_arg_fail(1)) SWIG_fail;
36834 {
36835 PyThreadState* __tstate = wxPyBeginAllowThreads();
36836 result = ((wxMenuItem const *)arg1)->GetLabel();
36837
36838 wxPyEndAllowThreads(__tstate);
36839 if (PyErr_Occurred()) SWIG_fail;
36840 }
36841 {
36842 #if wxUSE_UNICODE
36843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36844 #else
36845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36846 #endif
36847 }
36848 return resultobj;
36849 fail:
36850 return NULL;
36851 }
36852
36853
36854 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36855 PyObject *resultobj;
36856 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36857 wxString *result;
36858 PyObject * obj0 = 0 ;
36859 char *kwnames[] = {
36860 (char *) "self", NULL
36861 };
36862
36863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36865 if (SWIG_arg_fail(1)) SWIG_fail;
36866 {
36867 PyThreadState* __tstate = wxPyBeginAllowThreads();
36868 {
36869 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36870 result = (wxString *) &_result_ref;
36871 }
36872
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 {
36877 #if wxUSE_UNICODE
36878 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36879 #else
36880 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36881 #endif
36882 }
36883 return resultobj;
36884 fail:
36885 return NULL;
36886 }
36887
36888
36889 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36890 PyObject *resultobj;
36891 wxString *arg1 = 0 ;
36892 wxString result;
36893 bool temp1 = false ;
36894 PyObject * obj0 = 0 ;
36895 char *kwnames[] = {
36896 (char *) "text", NULL
36897 };
36898
36899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36900 {
36901 arg1 = wxString_in_helper(obj0);
36902 if (arg1 == NULL) SWIG_fail;
36903 temp1 = true;
36904 }
36905 {
36906 PyThreadState* __tstate = wxPyBeginAllowThreads();
36907 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36908
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 {
36913 #if wxUSE_UNICODE
36914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36915 #else
36916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36917 #endif
36918 }
36919 {
36920 if (temp1)
36921 delete arg1;
36922 }
36923 return resultobj;
36924 fail:
36925 {
36926 if (temp1)
36927 delete arg1;
36928 }
36929 return NULL;
36930 }
36931
36932
36933 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36934 PyObject *resultobj;
36935 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36936 wxItemKind result;
36937 PyObject * obj0 = 0 ;
36938 char *kwnames[] = {
36939 (char *) "self", NULL
36940 };
36941
36942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36944 if (SWIG_arg_fail(1)) SWIG_fail;
36945 {
36946 PyThreadState* __tstate = wxPyBeginAllowThreads();
36947 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36948
36949 wxPyEndAllowThreads(__tstate);
36950 if (PyErr_Occurred()) SWIG_fail;
36951 }
36952 resultobj = SWIG_From_int((result));
36953 return resultobj;
36954 fail:
36955 return NULL;
36956 }
36957
36958
36959 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36960 PyObject *resultobj;
36961 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36962 wxItemKind arg2 ;
36963 PyObject * obj0 = 0 ;
36964 PyObject * obj1 = 0 ;
36965 char *kwnames[] = {
36966 (char *) "self",(char *) "kind", NULL
36967 };
36968
36969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36971 if (SWIG_arg_fail(1)) SWIG_fail;
36972 {
36973 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36974 if (SWIG_arg_fail(2)) SWIG_fail;
36975 }
36976 {
36977 PyThreadState* __tstate = wxPyBeginAllowThreads();
36978 (arg1)->SetKind((wxItemKind )arg2);
36979
36980 wxPyEndAllowThreads(__tstate);
36981 if (PyErr_Occurred()) SWIG_fail;
36982 }
36983 Py_INCREF(Py_None); resultobj = Py_None;
36984 return resultobj;
36985 fail:
36986 return NULL;
36987 }
36988
36989
36990 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36991 PyObject *resultobj;
36992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36993 bool arg2 ;
36994 PyObject * obj0 = 0 ;
36995 PyObject * obj1 = 0 ;
36996 char *kwnames[] = {
36997 (char *) "self",(char *) "checkable", NULL
36998 };
36999
37000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37002 if (SWIG_arg_fail(1)) SWIG_fail;
37003 {
37004 arg2 = (bool)(SWIG_As_bool(obj1));
37005 if (SWIG_arg_fail(2)) SWIG_fail;
37006 }
37007 {
37008 PyThreadState* __tstate = wxPyBeginAllowThreads();
37009 (arg1)->SetCheckable(arg2);
37010
37011 wxPyEndAllowThreads(__tstate);
37012 if (PyErr_Occurred()) SWIG_fail;
37013 }
37014 Py_INCREF(Py_None); resultobj = Py_None;
37015 return resultobj;
37016 fail:
37017 return NULL;
37018 }
37019
37020
37021 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37022 PyObject *resultobj;
37023 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37024 bool result;
37025 PyObject * obj0 = 0 ;
37026 char *kwnames[] = {
37027 (char *) "self", NULL
37028 };
37029
37030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37032 if (SWIG_arg_fail(1)) SWIG_fail;
37033 {
37034 PyThreadState* __tstate = wxPyBeginAllowThreads();
37035 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37036
37037 wxPyEndAllowThreads(__tstate);
37038 if (PyErr_Occurred()) SWIG_fail;
37039 }
37040 {
37041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37042 }
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37050 PyObject *resultobj;
37051 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37052 bool result;
37053 PyObject * obj0 = 0 ;
37054 char *kwnames[] = {
37055 (char *) "self", NULL
37056 };
37057
37058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37060 if (SWIG_arg_fail(1)) SWIG_fail;
37061 {
37062 PyThreadState* __tstate = wxPyBeginAllowThreads();
37063 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37064
37065 wxPyEndAllowThreads(__tstate);
37066 if (PyErr_Occurred()) SWIG_fail;
37067 }
37068 {
37069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37070 }
37071 return resultobj;
37072 fail:
37073 return NULL;
37074 }
37075
37076
37077 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37078 PyObject *resultobj;
37079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37080 wxMenu *arg2 = (wxMenu *) 0 ;
37081 PyObject * obj0 = 0 ;
37082 PyObject * obj1 = 0 ;
37083 char *kwnames[] = {
37084 (char *) "self",(char *) "menu", NULL
37085 };
37086
37087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37089 if (SWIG_arg_fail(1)) SWIG_fail;
37090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37091 if (SWIG_arg_fail(2)) SWIG_fail;
37092 {
37093 PyThreadState* __tstate = wxPyBeginAllowThreads();
37094 (arg1)->SetSubMenu(arg2);
37095
37096 wxPyEndAllowThreads(__tstate);
37097 if (PyErr_Occurred()) SWIG_fail;
37098 }
37099 Py_INCREF(Py_None); resultobj = Py_None;
37100 return resultobj;
37101 fail:
37102 return NULL;
37103 }
37104
37105
37106 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37107 PyObject *resultobj;
37108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37109 wxMenu *result;
37110 PyObject * obj0 = 0 ;
37111 char *kwnames[] = {
37112 (char *) "self", NULL
37113 };
37114
37115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37117 if (SWIG_arg_fail(1)) SWIG_fail;
37118 {
37119 PyThreadState* __tstate = wxPyBeginAllowThreads();
37120 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37121
37122 wxPyEndAllowThreads(__tstate);
37123 if (PyErr_Occurred()) SWIG_fail;
37124 }
37125 {
37126 resultobj = wxPyMake_wxObject(result, 0);
37127 }
37128 return resultobj;
37129 fail:
37130 return NULL;
37131 }
37132
37133
37134 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37135 PyObject *resultobj;
37136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37137 bool arg2 = (bool) true ;
37138 PyObject * obj0 = 0 ;
37139 PyObject * obj1 = 0 ;
37140 char *kwnames[] = {
37141 (char *) "self",(char *) "enable", NULL
37142 };
37143
37144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37146 if (SWIG_arg_fail(1)) SWIG_fail;
37147 if (obj1) {
37148 {
37149 arg2 = (bool)(SWIG_As_bool(obj1));
37150 if (SWIG_arg_fail(2)) SWIG_fail;
37151 }
37152 }
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 (arg1)->Enable(arg2);
37156
37157 wxPyEndAllowThreads(__tstate);
37158 if (PyErr_Occurred()) SWIG_fail;
37159 }
37160 Py_INCREF(Py_None); resultobj = Py_None;
37161 return resultobj;
37162 fail:
37163 return NULL;
37164 }
37165
37166
37167 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37168 PyObject *resultobj;
37169 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37170 bool result;
37171 PyObject * obj0 = 0 ;
37172 char *kwnames[] = {
37173 (char *) "self", NULL
37174 };
37175
37176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37178 if (SWIG_arg_fail(1)) SWIG_fail;
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37182
37183 wxPyEndAllowThreads(__tstate);
37184 if (PyErr_Occurred()) SWIG_fail;
37185 }
37186 {
37187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37188 }
37189 return resultobj;
37190 fail:
37191 return NULL;
37192 }
37193
37194
37195 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37196 PyObject *resultobj;
37197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37198 bool arg2 = (bool) true ;
37199 PyObject * obj0 = 0 ;
37200 PyObject * obj1 = 0 ;
37201 char *kwnames[] = {
37202 (char *) "self",(char *) "check", NULL
37203 };
37204
37205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",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 if (obj1) {
37209 {
37210 arg2 = (bool)(SWIG_As_bool(obj1));
37211 if (SWIG_arg_fail(2)) SWIG_fail;
37212 }
37213 }
37214 {
37215 PyThreadState* __tstate = wxPyBeginAllowThreads();
37216 (arg1)->Check(arg2);
37217
37218 wxPyEndAllowThreads(__tstate);
37219 if (PyErr_Occurred()) SWIG_fail;
37220 }
37221 Py_INCREF(Py_None); resultobj = Py_None;
37222 return resultobj;
37223 fail:
37224 return NULL;
37225 }
37226
37227
37228 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37229 PyObject *resultobj;
37230 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37231 bool result;
37232 PyObject * obj0 = 0 ;
37233 char *kwnames[] = {
37234 (char *) "self", NULL
37235 };
37236
37237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37239 if (SWIG_arg_fail(1)) SWIG_fail;
37240 {
37241 PyThreadState* __tstate = wxPyBeginAllowThreads();
37242 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37243
37244 wxPyEndAllowThreads(__tstate);
37245 if (PyErr_Occurred()) SWIG_fail;
37246 }
37247 {
37248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37249 }
37250 return resultobj;
37251 fail:
37252 return NULL;
37253 }
37254
37255
37256 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37257 PyObject *resultobj;
37258 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37259 PyObject * obj0 = 0 ;
37260 char *kwnames[] = {
37261 (char *) "self", NULL
37262 };
37263
37264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37266 if (SWIG_arg_fail(1)) SWIG_fail;
37267 {
37268 PyThreadState* __tstate = wxPyBeginAllowThreads();
37269 (arg1)->Toggle();
37270
37271 wxPyEndAllowThreads(__tstate);
37272 if (PyErr_Occurred()) SWIG_fail;
37273 }
37274 Py_INCREF(Py_None); resultobj = Py_None;
37275 return resultobj;
37276 fail:
37277 return NULL;
37278 }
37279
37280
37281 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37282 PyObject *resultobj;
37283 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37284 wxString *arg2 = 0 ;
37285 bool temp2 = false ;
37286 PyObject * obj0 = 0 ;
37287 PyObject * obj1 = 0 ;
37288 char *kwnames[] = {
37289 (char *) "self",(char *) "str", NULL
37290 };
37291
37292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37294 if (SWIG_arg_fail(1)) SWIG_fail;
37295 {
37296 arg2 = wxString_in_helper(obj1);
37297 if (arg2 == NULL) SWIG_fail;
37298 temp2 = true;
37299 }
37300 {
37301 PyThreadState* __tstate = wxPyBeginAllowThreads();
37302 (arg1)->SetHelp((wxString const &)*arg2);
37303
37304 wxPyEndAllowThreads(__tstate);
37305 if (PyErr_Occurred()) SWIG_fail;
37306 }
37307 Py_INCREF(Py_None); resultobj = Py_None;
37308 {
37309 if (temp2)
37310 delete arg2;
37311 }
37312 return resultobj;
37313 fail:
37314 {
37315 if (temp2)
37316 delete arg2;
37317 }
37318 return NULL;
37319 }
37320
37321
37322 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37323 PyObject *resultobj;
37324 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37325 wxString *result;
37326 PyObject * obj0 = 0 ;
37327 char *kwnames[] = {
37328 (char *) "self", NULL
37329 };
37330
37331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37333 if (SWIG_arg_fail(1)) SWIG_fail;
37334 {
37335 PyThreadState* __tstate = wxPyBeginAllowThreads();
37336 {
37337 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37338 result = (wxString *) &_result_ref;
37339 }
37340
37341 wxPyEndAllowThreads(__tstate);
37342 if (PyErr_Occurred()) SWIG_fail;
37343 }
37344 {
37345 #if wxUSE_UNICODE
37346 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37347 #else
37348 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37349 #endif
37350 }
37351 return resultobj;
37352 fail:
37353 return NULL;
37354 }
37355
37356
37357 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37358 PyObject *resultobj;
37359 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37360 wxAcceleratorEntry *result;
37361 PyObject * obj0 = 0 ;
37362 char *kwnames[] = {
37363 (char *) "self", NULL
37364 };
37365
37366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37368 if (SWIG_arg_fail(1)) SWIG_fail;
37369 {
37370 PyThreadState* __tstate = wxPyBeginAllowThreads();
37371 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37372
37373 wxPyEndAllowThreads(__tstate);
37374 if (PyErr_Occurred()) SWIG_fail;
37375 }
37376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37377 return resultobj;
37378 fail:
37379 return NULL;
37380 }
37381
37382
37383 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37384 PyObject *resultobj;
37385 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37386 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37387 PyObject * obj0 = 0 ;
37388 PyObject * obj1 = 0 ;
37389 char *kwnames[] = {
37390 (char *) "self",(char *) "accel", NULL
37391 };
37392
37393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37395 if (SWIG_arg_fail(1)) SWIG_fail;
37396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37397 if (SWIG_arg_fail(2)) SWIG_fail;
37398 {
37399 PyThreadState* __tstate = wxPyBeginAllowThreads();
37400 (arg1)->SetAccel(arg2);
37401
37402 wxPyEndAllowThreads(__tstate);
37403 if (PyErr_Occurred()) SWIG_fail;
37404 }
37405 Py_INCREF(Py_None); resultobj = Py_None;
37406 return resultobj;
37407 fail:
37408 return NULL;
37409 }
37410
37411
37412 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37413 PyObject *resultobj;
37414 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37415 wxFont *arg2 = 0 ;
37416 PyObject * obj0 = 0 ;
37417 PyObject * obj1 = 0 ;
37418 char *kwnames[] = {
37419 (char *) "self",(char *) "font", NULL
37420 };
37421
37422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37424 if (SWIG_arg_fail(1)) SWIG_fail;
37425 {
37426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37427 if (SWIG_arg_fail(2)) SWIG_fail;
37428 if (arg2 == NULL) {
37429 SWIG_null_ref("wxFont");
37430 }
37431 if (SWIG_arg_fail(2)) SWIG_fail;
37432 }
37433 {
37434 PyThreadState* __tstate = wxPyBeginAllowThreads();
37435 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
37436
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 Py_INCREF(Py_None); resultobj = Py_None;
37441 return resultobj;
37442 fail:
37443 return NULL;
37444 }
37445
37446
37447 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37448 PyObject *resultobj;
37449 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37450 wxFont result;
37451 PyObject * obj0 = 0 ;
37452 char *kwnames[] = {
37453 (char *) "self", NULL
37454 };
37455
37456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37458 if (SWIG_arg_fail(1)) SWIG_fail;
37459 {
37460 PyThreadState* __tstate = wxPyBeginAllowThreads();
37461 result = wxMenuItem_GetFont(arg1);
37462
37463 wxPyEndAllowThreads(__tstate);
37464 if (PyErr_Occurred()) SWIG_fail;
37465 }
37466 {
37467 wxFont * resultptr;
37468 resultptr = new wxFont((wxFont &)(result));
37469 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37470 }
37471 return resultobj;
37472 fail:
37473 return NULL;
37474 }
37475
37476
37477 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37478 PyObject *resultobj;
37479 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37480 wxColour *arg2 = 0 ;
37481 wxColour temp2 ;
37482 PyObject * obj0 = 0 ;
37483 PyObject * obj1 = 0 ;
37484 char *kwnames[] = {
37485 (char *) "self",(char *) "colText", NULL
37486 };
37487
37488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37490 if (SWIG_arg_fail(1)) SWIG_fail;
37491 {
37492 arg2 = &temp2;
37493 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37494 }
37495 {
37496 PyThreadState* __tstate = wxPyBeginAllowThreads();
37497 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
37498
37499 wxPyEndAllowThreads(__tstate);
37500 if (PyErr_Occurred()) SWIG_fail;
37501 }
37502 Py_INCREF(Py_None); resultobj = Py_None;
37503 return resultobj;
37504 fail:
37505 return NULL;
37506 }
37507
37508
37509 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37510 PyObject *resultobj;
37511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37512 wxColour result;
37513 PyObject * obj0 = 0 ;
37514 char *kwnames[] = {
37515 (char *) "self", NULL
37516 };
37517
37518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37520 if (SWIG_arg_fail(1)) SWIG_fail;
37521 {
37522 PyThreadState* __tstate = wxPyBeginAllowThreads();
37523 result = wxMenuItem_GetTextColour(arg1);
37524
37525 wxPyEndAllowThreads(__tstate);
37526 if (PyErr_Occurred()) SWIG_fail;
37527 }
37528 {
37529 wxColour * resultptr;
37530 resultptr = new wxColour((wxColour &)(result));
37531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37532 }
37533 return resultobj;
37534 fail:
37535 return NULL;
37536 }
37537
37538
37539 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37540 PyObject *resultobj;
37541 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37542 wxColour *arg2 = 0 ;
37543 wxColour temp2 ;
37544 PyObject * obj0 = 0 ;
37545 PyObject * obj1 = 0 ;
37546 char *kwnames[] = {
37547 (char *) "self",(char *) "colBack", NULL
37548 };
37549
37550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37552 if (SWIG_arg_fail(1)) SWIG_fail;
37553 {
37554 arg2 = &temp2;
37555 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37556 }
37557 {
37558 PyThreadState* __tstate = wxPyBeginAllowThreads();
37559 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37560
37561 wxPyEndAllowThreads(__tstate);
37562 if (PyErr_Occurred()) SWIG_fail;
37563 }
37564 Py_INCREF(Py_None); resultobj = Py_None;
37565 return resultobj;
37566 fail:
37567 return NULL;
37568 }
37569
37570
37571 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37572 PyObject *resultobj;
37573 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37574 wxColour result;
37575 PyObject * obj0 = 0 ;
37576 char *kwnames[] = {
37577 (char *) "self", NULL
37578 };
37579
37580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37582 if (SWIG_arg_fail(1)) SWIG_fail;
37583 {
37584 PyThreadState* __tstate = wxPyBeginAllowThreads();
37585 result = wxMenuItem_GetBackgroundColour(arg1);
37586
37587 wxPyEndAllowThreads(__tstate);
37588 if (PyErr_Occurred()) SWIG_fail;
37589 }
37590 {
37591 wxColour * resultptr;
37592 resultptr = new wxColour((wxColour &)(result));
37593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37594 }
37595 return resultobj;
37596 fail:
37597 return NULL;
37598 }
37599
37600
37601 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37602 PyObject *resultobj;
37603 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37604 wxBitmap *arg2 = 0 ;
37605 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37606 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37607 PyObject * obj0 = 0 ;
37608 PyObject * obj1 = 0 ;
37609 PyObject * obj2 = 0 ;
37610 char *kwnames[] = {
37611 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37612 };
37613
37614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37616 if (SWIG_arg_fail(1)) SWIG_fail;
37617 {
37618 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37619 if (SWIG_arg_fail(2)) SWIG_fail;
37620 if (arg2 == NULL) {
37621 SWIG_null_ref("wxBitmap");
37622 }
37623 if (SWIG_arg_fail(2)) SWIG_fail;
37624 }
37625 if (obj2) {
37626 {
37627 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37628 if (SWIG_arg_fail(3)) SWIG_fail;
37629 if (arg3 == NULL) {
37630 SWIG_null_ref("wxBitmap");
37631 }
37632 if (SWIG_arg_fail(3)) SWIG_fail;
37633 }
37634 }
37635 {
37636 PyThreadState* __tstate = wxPyBeginAllowThreads();
37637 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37638
37639 wxPyEndAllowThreads(__tstate);
37640 if (PyErr_Occurred()) SWIG_fail;
37641 }
37642 Py_INCREF(Py_None); resultobj = Py_None;
37643 return resultobj;
37644 fail:
37645 return NULL;
37646 }
37647
37648
37649 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37650 PyObject *resultobj;
37651 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37652 wxBitmap *arg2 = 0 ;
37653 PyObject * obj0 = 0 ;
37654 PyObject * obj1 = 0 ;
37655 char *kwnames[] = {
37656 (char *) "self",(char *) "bmpDisabled", NULL
37657 };
37658
37659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37661 if (SWIG_arg_fail(1)) SWIG_fail;
37662 {
37663 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37664 if (SWIG_arg_fail(2)) SWIG_fail;
37665 if (arg2 == NULL) {
37666 SWIG_null_ref("wxBitmap");
37667 }
37668 if (SWIG_arg_fail(2)) SWIG_fail;
37669 }
37670 {
37671 PyThreadState* __tstate = wxPyBeginAllowThreads();
37672 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37673
37674 wxPyEndAllowThreads(__tstate);
37675 if (PyErr_Occurred()) SWIG_fail;
37676 }
37677 Py_INCREF(Py_None); resultobj = Py_None;
37678 return resultobj;
37679 fail:
37680 return NULL;
37681 }
37682
37683
37684 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37685 PyObject *resultobj;
37686 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37687 wxBitmap *result;
37688 PyObject * obj0 = 0 ;
37689 char *kwnames[] = {
37690 (char *) "self", NULL
37691 };
37692
37693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37695 if (SWIG_arg_fail(1)) SWIG_fail;
37696 {
37697 PyThreadState* __tstate = wxPyBeginAllowThreads();
37698 {
37699 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37700 result = (wxBitmap *) &_result_ref;
37701 }
37702
37703 wxPyEndAllowThreads(__tstate);
37704 if (PyErr_Occurred()) SWIG_fail;
37705 }
37706 {
37707 wxBitmap* resultptr = new wxBitmap(*result);
37708 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37709 }
37710 return resultobj;
37711 fail:
37712 return NULL;
37713 }
37714
37715
37716 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37717 PyObject *resultobj;
37718 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37719 int arg2 ;
37720 PyObject * obj0 = 0 ;
37721 PyObject * obj1 = 0 ;
37722 char *kwnames[] = {
37723 (char *) "self",(char *) "nWidth", NULL
37724 };
37725
37726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37728 if (SWIG_arg_fail(1)) SWIG_fail;
37729 {
37730 arg2 = (int)(SWIG_As_int(obj1));
37731 if (SWIG_arg_fail(2)) SWIG_fail;
37732 }
37733 {
37734 PyThreadState* __tstate = wxPyBeginAllowThreads();
37735 wxMenuItem_SetMarginWidth(arg1,arg2);
37736
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 Py_INCREF(Py_None); resultobj = Py_None;
37741 return resultobj;
37742 fail:
37743 return NULL;
37744 }
37745
37746
37747 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37748 PyObject *resultobj;
37749 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37750 int result;
37751 PyObject * obj0 = 0 ;
37752 char *kwnames[] = {
37753 (char *) "self", NULL
37754 };
37755
37756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37758 if (SWIG_arg_fail(1)) SWIG_fail;
37759 {
37760 PyThreadState* __tstate = wxPyBeginAllowThreads();
37761 result = (int)wxMenuItem_GetMarginWidth(arg1);
37762
37763 wxPyEndAllowThreads(__tstate);
37764 if (PyErr_Occurred()) SWIG_fail;
37765 }
37766 {
37767 resultobj = SWIG_From_int((int)(result));
37768 }
37769 return resultobj;
37770 fail:
37771 return NULL;
37772 }
37773
37774
37775 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37776 PyObject *resultobj;
37777 int result;
37778 char *kwnames[] = {
37779 NULL
37780 };
37781
37782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37783 {
37784 PyThreadState* __tstate = wxPyBeginAllowThreads();
37785 result = (int)MenuItem_GetDefaultMarginWidth();
37786
37787 wxPyEndAllowThreads(__tstate);
37788 if (PyErr_Occurred()) SWIG_fail;
37789 }
37790 {
37791 resultobj = SWIG_From_int((int)(result));
37792 }
37793 return resultobj;
37794 fail:
37795 return NULL;
37796 }
37797
37798
37799 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37800 PyObject *resultobj;
37801 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37802 bool result;
37803 PyObject * obj0 = 0 ;
37804 char *kwnames[] = {
37805 (char *) "self", NULL
37806 };
37807
37808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37810 if (SWIG_arg_fail(1)) SWIG_fail;
37811 {
37812 PyThreadState* __tstate = wxPyBeginAllowThreads();
37813 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37814
37815 wxPyEndAllowThreads(__tstate);
37816 if (PyErr_Occurred()) SWIG_fail;
37817 }
37818 {
37819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37820 }
37821 return resultobj;
37822 fail:
37823 return NULL;
37824 }
37825
37826
37827 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37828 PyObject *resultobj;
37829 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37830 bool arg2 = (bool) true ;
37831 PyObject * obj0 = 0 ;
37832 PyObject * obj1 = 0 ;
37833 char *kwnames[] = {
37834 (char *) "self",(char *) "ownerDrawn", NULL
37835 };
37836
37837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37839 if (SWIG_arg_fail(1)) SWIG_fail;
37840 if (obj1) {
37841 {
37842 arg2 = (bool)(SWIG_As_bool(obj1));
37843 if (SWIG_arg_fail(2)) SWIG_fail;
37844 }
37845 }
37846 {
37847 PyThreadState* __tstate = wxPyBeginAllowThreads();
37848 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37849
37850 wxPyEndAllowThreads(__tstate);
37851 if (PyErr_Occurred()) SWIG_fail;
37852 }
37853 Py_INCREF(Py_None); resultobj = Py_None;
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37861 PyObject *resultobj;
37862 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37863 PyObject * obj0 = 0 ;
37864 char *kwnames[] = {
37865 (char *) "self", NULL
37866 };
37867
37868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37870 if (SWIG_arg_fail(1)) SWIG_fail;
37871 {
37872 PyThreadState* __tstate = wxPyBeginAllowThreads();
37873 wxMenuItem_ResetOwnerDrawn(arg1);
37874
37875 wxPyEndAllowThreads(__tstate);
37876 if (PyErr_Occurred()) SWIG_fail;
37877 }
37878 Py_INCREF(Py_None); resultobj = Py_None;
37879 return resultobj;
37880 fail:
37881 return NULL;
37882 }
37883
37884
37885 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37886 PyObject *resultobj;
37887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37888 wxBitmap *arg2 = 0 ;
37889 PyObject * obj0 = 0 ;
37890 PyObject * obj1 = 0 ;
37891 char *kwnames[] = {
37892 (char *) "self",(char *) "bitmap", NULL
37893 };
37894
37895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37897 if (SWIG_arg_fail(1)) SWIG_fail;
37898 {
37899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37900 if (SWIG_arg_fail(2)) SWIG_fail;
37901 if (arg2 == NULL) {
37902 SWIG_null_ref("wxBitmap");
37903 }
37904 if (SWIG_arg_fail(2)) SWIG_fail;
37905 }
37906 {
37907 PyThreadState* __tstate = wxPyBeginAllowThreads();
37908 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37909
37910 wxPyEndAllowThreads(__tstate);
37911 if (PyErr_Occurred()) SWIG_fail;
37912 }
37913 Py_INCREF(Py_None); resultobj = Py_None;
37914 return resultobj;
37915 fail:
37916 return NULL;
37917 }
37918
37919
37920 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37921 PyObject *resultobj;
37922 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37923 wxBitmap *result;
37924 PyObject * obj0 = 0 ;
37925 char *kwnames[] = {
37926 (char *) "self", NULL
37927 };
37928
37929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37931 if (SWIG_arg_fail(1)) SWIG_fail;
37932 {
37933 PyThreadState* __tstate = wxPyBeginAllowThreads();
37934 {
37935 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37936 result = (wxBitmap *) &_result_ref;
37937 }
37938
37939 wxPyEndAllowThreads(__tstate);
37940 if (PyErr_Occurred()) SWIG_fail;
37941 }
37942 {
37943 wxBitmap* resultptr = new wxBitmap(*result);
37944 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37945 }
37946 return resultobj;
37947 fail:
37948 return NULL;
37949 }
37950
37951
37952 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37953 PyObject *obj;
37954 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37955 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37956 Py_INCREF(obj);
37957 return Py_BuildValue((char *)"");
37958 }
37959 static int _wrap_ControlNameStr_set(PyObject *) {
37960 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37961 return 1;
37962 }
37963
37964
37965 static PyObject *_wrap_ControlNameStr_get(void) {
37966 PyObject *pyobj;
37967
37968 {
37969 #if wxUSE_UNICODE
37970 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37971 #else
37972 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37973 #endif
37974 }
37975 return pyobj;
37976 }
37977
37978
37979 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37980 PyObject *resultobj;
37981 wxWindow *arg1 = (wxWindow *) 0 ;
37982 int arg2 = (int) -1 ;
37983 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37984 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37985 wxSize const &arg4_defvalue = wxDefaultSize ;
37986 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37987 long arg5 = (long) 0 ;
37988 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37989 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37990 wxString const &arg7_defvalue = wxPyControlNameStr ;
37991 wxString *arg7 = (wxString *) &arg7_defvalue ;
37992 wxControl *result;
37993 wxPoint temp3 ;
37994 wxSize temp4 ;
37995 bool temp7 = false ;
37996 PyObject * obj0 = 0 ;
37997 PyObject * obj1 = 0 ;
37998 PyObject * obj2 = 0 ;
37999 PyObject * obj3 = 0 ;
38000 PyObject * obj4 = 0 ;
38001 PyObject * obj5 = 0 ;
38002 PyObject * obj6 = 0 ;
38003 char *kwnames[] = {
38004 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38005 };
38006
38007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38009 if (SWIG_arg_fail(1)) SWIG_fail;
38010 if (obj1) {
38011 {
38012 arg2 = (int)(SWIG_As_int(obj1));
38013 if (SWIG_arg_fail(2)) SWIG_fail;
38014 }
38015 }
38016 if (obj2) {
38017 {
38018 arg3 = &temp3;
38019 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38020 }
38021 }
38022 if (obj3) {
38023 {
38024 arg4 = &temp4;
38025 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38026 }
38027 }
38028 if (obj4) {
38029 {
38030 arg5 = (long)(SWIG_As_long(obj4));
38031 if (SWIG_arg_fail(5)) SWIG_fail;
38032 }
38033 }
38034 if (obj5) {
38035 {
38036 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38037 if (SWIG_arg_fail(6)) SWIG_fail;
38038 if (arg6 == NULL) {
38039 SWIG_null_ref("wxValidator");
38040 }
38041 if (SWIG_arg_fail(6)) SWIG_fail;
38042 }
38043 }
38044 if (obj6) {
38045 {
38046 arg7 = wxString_in_helper(obj6);
38047 if (arg7 == NULL) SWIG_fail;
38048 temp7 = true;
38049 }
38050 }
38051 {
38052 if (!wxPyCheckForApp()) SWIG_fail;
38053 PyThreadState* __tstate = wxPyBeginAllowThreads();
38054 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38055
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38060 {
38061 if (temp7)
38062 delete arg7;
38063 }
38064 return resultobj;
38065 fail:
38066 {
38067 if (temp7)
38068 delete arg7;
38069 }
38070 return NULL;
38071 }
38072
38073
38074 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38075 PyObject *resultobj;
38076 wxControl *result;
38077 char *kwnames[] = {
38078 NULL
38079 };
38080
38081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38082 {
38083 if (!wxPyCheckForApp()) SWIG_fail;
38084 PyThreadState* __tstate = wxPyBeginAllowThreads();
38085 result = (wxControl *)new wxControl();
38086
38087 wxPyEndAllowThreads(__tstate);
38088 if (PyErr_Occurred()) SWIG_fail;
38089 }
38090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38091 return resultobj;
38092 fail:
38093 return NULL;
38094 }
38095
38096
38097 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38098 PyObject *resultobj;
38099 wxControl *arg1 = (wxControl *) 0 ;
38100 wxWindow *arg2 = (wxWindow *) 0 ;
38101 int arg3 = (int) -1 ;
38102 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38103 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38104 wxSize const &arg5_defvalue = wxDefaultSize ;
38105 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38106 long arg6 = (long) 0 ;
38107 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38108 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38109 wxString const &arg8_defvalue = wxPyControlNameStr ;
38110 wxString *arg8 = (wxString *) &arg8_defvalue ;
38111 bool result;
38112 wxPoint temp4 ;
38113 wxSize temp5 ;
38114 bool temp8 = false ;
38115 PyObject * obj0 = 0 ;
38116 PyObject * obj1 = 0 ;
38117 PyObject * obj2 = 0 ;
38118 PyObject * obj3 = 0 ;
38119 PyObject * obj4 = 0 ;
38120 PyObject * obj5 = 0 ;
38121 PyObject * obj6 = 0 ;
38122 PyObject * obj7 = 0 ;
38123 char *kwnames[] = {
38124 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38125 };
38126
38127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38129 if (SWIG_arg_fail(1)) SWIG_fail;
38130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38131 if (SWIG_arg_fail(2)) SWIG_fail;
38132 if (obj2) {
38133 {
38134 arg3 = (int)(SWIG_As_int(obj2));
38135 if (SWIG_arg_fail(3)) SWIG_fail;
38136 }
38137 }
38138 if (obj3) {
38139 {
38140 arg4 = &temp4;
38141 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38142 }
38143 }
38144 if (obj4) {
38145 {
38146 arg5 = &temp5;
38147 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38148 }
38149 }
38150 if (obj5) {
38151 {
38152 arg6 = (long)(SWIG_As_long(obj5));
38153 if (SWIG_arg_fail(6)) SWIG_fail;
38154 }
38155 }
38156 if (obj6) {
38157 {
38158 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38159 if (SWIG_arg_fail(7)) SWIG_fail;
38160 if (arg7 == NULL) {
38161 SWIG_null_ref("wxValidator");
38162 }
38163 if (SWIG_arg_fail(7)) SWIG_fail;
38164 }
38165 }
38166 if (obj7) {
38167 {
38168 arg8 = wxString_in_helper(obj7);
38169 if (arg8 == NULL) SWIG_fail;
38170 temp8 = true;
38171 }
38172 }
38173 {
38174 PyThreadState* __tstate = wxPyBeginAllowThreads();
38175 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38176
38177 wxPyEndAllowThreads(__tstate);
38178 if (PyErr_Occurred()) SWIG_fail;
38179 }
38180 {
38181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38182 }
38183 {
38184 if (temp8)
38185 delete arg8;
38186 }
38187 return resultobj;
38188 fail:
38189 {
38190 if (temp8)
38191 delete arg8;
38192 }
38193 return NULL;
38194 }
38195
38196
38197 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38198 PyObject *resultobj;
38199 wxControl *arg1 = (wxControl *) 0 ;
38200 wxCommandEvent *arg2 = 0 ;
38201 PyObject * obj0 = 0 ;
38202 PyObject * obj1 = 0 ;
38203 char *kwnames[] = {
38204 (char *) "self",(char *) "event", NULL
38205 };
38206
38207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38209 if (SWIG_arg_fail(1)) SWIG_fail;
38210 {
38211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38212 if (SWIG_arg_fail(2)) SWIG_fail;
38213 if (arg2 == NULL) {
38214 SWIG_null_ref("wxCommandEvent");
38215 }
38216 if (SWIG_arg_fail(2)) SWIG_fail;
38217 }
38218 {
38219 PyThreadState* __tstate = wxPyBeginAllowThreads();
38220 (arg1)->Command(*arg2);
38221
38222 wxPyEndAllowThreads(__tstate);
38223 if (PyErr_Occurred()) SWIG_fail;
38224 }
38225 Py_INCREF(Py_None); resultobj = Py_None;
38226 return resultobj;
38227 fail:
38228 return NULL;
38229 }
38230
38231
38232 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38233 PyObject *resultobj;
38234 wxControl *arg1 = (wxControl *) 0 ;
38235 wxString result;
38236 PyObject * obj0 = 0 ;
38237 char *kwnames[] = {
38238 (char *) "self", NULL
38239 };
38240
38241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38243 if (SWIG_arg_fail(1)) SWIG_fail;
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 result = (arg1)->GetLabel();
38247
38248 wxPyEndAllowThreads(__tstate);
38249 if (PyErr_Occurred()) SWIG_fail;
38250 }
38251 {
38252 #if wxUSE_UNICODE
38253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38254 #else
38255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38256 #endif
38257 }
38258 return resultobj;
38259 fail:
38260 return NULL;
38261 }
38262
38263
38264 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38265 PyObject *resultobj;
38266 wxControl *arg1 = (wxControl *) 0 ;
38267 wxString *arg2 = 0 ;
38268 bool temp2 = false ;
38269 PyObject * obj0 = 0 ;
38270 PyObject * obj1 = 0 ;
38271 char *kwnames[] = {
38272 (char *) "self",(char *) "label", NULL
38273 };
38274
38275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38277 if (SWIG_arg_fail(1)) SWIG_fail;
38278 {
38279 arg2 = wxString_in_helper(obj1);
38280 if (arg2 == NULL) SWIG_fail;
38281 temp2 = true;
38282 }
38283 {
38284 PyThreadState* __tstate = wxPyBeginAllowThreads();
38285 (arg1)->SetLabel((wxString const &)*arg2);
38286
38287 wxPyEndAllowThreads(__tstate);
38288 if (PyErr_Occurred()) SWIG_fail;
38289 }
38290 Py_INCREF(Py_None); resultobj = Py_None;
38291 {
38292 if (temp2)
38293 delete arg2;
38294 }
38295 return resultobj;
38296 fail:
38297 {
38298 if (temp2)
38299 delete arg2;
38300 }
38301 return NULL;
38302 }
38303
38304
38305 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38306 PyObject *resultobj;
38307 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38308 wxVisualAttributes result;
38309 PyObject * obj0 = 0 ;
38310 char *kwnames[] = {
38311 (char *) "variant", NULL
38312 };
38313
38314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38315 if (obj0) {
38316 {
38317 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
38318 if (SWIG_arg_fail(1)) SWIG_fail;
38319 }
38320 }
38321 {
38322 if (!wxPyCheckForApp()) SWIG_fail;
38323 PyThreadState* __tstate = wxPyBeginAllowThreads();
38324 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
38325
38326 wxPyEndAllowThreads(__tstate);
38327 if (PyErr_Occurred()) SWIG_fail;
38328 }
38329 {
38330 wxVisualAttributes * resultptr;
38331 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
38332 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38333 }
38334 return resultobj;
38335 fail:
38336 return NULL;
38337 }
38338
38339
38340 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38341 PyObject *obj;
38342 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38343 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38344 Py_INCREF(obj);
38345 return Py_BuildValue((char *)"");
38346 }
38347 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38348 PyObject *resultobj;
38349 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38350 wxString *arg2 = 0 ;
38351 PyObject *arg3 = (PyObject *) NULL ;
38352 int result;
38353 bool temp2 = false ;
38354 PyObject * obj0 = 0 ;
38355 PyObject * obj1 = 0 ;
38356 PyObject * obj2 = 0 ;
38357 char *kwnames[] = {
38358 (char *) "self",(char *) "item",(char *) "clientData", NULL
38359 };
38360
38361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38363 if (SWIG_arg_fail(1)) SWIG_fail;
38364 {
38365 arg2 = wxString_in_helper(obj1);
38366 if (arg2 == NULL) SWIG_fail;
38367 temp2 = true;
38368 }
38369 if (obj2) {
38370 arg3 = obj2;
38371 }
38372 {
38373 PyThreadState* __tstate = wxPyBeginAllowThreads();
38374 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38375
38376 wxPyEndAllowThreads(__tstate);
38377 if (PyErr_Occurred()) SWIG_fail;
38378 }
38379 {
38380 resultobj = SWIG_From_int((int)(result));
38381 }
38382 {
38383 if (temp2)
38384 delete arg2;
38385 }
38386 return resultobj;
38387 fail:
38388 {
38389 if (temp2)
38390 delete arg2;
38391 }
38392 return NULL;
38393 }
38394
38395
38396 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38397 PyObject *resultobj;
38398 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38399 wxArrayString *arg2 = 0 ;
38400 bool temp2 = false ;
38401 PyObject * obj0 = 0 ;
38402 PyObject * obj1 = 0 ;
38403 char *kwnames[] = {
38404 (char *) "self",(char *) "strings", NULL
38405 };
38406
38407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38409 if (SWIG_arg_fail(1)) SWIG_fail;
38410 {
38411 if (! PySequence_Check(obj1)) {
38412 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38413 SWIG_fail;
38414 }
38415 arg2 = new wxArrayString;
38416 temp2 = true;
38417 int i, len=PySequence_Length(obj1);
38418 for (i=0; i<len; i++) {
38419 PyObject* item = PySequence_GetItem(obj1, i);
38420 wxString* s = wxString_in_helper(item);
38421 if (PyErr_Occurred()) SWIG_fail;
38422 arg2->Add(*s);
38423 delete s;
38424 Py_DECREF(item);
38425 }
38426 }
38427 {
38428 PyThreadState* __tstate = wxPyBeginAllowThreads();
38429 (arg1)->Append((wxArrayString const &)*arg2);
38430
38431 wxPyEndAllowThreads(__tstate);
38432 if (PyErr_Occurred()) SWIG_fail;
38433 }
38434 Py_INCREF(Py_None); resultobj = Py_None;
38435 {
38436 if (temp2) delete arg2;
38437 }
38438 return resultobj;
38439 fail:
38440 {
38441 if (temp2) delete arg2;
38442 }
38443 return NULL;
38444 }
38445
38446
38447 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38448 PyObject *resultobj;
38449 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38450 wxString *arg2 = 0 ;
38451 int arg3 ;
38452 PyObject *arg4 = (PyObject *) NULL ;
38453 int result;
38454 bool temp2 = false ;
38455 PyObject * obj0 = 0 ;
38456 PyObject * obj1 = 0 ;
38457 PyObject * obj2 = 0 ;
38458 PyObject * obj3 = 0 ;
38459 char *kwnames[] = {
38460 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38461 };
38462
38463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38465 if (SWIG_arg_fail(1)) SWIG_fail;
38466 {
38467 arg2 = wxString_in_helper(obj1);
38468 if (arg2 == NULL) SWIG_fail;
38469 temp2 = true;
38470 }
38471 {
38472 arg3 = (int)(SWIG_As_int(obj2));
38473 if (SWIG_arg_fail(3)) SWIG_fail;
38474 }
38475 if (obj3) {
38476 arg4 = obj3;
38477 }
38478 {
38479 PyThreadState* __tstate = wxPyBeginAllowThreads();
38480 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38481
38482 wxPyEndAllowThreads(__tstate);
38483 if (PyErr_Occurred()) SWIG_fail;
38484 }
38485 {
38486 resultobj = SWIG_From_int((int)(result));
38487 }
38488 {
38489 if (temp2)
38490 delete arg2;
38491 }
38492 return resultobj;
38493 fail:
38494 {
38495 if (temp2)
38496 delete arg2;
38497 }
38498 return NULL;
38499 }
38500
38501
38502 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38503 PyObject *resultobj;
38504 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38505 PyObject * obj0 = 0 ;
38506 char *kwnames[] = {
38507 (char *) "self", NULL
38508 };
38509
38510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38512 if (SWIG_arg_fail(1)) SWIG_fail;
38513 {
38514 PyThreadState* __tstate = wxPyBeginAllowThreads();
38515 (arg1)->Clear();
38516
38517 wxPyEndAllowThreads(__tstate);
38518 if (PyErr_Occurred()) SWIG_fail;
38519 }
38520 Py_INCREF(Py_None); resultobj = Py_None;
38521 return resultobj;
38522 fail:
38523 return NULL;
38524 }
38525
38526
38527 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38528 PyObject *resultobj;
38529 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38530 int arg2 ;
38531 PyObject * obj0 = 0 ;
38532 PyObject * obj1 = 0 ;
38533 char *kwnames[] = {
38534 (char *) "self",(char *) "n", NULL
38535 };
38536
38537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38539 if (SWIG_arg_fail(1)) SWIG_fail;
38540 {
38541 arg2 = (int)(SWIG_As_int(obj1));
38542 if (SWIG_arg_fail(2)) SWIG_fail;
38543 }
38544 {
38545 PyThreadState* __tstate = wxPyBeginAllowThreads();
38546 (arg1)->Delete(arg2);
38547
38548 wxPyEndAllowThreads(__tstate);
38549 if (PyErr_Occurred()) SWIG_fail;
38550 }
38551 Py_INCREF(Py_None); resultobj = Py_None;
38552 return resultobj;
38553 fail:
38554 return NULL;
38555 }
38556
38557
38558 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38559 PyObject *resultobj;
38560 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38561 int arg2 ;
38562 PyObject *result;
38563 PyObject * obj0 = 0 ;
38564 PyObject * obj1 = 0 ;
38565 char *kwnames[] = {
38566 (char *) "self",(char *) "n", NULL
38567 };
38568
38569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38571 if (SWIG_arg_fail(1)) SWIG_fail;
38572 {
38573 arg2 = (int)(SWIG_As_int(obj1));
38574 if (SWIG_arg_fail(2)) SWIG_fail;
38575 }
38576 {
38577 PyThreadState* __tstate = wxPyBeginAllowThreads();
38578 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38579
38580 wxPyEndAllowThreads(__tstate);
38581 if (PyErr_Occurred()) SWIG_fail;
38582 }
38583 resultobj = result;
38584 return resultobj;
38585 fail:
38586 return NULL;
38587 }
38588
38589
38590 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38591 PyObject *resultobj;
38592 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38593 int arg2 ;
38594 PyObject *arg3 = (PyObject *) 0 ;
38595 PyObject * obj0 = 0 ;
38596 PyObject * obj1 = 0 ;
38597 PyObject * obj2 = 0 ;
38598 char *kwnames[] = {
38599 (char *) "self",(char *) "n",(char *) "clientData", NULL
38600 };
38601
38602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38604 if (SWIG_arg_fail(1)) SWIG_fail;
38605 {
38606 arg2 = (int)(SWIG_As_int(obj1));
38607 if (SWIG_arg_fail(2)) SWIG_fail;
38608 }
38609 arg3 = obj2;
38610 {
38611 PyThreadState* __tstate = wxPyBeginAllowThreads();
38612 wxItemContainer_SetClientData(arg1,arg2,arg3);
38613
38614 wxPyEndAllowThreads(__tstate);
38615 if (PyErr_Occurred()) SWIG_fail;
38616 }
38617 Py_INCREF(Py_None); resultobj = Py_None;
38618 return resultobj;
38619 fail:
38620 return NULL;
38621 }
38622
38623
38624 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38625 PyObject *resultobj;
38626 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38627 int result;
38628 PyObject * obj0 = 0 ;
38629 char *kwnames[] = {
38630 (char *) "self", NULL
38631 };
38632
38633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38635 if (SWIG_arg_fail(1)) SWIG_fail;
38636 {
38637 PyThreadState* __tstate = wxPyBeginAllowThreads();
38638 result = (int)((wxItemContainer const *)arg1)->GetCount();
38639
38640 wxPyEndAllowThreads(__tstate);
38641 if (PyErr_Occurred()) SWIG_fail;
38642 }
38643 {
38644 resultobj = SWIG_From_int((int)(result));
38645 }
38646 return resultobj;
38647 fail:
38648 return NULL;
38649 }
38650
38651
38652 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38653 PyObject *resultobj;
38654 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38655 bool result;
38656 PyObject * obj0 = 0 ;
38657 char *kwnames[] = {
38658 (char *) "self", NULL
38659 };
38660
38661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38663 if (SWIG_arg_fail(1)) SWIG_fail;
38664 {
38665 PyThreadState* __tstate = wxPyBeginAllowThreads();
38666 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38667
38668 wxPyEndAllowThreads(__tstate);
38669 if (PyErr_Occurred()) SWIG_fail;
38670 }
38671 {
38672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38673 }
38674 return resultobj;
38675 fail:
38676 return NULL;
38677 }
38678
38679
38680 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38681 PyObject *resultobj;
38682 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38683 int arg2 ;
38684 wxString result;
38685 PyObject * obj0 = 0 ;
38686 PyObject * obj1 = 0 ;
38687 char *kwnames[] = {
38688 (char *) "self",(char *) "n", NULL
38689 };
38690
38691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38693 if (SWIG_arg_fail(1)) SWIG_fail;
38694 {
38695 arg2 = (int)(SWIG_As_int(obj1));
38696 if (SWIG_arg_fail(2)) SWIG_fail;
38697 }
38698 {
38699 PyThreadState* __tstate = wxPyBeginAllowThreads();
38700 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38701
38702 wxPyEndAllowThreads(__tstate);
38703 if (PyErr_Occurred()) SWIG_fail;
38704 }
38705 {
38706 #if wxUSE_UNICODE
38707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38708 #else
38709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38710 #endif
38711 }
38712 return resultobj;
38713 fail:
38714 return NULL;
38715 }
38716
38717
38718 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38719 PyObject *resultobj;
38720 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38721 wxArrayString result;
38722 PyObject * obj0 = 0 ;
38723 char *kwnames[] = {
38724 (char *) "self", NULL
38725 };
38726
38727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38729 if (SWIG_arg_fail(1)) SWIG_fail;
38730 {
38731 PyThreadState* __tstate = wxPyBeginAllowThreads();
38732 result = ((wxItemContainer const *)arg1)->GetStrings();
38733
38734 wxPyEndAllowThreads(__tstate);
38735 if (PyErr_Occurred()) SWIG_fail;
38736 }
38737 {
38738 resultobj = wxArrayString2PyList_helper(result);
38739 }
38740 return resultobj;
38741 fail:
38742 return NULL;
38743 }
38744
38745
38746 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38747 PyObject *resultobj;
38748 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38749 int arg2 ;
38750 wxString *arg3 = 0 ;
38751 bool temp3 = false ;
38752 PyObject * obj0 = 0 ;
38753 PyObject * obj1 = 0 ;
38754 PyObject * obj2 = 0 ;
38755 char *kwnames[] = {
38756 (char *) "self",(char *) "n",(char *) "s", NULL
38757 };
38758
38759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38761 if (SWIG_arg_fail(1)) SWIG_fail;
38762 {
38763 arg2 = (int)(SWIG_As_int(obj1));
38764 if (SWIG_arg_fail(2)) SWIG_fail;
38765 }
38766 {
38767 arg3 = wxString_in_helper(obj2);
38768 if (arg3 == NULL) SWIG_fail;
38769 temp3 = true;
38770 }
38771 {
38772 PyThreadState* __tstate = wxPyBeginAllowThreads();
38773 (arg1)->SetString(arg2,(wxString const &)*arg3);
38774
38775 wxPyEndAllowThreads(__tstate);
38776 if (PyErr_Occurred()) SWIG_fail;
38777 }
38778 Py_INCREF(Py_None); resultobj = Py_None;
38779 {
38780 if (temp3)
38781 delete arg3;
38782 }
38783 return resultobj;
38784 fail:
38785 {
38786 if (temp3)
38787 delete arg3;
38788 }
38789 return NULL;
38790 }
38791
38792
38793 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38794 PyObject *resultobj;
38795 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38796 wxString *arg2 = 0 ;
38797 int result;
38798 bool temp2 = false ;
38799 PyObject * obj0 = 0 ;
38800 PyObject * obj1 = 0 ;
38801 char *kwnames[] = {
38802 (char *) "self",(char *) "s", NULL
38803 };
38804
38805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38807 if (SWIG_arg_fail(1)) SWIG_fail;
38808 {
38809 arg2 = wxString_in_helper(obj1);
38810 if (arg2 == NULL) SWIG_fail;
38811 temp2 = true;
38812 }
38813 {
38814 PyThreadState* __tstate = wxPyBeginAllowThreads();
38815 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38816
38817 wxPyEndAllowThreads(__tstate);
38818 if (PyErr_Occurred()) SWIG_fail;
38819 }
38820 {
38821 resultobj = SWIG_From_int((int)(result));
38822 }
38823 {
38824 if (temp2)
38825 delete arg2;
38826 }
38827 return resultobj;
38828 fail:
38829 {
38830 if (temp2)
38831 delete arg2;
38832 }
38833 return NULL;
38834 }
38835
38836
38837 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38838 PyObject *resultobj;
38839 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38840 int arg2 ;
38841 PyObject * obj0 = 0 ;
38842 PyObject * obj1 = 0 ;
38843 char *kwnames[] = {
38844 (char *) "self",(char *) "n", NULL
38845 };
38846
38847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38849 if (SWIG_arg_fail(1)) SWIG_fail;
38850 {
38851 arg2 = (int)(SWIG_As_int(obj1));
38852 if (SWIG_arg_fail(2)) SWIG_fail;
38853 }
38854 {
38855 PyThreadState* __tstate = wxPyBeginAllowThreads();
38856 (arg1)->SetSelection(arg2);
38857
38858 wxPyEndAllowThreads(__tstate);
38859 if (PyErr_Occurred()) SWIG_fail;
38860 }
38861 Py_INCREF(Py_None); resultobj = Py_None;
38862 return resultobj;
38863 fail:
38864 return NULL;
38865 }
38866
38867
38868 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38869 PyObject *resultobj;
38870 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38871 int result;
38872 PyObject * obj0 = 0 ;
38873 char *kwnames[] = {
38874 (char *) "self", NULL
38875 };
38876
38877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38879 if (SWIG_arg_fail(1)) SWIG_fail;
38880 {
38881 PyThreadState* __tstate = wxPyBeginAllowThreads();
38882 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38883
38884 wxPyEndAllowThreads(__tstate);
38885 if (PyErr_Occurred()) SWIG_fail;
38886 }
38887 {
38888 resultobj = SWIG_From_int((int)(result));
38889 }
38890 return resultobj;
38891 fail:
38892 return NULL;
38893 }
38894
38895
38896 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38897 PyObject *resultobj;
38898 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38899 wxString *arg2 = 0 ;
38900 bool result;
38901 bool temp2 = false ;
38902 PyObject * obj0 = 0 ;
38903 PyObject * obj1 = 0 ;
38904 char *kwnames[] = {
38905 (char *) "self",(char *) "s", NULL
38906 };
38907
38908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38910 if (SWIG_arg_fail(1)) SWIG_fail;
38911 {
38912 arg2 = wxString_in_helper(obj1);
38913 if (arg2 == NULL) SWIG_fail;
38914 temp2 = true;
38915 }
38916 {
38917 PyThreadState* __tstate = wxPyBeginAllowThreads();
38918 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38919
38920 wxPyEndAllowThreads(__tstate);
38921 if (PyErr_Occurred()) SWIG_fail;
38922 }
38923 {
38924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38925 }
38926 {
38927 if (temp2)
38928 delete arg2;
38929 }
38930 return resultobj;
38931 fail:
38932 {
38933 if (temp2)
38934 delete arg2;
38935 }
38936 return NULL;
38937 }
38938
38939
38940 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38941 PyObject *resultobj;
38942 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38943 wxString result;
38944 PyObject * obj0 = 0 ;
38945 char *kwnames[] = {
38946 (char *) "self", NULL
38947 };
38948
38949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38951 if (SWIG_arg_fail(1)) SWIG_fail;
38952 {
38953 PyThreadState* __tstate = wxPyBeginAllowThreads();
38954 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38955
38956 wxPyEndAllowThreads(__tstate);
38957 if (PyErr_Occurred()) SWIG_fail;
38958 }
38959 {
38960 #if wxUSE_UNICODE
38961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38962 #else
38963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38964 #endif
38965 }
38966 return resultobj;
38967 fail:
38968 return NULL;
38969 }
38970
38971
38972 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38973 PyObject *resultobj;
38974 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38975 int arg2 ;
38976 PyObject * obj0 = 0 ;
38977 PyObject * obj1 = 0 ;
38978 char *kwnames[] = {
38979 (char *) "self",(char *) "n", NULL
38980 };
38981
38982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38984 if (SWIG_arg_fail(1)) SWIG_fail;
38985 {
38986 arg2 = (int)(SWIG_As_int(obj1));
38987 if (SWIG_arg_fail(2)) SWIG_fail;
38988 }
38989 {
38990 PyThreadState* __tstate = wxPyBeginAllowThreads();
38991 (arg1)->Select(arg2);
38992
38993 wxPyEndAllowThreads(__tstate);
38994 if (PyErr_Occurred()) SWIG_fail;
38995 }
38996 Py_INCREF(Py_None); resultobj = Py_None;
38997 return resultobj;
38998 fail:
38999 return NULL;
39000 }
39001
39002
39003 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39004 PyObject *obj;
39005 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39006 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39007 Py_INCREF(obj);
39008 return Py_BuildValue((char *)"");
39009 }
39010 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39011 PyObject *obj;
39012 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39013 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39014 Py_INCREF(obj);
39015 return Py_BuildValue((char *)"");
39016 }
39017 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39018 PyObject *resultobj;
39019 wxSizerItem *result;
39020 char *kwnames[] = {
39021 NULL
39022 };
39023
39024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39025 {
39026 PyThreadState* __tstate = wxPyBeginAllowThreads();
39027 result = (wxSizerItem *)new wxSizerItem();
39028
39029 wxPyEndAllowThreads(__tstate);
39030 if (PyErr_Occurred()) SWIG_fail;
39031 }
39032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39033 return resultobj;
39034 fail:
39035 return NULL;
39036 }
39037
39038
39039 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39040 PyObject *resultobj;
39041 wxWindow *arg1 = (wxWindow *) 0 ;
39042 int arg2 ;
39043 int arg3 ;
39044 int arg4 ;
39045 PyObject *arg5 = (PyObject *) NULL ;
39046 wxSizerItem *result;
39047 PyObject * obj0 = 0 ;
39048 PyObject * obj1 = 0 ;
39049 PyObject * obj2 = 0 ;
39050 PyObject * obj3 = 0 ;
39051 PyObject * obj4 = 0 ;
39052 char *kwnames[] = {
39053 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39054 };
39055
39056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39058 if (SWIG_arg_fail(1)) SWIG_fail;
39059 {
39060 arg2 = (int)(SWIG_As_int(obj1));
39061 if (SWIG_arg_fail(2)) SWIG_fail;
39062 }
39063 {
39064 arg3 = (int)(SWIG_As_int(obj2));
39065 if (SWIG_arg_fail(3)) SWIG_fail;
39066 }
39067 {
39068 arg4 = (int)(SWIG_As_int(obj3));
39069 if (SWIG_arg_fail(4)) SWIG_fail;
39070 }
39071 if (obj4) {
39072 arg5 = obj4;
39073 }
39074 {
39075 PyThreadState* __tstate = wxPyBeginAllowThreads();
39076 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39077
39078 wxPyEndAllowThreads(__tstate);
39079 if (PyErr_Occurred()) SWIG_fail;
39080 }
39081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39082 return resultobj;
39083 fail:
39084 return NULL;
39085 }
39086
39087
39088 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39089 PyObject *resultobj;
39090 int arg1 ;
39091 int arg2 ;
39092 int arg3 ;
39093 int arg4 ;
39094 int arg5 ;
39095 PyObject *arg6 = (PyObject *) NULL ;
39096 wxSizerItem *result;
39097 PyObject * obj0 = 0 ;
39098 PyObject * obj1 = 0 ;
39099 PyObject * obj2 = 0 ;
39100 PyObject * obj3 = 0 ;
39101 PyObject * obj4 = 0 ;
39102 PyObject * obj5 = 0 ;
39103 char *kwnames[] = {
39104 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39105 };
39106
39107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39108 {
39109 arg1 = (int)(SWIG_As_int(obj0));
39110 if (SWIG_arg_fail(1)) SWIG_fail;
39111 }
39112 {
39113 arg2 = (int)(SWIG_As_int(obj1));
39114 if (SWIG_arg_fail(2)) SWIG_fail;
39115 }
39116 {
39117 arg3 = (int)(SWIG_As_int(obj2));
39118 if (SWIG_arg_fail(3)) SWIG_fail;
39119 }
39120 {
39121 arg4 = (int)(SWIG_As_int(obj3));
39122 if (SWIG_arg_fail(4)) SWIG_fail;
39123 }
39124 {
39125 arg5 = (int)(SWIG_As_int(obj4));
39126 if (SWIG_arg_fail(5)) SWIG_fail;
39127 }
39128 if (obj5) {
39129 arg6 = obj5;
39130 }
39131 {
39132 PyThreadState* __tstate = wxPyBeginAllowThreads();
39133 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39134
39135 wxPyEndAllowThreads(__tstate);
39136 if (PyErr_Occurred()) SWIG_fail;
39137 }
39138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39139 return resultobj;
39140 fail:
39141 return NULL;
39142 }
39143
39144
39145 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39146 PyObject *resultobj;
39147 wxSizer *arg1 = (wxSizer *) 0 ;
39148 int arg2 ;
39149 int arg3 ;
39150 int arg4 ;
39151 PyObject *arg5 = (PyObject *) NULL ;
39152 wxSizerItem *result;
39153 PyObject * obj0 = 0 ;
39154 PyObject * obj1 = 0 ;
39155 PyObject * obj2 = 0 ;
39156 PyObject * obj3 = 0 ;
39157 PyObject * obj4 = 0 ;
39158 char *kwnames[] = {
39159 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39160 };
39161
39162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39164 if (SWIG_arg_fail(1)) SWIG_fail;
39165 {
39166 arg2 = (int)(SWIG_As_int(obj1));
39167 if (SWIG_arg_fail(2)) SWIG_fail;
39168 }
39169 {
39170 arg3 = (int)(SWIG_As_int(obj2));
39171 if (SWIG_arg_fail(3)) SWIG_fail;
39172 }
39173 {
39174 arg4 = (int)(SWIG_As_int(obj3));
39175 if (SWIG_arg_fail(4)) SWIG_fail;
39176 }
39177 if (obj4) {
39178 arg5 = obj4;
39179 }
39180 {
39181 PyThreadState* __tstate = wxPyBeginAllowThreads();
39182 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39183
39184 wxPyEndAllowThreads(__tstate);
39185 if (PyErr_Occurred()) SWIG_fail;
39186 }
39187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39188 return resultobj;
39189 fail:
39190 return NULL;
39191 }
39192
39193
39194 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39195 PyObject *resultobj;
39196 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39197 PyObject * obj0 = 0 ;
39198 char *kwnames[] = {
39199 (char *) "self", NULL
39200 };
39201
39202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39204 if (SWIG_arg_fail(1)) SWIG_fail;
39205 {
39206 PyThreadState* __tstate = wxPyBeginAllowThreads();
39207 (arg1)->DeleteWindows();
39208
39209 wxPyEndAllowThreads(__tstate);
39210 if (PyErr_Occurred()) SWIG_fail;
39211 }
39212 Py_INCREF(Py_None); resultobj = Py_None;
39213 return resultobj;
39214 fail:
39215 return NULL;
39216 }
39217
39218
39219 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39220 PyObject *resultobj;
39221 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39222 PyObject * obj0 = 0 ;
39223 char *kwnames[] = {
39224 (char *) "self", NULL
39225 };
39226
39227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39229 if (SWIG_arg_fail(1)) SWIG_fail;
39230 {
39231 PyThreadState* __tstate = wxPyBeginAllowThreads();
39232 (arg1)->DetachSizer();
39233
39234 wxPyEndAllowThreads(__tstate);
39235 if (PyErr_Occurred()) SWIG_fail;
39236 }
39237 Py_INCREF(Py_None); resultobj = Py_None;
39238 return resultobj;
39239 fail:
39240 return NULL;
39241 }
39242
39243
39244 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39245 PyObject *resultobj;
39246 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39247 wxSize result;
39248 PyObject * obj0 = 0 ;
39249 char *kwnames[] = {
39250 (char *) "self", NULL
39251 };
39252
39253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39255 if (SWIG_arg_fail(1)) SWIG_fail;
39256 {
39257 PyThreadState* __tstate = wxPyBeginAllowThreads();
39258 result = (arg1)->GetSize();
39259
39260 wxPyEndAllowThreads(__tstate);
39261 if (PyErr_Occurred()) SWIG_fail;
39262 }
39263 {
39264 wxSize * resultptr;
39265 resultptr = new wxSize((wxSize &)(result));
39266 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39267 }
39268 return resultobj;
39269 fail:
39270 return NULL;
39271 }
39272
39273
39274 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39275 PyObject *resultobj;
39276 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39277 wxSize result;
39278 PyObject * obj0 = 0 ;
39279 char *kwnames[] = {
39280 (char *) "self", NULL
39281 };
39282
39283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39285 if (SWIG_arg_fail(1)) SWIG_fail;
39286 {
39287 PyThreadState* __tstate = wxPyBeginAllowThreads();
39288 result = (arg1)->CalcMin();
39289
39290 wxPyEndAllowThreads(__tstate);
39291 if (PyErr_Occurred()) SWIG_fail;
39292 }
39293 {
39294 wxSize * resultptr;
39295 resultptr = new wxSize((wxSize &)(result));
39296 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39297 }
39298 return resultobj;
39299 fail:
39300 return NULL;
39301 }
39302
39303
39304 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39305 PyObject *resultobj;
39306 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39307 wxPoint arg2 ;
39308 wxSize arg3 ;
39309 PyObject * obj0 = 0 ;
39310 PyObject * obj1 = 0 ;
39311 PyObject * obj2 = 0 ;
39312 char *kwnames[] = {
39313 (char *) "self",(char *) "pos",(char *) "size", NULL
39314 };
39315
39316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39318 if (SWIG_arg_fail(1)) SWIG_fail;
39319 {
39320 wxPoint * argp;
39321 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
39322 if (SWIG_arg_fail(2)) SWIG_fail;
39323 if (argp == NULL) {
39324 SWIG_null_ref("wxPoint");
39325 }
39326 if (SWIG_arg_fail(2)) SWIG_fail;
39327 arg2 = *argp;
39328 }
39329 {
39330 wxSize * argp;
39331 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
39332 if (SWIG_arg_fail(3)) SWIG_fail;
39333 if (argp == NULL) {
39334 SWIG_null_ref("wxSize");
39335 }
39336 if (SWIG_arg_fail(3)) SWIG_fail;
39337 arg3 = *argp;
39338 }
39339 {
39340 PyThreadState* __tstate = wxPyBeginAllowThreads();
39341 (arg1)->SetDimension(arg2,arg3);
39342
39343 wxPyEndAllowThreads(__tstate);
39344 if (PyErr_Occurred()) SWIG_fail;
39345 }
39346 Py_INCREF(Py_None); resultobj = Py_None;
39347 return resultobj;
39348 fail:
39349 return NULL;
39350 }
39351
39352
39353 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39354 PyObject *resultobj;
39355 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39356 wxSize result;
39357 PyObject * obj0 = 0 ;
39358 char *kwnames[] = {
39359 (char *) "self", NULL
39360 };
39361
39362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39364 if (SWIG_arg_fail(1)) SWIG_fail;
39365 {
39366 PyThreadState* __tstate = wxPyBeginAllowThreads();
39367 result = (arg1)->GetMinSize();
39368
39369 wxPyEndAllowThreads(__tstate);
39370 if (PyErr_Occurred()) SWIG_fail;
39371 }
39372 {
39373 wxSize * resultptr;
39374 resultptr = new wxSize((wxSize &)(result));
39375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39376 }
39377 return resultobj;
39378 fail:
39379 return NULL;
39380 }
39381
39382
39383 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39384 PyObject *resultobj;
39385 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39386 wxSize result;
39387 PyObject * obj0 = 0 ;
39388 char *kwnames[] = {
39389 (char *) "self", NULL
39390 };
39391
39392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39394 if (SWIG_arg_fail(1)) SWIG_fail;
39395 {
39396 PyThreadState* __tstate = wxPyBeginAllowThreads();
39397 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39398
39399 wxPyEndAllowThreads(__tstate);
39400 if (PyErr_Occurred()) SWIG_fail;
39401 }
39402 {
39403 wxSize * resultptr;
39404 resultptr = new wxSize((wxSize &)(result));
39405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39406 }
39407 return resultobj;
39408 fail:
39409 return NULL;
39410 }
39411
39412
39413 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39414 PyObject *resultobj;
39415 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39416 int arg2 ;
39417 int arg3 ;
39418 PyObject * obj0 = 0 ;
39419 PyObject * obj1 = 0 ;
39420 PyObject * obj2 = 0 ;
39421 char *kwnames[] = {
39422 (char *) "self",(char *) "x",(char *) "y", NULL
39423 };
39424
39425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39427 if (SWIG_arg_fail(1)) SWIG_fail;
39428 {
39429 arg2 = (int)(SWIG_As_int(obj1));
39430 if (SWIG_arg_fail(2)) SWIG_fail;
39431 }
39432 {
39433 arg3 = (int)(SWIG_As_int(obj2));
39434 if (SWIG_arg_fail(3)) SWIG_fail;
39435 }
39436 {
39437 PyThreadState* __tstate = wxPyBeginAllowThreads();
39438 (arg1)->SetInitSize(arg2,arg3);
39439
39440 wxPyEndAllowThreads(__tstate);
39441 if (PyErr_Occurred()) SWIG_fail;
39442 }
39443 Py_INCREF(Py_None); resultobj = Py_None;
39444 return resultobj;
39445 fail:
39446 return NULL;
39447 }
39448
39449
39450 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39451 PyObject *resultobj;
39452 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39453 int arg2 ;
39454 int arg3 ;
39455 PyObject * obj0 = 0 ;
39456 PyObject * obj1 = 0 ;
39457 PyObject * obj2 = 0 ;
39458 char *kwnames[] = {
39459 (char *) "self",(char *) "width",(char *) "height", NULL
39460 };
39461
39462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39464 if (SWIG_arg_fail(1)) SWIG_fail;
39465 {
39466 arg2 = (int)(SWIG_As_int(obj1));
39467 if (SWIG_arg_fail(2)) SWIG_fail;
39468 }
39469 {
39470 arg3 = (int)(SWIG_As_int(obj2));
39471 if (SWIG_arg_fail(3)) SWIG_fail;
39472 }
39473 {
39474 PyThreadState* __tstate = wxPyBeginAllowThreads();
39475 (arg1)->SetRatio(arg2,arg3);
39476
39477 wxPyEndAllowThreads(__tstate);
39478 if (PyErr_Occurred()) SWIG_fail;
39479 }
39480 Py_INCREF(Py_None); resultobj = Py_None;
39481 return resultobj;
39482 fail:
39483 return NULL;
39484 }
39485
39486
39487 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39488 PyObject *resultobj;
39489 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39490 wxSize *arg2 = 0 ;
39491 wxSize temp2 ;
39492 PyObject * obj0 = 0 ;
39493 PyObject * obj1 = 0 ;
39494 char *kwnames[] = {
39495 (char *) "self",(char *) "size", NULL
39496 };
39497
39498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39500 if (SWIG_arg_fail(1)) SWIG_fail;
39501 {
39502 arg2 = &temp2;
39503 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39504 }
39505 {
39506 PyThreadState* __tstate = wxPyBeginAllowThreads();
39507 (arg1)->SetRatio((wxSize const &)*arg2);
39508
39509 wxPyEndAllowThreads(__tstate);
39510 if (PyErr_Occurred()) SWIG_fail;
39511 }
39512 Py_INCREF(Py_None); resultobj = Py_None;
39513 return resultobj;
39514 fail:
39515 return NULL;
39516 }
39517
39518
39519 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39520 PyObject *resultobj;
39521 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39522 float arg2 ;
39523 PyObject * obj0 = 0 ;
39524 PyObject * obj1 = 0 ;
39525 char *kwnames[] = {
39526 (char *) "self",(char *) "ratio", NULL
39527 };
39528
39529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39531 if (SWIG_arg_fail(1)) SWIG_fail;
39532 {
39533 arg2 = (float)(SWIG_As_float(obj1));
39534 if (SWIG_arg_fail(2)) SWIG_fail;
39535 }
39536 {
39537 PyThreadState* __tstate = wxPyBeginAllowThreads();
39538 (arg1)->SetRatio(arg2);
39539
39540 wxPyEndAllowThreads(__tstate);
39541 if (PyErr_Occurred()) SWIG_fail;
39542 }
39543 Py_INCREF(Py_None); resultobj = Py_None;
39544 return resultobj;
39545 fail:
39546 return NULL;
39547 }
39548
39549
39550 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39551 PyObject *resultobj;
39552 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39553 float result;
39554 PyObject * obj0 = 0 ;
39555 char *kwnames[] = {
39556 (char *) "self", NULL
39557 };
39558
39559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39561 if (SWIG_arg_fail(1)) SWIG_fail;
39562 {
39563 PyThreadState* __tstate = wxPyBeginAllowThreads();
39564 result = (float)(arg1)->GetRatio();
39565
39566 wxPyEndAllowThreads(__tstate);
39567 if (PyErr_Occurred()) SWIG_fail;
39568 }
39569 {
39570 resultobj = SWIG_From_float((float)(result));
39571 }
39572 return resultobj;
39573 fail:
39574 return NULL;
39575 }
39576
39577
39578 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39579 PyObject *resultobj;
39580 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39581 wxRect result;
39582 PyObject * obj0 = 0 ;
39583 char *kwnames[] = {
39584 (char *) "self", NULL
39585 };
39586
39587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39589 if (SWIG_arg_fail(1)) SWIG_fail;
39590 {
39591 PyThreadState* __tstate = wxPyBeginAllowThreads();
39592 result = (arg1)->GetRect();
39593
39594 wxPyEndAllowThreads(__tstate);
39595 if (PyErr_Occurred()) SWIG_fail;
39596 }
39597 {
39598 wxRect * resultptr;
39599 resultptr = new wxRect((wxRect &)(result));
39600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39601 }
39602 return resultobj;
39603 fail:
39604 return NULL;
39605 }
39606
39607
39608 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39609 PyObject *resultobj;
39610 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39611 bool result;
39612 PyObject * obj0 = 0 ;
39613 char *kwnames[] = {
39614 (char *) "self", NULL
39615 };
39616
39617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39619 if (SWIG_arg_fail(1)) SWIG_fail;
39620 {
39621 PyThreadState* __tstate = wxPyBeginAllowThreads();
39622 result = (bool)(arg1)->IsWindow();
39623
39624 wxPyEndAllowThreads(__tstate);
39625 if (PyErr_Occurred()) SWIG_fail;
39626 }
39627 {
39628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39629 }
39630 return resultobj;
39631 fail:
39632 return NULL;
39633 }
39634
39635
39636 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39637 PyObject *resultobj;
39638 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39639 bool result;
39640 PyObject * obj0 = 0 ;
39641 char *kwnames[] = {
39642 (char *) "self", NULL
39643 };
39644
39645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39647 if (SWIG_arg_fail(1)) SWIG_fail;
39648 {
39649 PyThreadState* __tstate = wxPyBeginAllowThreads();
39650 result = (bool)(arg1)->IsSizer();
39651
39652 wxPyEndAllowThreads(__tstate);
39653 if (PyErr_Occurred()) SWIG_fail;
39654 }
39655 {
39656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39657 }
39658 return resultobj;
39659 fail:
39660 return NULL;
39661 }
39662
39663
39664 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39665 PyObject *resultobj;
39666 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39667 bool result;
39668 PyObject * obj0 = 0 ;
39669 char *kwnames[] = {
39670 (char *) "self", NULL
39671 };
39672
39673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39675 if (SWIG_arg_fail(1)) SWIG_fail;
39676 {
39677 PyThreadState* __tstate = wxPyBeginAllowThreads();
39678 result = (bool)(arg1)->IsSpacer();
39679
39680 wxPyEndAllowThreads(__tstate);
39681 if (PyErr_Occurred()) SWIG_fail;
39682 }
39683 {
39684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39685 }
39686 return resultobj;
39687 fail:
39688 return NULL;
39689 }
39690
39691
39692 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39693 PyObject *resultobj;
39694 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39695 int arg2 ;
39696 PyObject * obj0 = 0 ;
39697 PyObject * obj1 = 0 ;
39698 char *kwnames[] = {
39699 (char *) "self",(char *) "proportion", NULL
39700 };
39701
39702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39704 if (SWIG_arg_fail(1)) SWIG_fail;
39705 {
39706 arg2 = (int)(SWIG_As_int(obj1));
39707 if (SWIG_arg_fail(2)) SWIG_fail;
39708 }
39709 {
39710 PyThreadState* __tstate = wxPyBeginAllowThreads();
39711 (arg1)->SetProportion(arg2);
39712
39713 wxPyEndAllowThreads(__tstate);
39714 if (PyErr_Occurred()) SWIG_fail;
39715 }
39716 Py_INCREF(Py_None); resultobj = Py_None;
39717 return resultobj;
39718 fail:
39719 return NULL;
39720 }
39721
39722
39723 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39724 PyObject *resultobj;
39725 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39726 int result;
39727 PyObject * obj0 = 0 ;
39728 char *kwnames[] = {
39729 (char *) "self", NULL
39730 };
39731
39732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39734 if (SWIG_arg_fail(1)) SWIG_fail;
39735 {
39736 PyThreadState* __tstate = wxPyBeginAllowThreads();
39737 result = (int)(arg1)->GetProportion();
39738
39739 wxPyEndAllowThreads(__tstate);
39740 if (PyErr_Occurred()) SWIG_fail;
39741 }
39742 {
39743 resultobj = SWIG_From_int((int)(result));
39744 }
39745 return resultobj;
39746 fail:
39747 return NULL;
39748 }
39749
39750
39751 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39752 PyObject *resultobj;
39753 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39754 int arg2 ;
39755 PyObject * obj0 = 0 ;
39756 PyObject * obj1 = 0 ;
39757 char *kwnames[] = {
39758 (char *) "self",(char *) "flag", NULL
39759 };
39760
39761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39763 if (SWIG_arg_fail(1)) SWIG_fail;
39764 {
39765 arg2 = (int)(SWIG_As_int(obj1));
39766 if (SWIG_arg_fail(2)) SWIG_fail;
39767 }
39768 {
39769 PyThreadState* __tstate = wxPyBeginAllowThreads();
39770 (arg1)->SetFlag(arg2);
39771
39772 wxPyEndAllowThreads(__tstate);
39773 if (PyErr_Occurred()) SWIG_fail;
39774 }
39775 Py_INCREF(Py_None); resultobj = Py_None;
39776 return resultobj;
39777 fail:
39778 return NULL;
39779 }
39780
39781
39782 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39783 PyObject *resultobj;
39784 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39785 int result;
39786 PyObject * obj0 = 0 ;
39787 char *kwnames[] = {
39788 (char *) "self", NULL
39789 };
39790
39791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39793 if (SWIG_arg_fail(1)) SWIG_fail;
39794 {
39795 PyThreadState* __tstate = wxPyBeginAllowThreads();
39796 result = (int)(arg1)->GetFlag();
39797
39798 wxPyEndAllowThreads(__tstate);
39799 if (PyErr_Occurred()) SWIG_fail;
39800 }
39801 {
39802 resultobj = SWIG_From_int((int)(result));
39803 }
39804 return resultobj;
39805 fail:
39806 return NULL;
39807 }
39808
39809
39810 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39811 PyObject *resultobj;
39812 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39813 int arg2 ;
39814 PyObject * obj0 = 0 ;
39815 PyObject * obj1 = 0 ;
39816 char *kwnames[] = {
39817 (char *) "self",(char *) "border", NULL
39818 };
39819
39820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39822 if (SWIG_arg_fail(1)) SWIG_fail;
39823 {
39824 arg2 = (int)(SWIG_As_int(obj1));
39825 if (SWIG_arg_fail(2)) SWIG_fail;
39826 }
39827 {
39828 PyThreadState* __tstate = wxPyBeginAllowThreads();
39829 (arg1)->SetBorder(arg2);
39830
39831 wxPyEndAllowThreads(__tstate);
39832 if (PyErr_Occurred()) SWIG_fail;
39833 }
39834 Py_INCREF(Py_None); resultobj = Py_None;
39835 return resultobj;
39836 fail:
39837 return NULL;
39838 }
39839
39840
39841 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39842 PyObject *resultobj;
39843 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39844 int result;
39845 PyObject * obj0 = 0 ;
39846 char *kwnames[] = {
39847 (char *) "self", NULL
39848 };
39849
39850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39852 if (SWIG_arg_fail(1)) SWIG_fail;
39853 {
39854 PyThreadState* __tstate = wxPyBeginAllowThreads();
39855 result = (int)(arg1)->GetBorder();
39856
39857 wxPyEndAllowThreads(__tstate);
39858 if (PyErr_Occurred()) SWIG_fail;
39859 }
39860 {
39861 resultobj = SWIG_From_int((int)(result));
39862 }
39863 return resultobj;
39864 fail:
39865 return NULL;
39866 }
39867
39868
39869 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39870 PyObject *resultobj;
39871 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39872 wxWindow *result;
39873 PyObject * obj0 = 0 ;
39874 char *kwnames[] = {
39875 (char *) "self", NULL
39876 };
39877
39878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39880 if (SWIG_arg_fail(1)) SWIG_fail;
39881 {
39882 PyThreadState* __tstate = wxPyBeginAllowThreads();
39883 result = (wxWindow *)(arg1)->GetWindow();
39884
39885 wxPyEndAllowThreads(__tstate);
39886 if (PyErr_Occurred()) SWIG_fail;
39887 }
39888 {
39889 resultobj = wxPyMake_wxObject(result, 0);
39890 }
39891 return resultobj;
39892 fail:
39893 return NULL;
39894 }
39895
39896
39897 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39898 PyObject *resultobj;
39899 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39900 wxWindow *arg2 = (wxWindow *) 0 ;
39901 PyObject * obj0 = 0 ;
39902 PyObject * obj1 = 0 ;
39903 char *kwnames[] = {
39904 (char *) "self",(char *) "window", NULL
39905 };
39906
39907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39909 if (SWIG_arg_fail(1)) SWIG_fail;
39910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39911 if (SWIG_arg_fail(2)) SWIG_fail;
39912 {
39913 PyThreadState* __tstate = wxPyBeginAllowThreads();
39914 (arg1)->SetWindow(arg2);
39915
39916 wxPyEndAllowThreads(__tstate);
39917 if (PyErr_Occurred()) SWIG_fail;
39918 }
39919 Py_INCREF(Py_None); resultobj = Py_None;
39920 return resultobj;
39921 fail:
39922 return NULL;
39923 }
39924
39925
39926 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39927 PyObject *resultobj;
39928 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39929 wxSizer *result;
39930 PyObject * obj0 = 0 ;
39931 char *kwnames[] = {
39932 (char *) "self", NULL
39933 };
39934
39935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39937 if (SWIG_arg_fail(1)) SWIG_fail;
39938 {
39939 PyThreadState* __tstate = wxPyBeginAllowThreads();
39940 result = (wxSizer *)(arg1)->GetSizer();
39941
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 {
39946 resultobj = wxPyMake_wxObject(result, 0);
39947 }
39948 return resultobj;
39949 fail:
39950 return NULL;
39951 }
39952
39953
39954 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39955 PyObject *resultobj;
39956 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39957 wxSizer *arg2 = (wxSizer *) 0 ;
39958 PyObject * obj0 = 0 ;
39959 PyObject * obj1 = 0 ;
39960 char *kwnames[] = {
39961 (char *) "self",(char *) "sizer", NULL
39962 };
39963
39964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39966 if (SWIG_arg_fail(1)) SWIG_fail;
39967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39968 if (SWIG_arg_fail(2)) SWIG_fail;
39969 {
39970 PyThreadState* __tstate = wxPyBeginAllowThreads();
39971 (arg1)->SetSizer(arg2);
39972
39973 wxPyEndAllowThreads(__tstate);
39974 if (PyErr_Occurred()) SWIG_fail;
39975 }
39976 Py_INCREF(Py_None); resultobj = Py_None;
39977 return resultobj;
39978 fail:
39979 return NULL;
39980 }
39981
39982
39983 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39984 PyObject *resultobj;
39985 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39986 wxSize *result;
39987 PyObject * obj0 = 0 ;
39988 char *kwnames[] = {
39989 (char *) "self", NULL
39990 };
39991
39992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39994 if (SWIG_arg_fail(1)) SWIG_fail;
39995 {
39996 PyThreadState* __tstate = wxPyBeginAllowThreads();
39997 {
39998 wxSize const &_result_ref = (arg1)->GetSpacer();
39999 result = (wxSize *) &_result_ref;
40000 }
40001
40002 wxPyEndAllowThreads(__tstate);
40003 if (PyErr_Occurred()) SWIG_fail;
40004 }
40005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40013 PyObject *resultobj;
40014 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40015 wxSize *arg2 = 0 ;
40016 wxSize temp2 ;
40017 PyObject * obj0 = 0 ;
40018 PyObject * obj1 = 0 ;
40019 char *kwnames[] = {
40020 (char *) "self",(char *) "size", NULL
40021 };
40022
40023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40025 if (SWIG_arg_fail(1)) SWIG_fail;
40026 {
40027 arg2 = &temp2;
40028 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40029 }
40030 {
40031 PyThreadState* __tstate = wxPyBeginAllowThreads();
40032 (arg1)->SetSpacer((wxSize const &)*arg2);
40033
40034 wxPyEndAllowThreads(__tstate);
40035 if (PyErr_Occurred()) SWIG_fail;
40036 }
40037 Py_INCREF(Py_None); resultobj = Py_None;
40038 return resultobj;
40039 fail:
40040 return NULL;
40041 }
40042
40043
40044 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40045 PyObject *resultobj;
40046 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40047 bool arg2 ;
40048 PyObject * obj0 = 0 ;
40049 PyObject * obj1 = 0 ;
40050 char *kwnames[] = {
40051 (char *) "self",(char *) "show", NULL
40052 };
40053
40054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40056 if (SWIG_arg_fail(1)) SWIG_fail;
40057 {
40058 arg2 = (bool)(SWIG_As_bool(obj1));
40059 if (SWIG_arg_fail(2)) SWIG_fail;
40060 }
40061 {
40062 PyThreadState* __tstate = wxPyBeginAllowThreads();
40063 (arg1)->Show(arg2);
40064
40065 wxPyEndAllowThreads(__tstate);
40066 if (PyErr_Occurred()) SWIG_fail;
40067 }
40068 Py_INCREF(Py_None); resultobj = Py_None;
40069 return resultobj;
40070 fail:
40071 return NULL;
40072 }
40073
40074
40075 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40076 PyObject *resultobj;
40077 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40078 bool result;
40079 PyObject * obj0 = 0 ;
40080 char *kwnames[] = {
40081 (char *) "self", NULL
40082 };
40083
40084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40086 if (SWIG_arg_fail(1)) SWIG_fail;
40087 {
40088 PyThreadState* __tstate = wxPyBeginAllowThreads();
40089 result = (bool)(arg1)->IsShown();
40090
40091 wxPyEndAllowThreads(__tstate);
40092 if (PyErr_Occurred()) SWIG_fail;
40093 }
40094 {
40095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40096 }
40097 return resultobj;
40098 fail:
40099 return NULL;
40100 }
40101
40102
40103 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40104 PyObject *resultobj;
40105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40106 wxPoint result;
40107 PyObject * obj0 = 0 ;
40108 char *kwnames[] = {
40109 (char *) "self", NULL
40110 };
40111
40112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40114 if (SWIG_arg_fail(1)) SWIG_fail;
40115 {
40116 PyThreadState* __tstate = wxPyBeginAllowThreads();
40117 result = (arg1)->GetPosition();
40118
40119 wxPyEndAllowThreads(__tstate);
40120 if (PyErr_Occurred()) SWIG_fail;
40121 }
40122 {
40123 wxPoint * resultptr;
40124 resultptr = new wxPoint((wxPoint &)(result));
40125 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40126 }
40127 return resultobj;
40128 fail:
40129 return NULL;
40130 }
40131
40132
40133 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40134 PyObject *resultobj;
40135 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40136 PyObject *result;
40137 PyObject * obj0 = 0 ;
40138 char *kwnames[] = {
40139 (char *) "self", NULL
40140 };
40141
40142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40144 if (SWIG_arg_fail(1)) SWIG_fail;
40145 {
40146 PyThreadState* __tstate = wxPyBeginAllowThreads();
40147 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40148
40149 wxPyEndAllowThreads(__tstate);
40150 if (PyErr_Occurred()) SWIG_fail;
40151 }
40152 resultobj = result;
40153 return resultobj;
40154 fail:
40155 return NULL;
40156 }
40157
40158
40159 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40160 PyObject *obj;
40161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40162 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40163 Py_INCREF(obj);
40164 return Py_BuildValue((char *)"");
40165 }
40166 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40167 PyObject *resultobj;
40168 wxSizer *arg1 = (wxSizer *) 0 ;
40169 PyObject *arg2 = (PyObject *) 0 ;
40170 PyObject * obj0 = 0 ;
40171 PyObject * obj1 = 0 ;
40172 char *kwnames[] = {
40173 (char *) "self",(char *) "_self", NULL
40174 };
40175
40176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40178 if (SWIG_arg_fail(1)) SWIG_fail;
40179 arg2 = obj1;
40180 {
40181 PyThreadState* __tstate = wxPyBeginAllowThreads();
40182 wxSizer__setOORInfo(arg1,arg2);
40183
40184 wxPyEndAllowThreads(__tstate);
40185 if (PyErr_Occurred()) SWIG_fail;
40186 }
40187 Py_INCREF(Py_None); resultobj = Py_None;
40188 return resultobj;
40189 fail:
40190 return NULL;
40191 }
40192
40193
40194 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40195 PyObject *resultobj;
40196 wxSizer *arg1 = (wxSizer *) 0 ;
40197 PyObject *arg2 = (PyObject *) 0 ;
40198 int arg3 = (int) 0 ;
40199 int arg4 = (int) 0 ;
40200 int arg5 = (int) 0 ;
40201 PyObject *arg6 = (PyObject *) NULL ;
40202 wxSizerItem *result;
40203 PyObject * obj0 = 0 ;
40204 PyObject * obj1 = 0 ;
40205 PyObject * obj2 = 0 ;
40206 PyObject * obj3 = 0 ;
40207 PyObject * obj4 = 0 ;
40208 PyObject * obj5 = 0 ;
40209 char *kwnames[] = {
40210 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40211 };
40212
40213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40215 if (SWIG_arg_fail(1)) SWIG_fail;
40216 arg2 = obj1;
40217 if (obj2) {
40218 {
40219 arg3 = (int)(SWIG_As_int(obj2));
40220 if (SWIG_arg_fail(3)) SWIG_fail;
40221 }
40222 }
40223 if (obj3) {
40224 {
40225 arg4 = (int)(SWIG_As_int(obj3));
40226 if (SWIG_arg_fail(4)) SWIG_fail;
40227 }
40228 }
40229 if (obj4) {
40230 {
40231 arg5 = (int)(SWIG_As_int(obj4));
40232 if (SWIG_arg_fail(5)) SWIG_fail;
40233 }
40234 }
40235 if (obj5) {
40236 arg6 = obj5;
40237 }
40238 {
40239 PyThreadState* __tstate = wxPyBeginAllowThreads();
40240 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40241
40242 wxPyEndAllowThreads(__tstate);
40243 if (PyErr_Occurred()) SWIG_fail;
40244 }
40245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40246 return resultobj;
40247 fail:
40248 return NULL;
40249 }
40250
40251
40252 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40253 PyObject *resultobj;
40254 wxSizer *arg1 = (wxSizer *) 0 ;
40255 int arg2 ;
40256 PyObject *arg3 = (PyObject *) 0 ;
40257 int arg4 = (int) 0 ;
40258 int arg5 = (int) 0 ;
40259 int arg6 = (int) 0 ;
40260 PyObject *arg7 = (PyObject *) NULL ;
40261 wxSizerItem *result;
40262 PyObject * obj0 = 0 ;
40263 PyObject * obj1 = 0 ;
40264 PyObject * obj2 = 0 ;
40265 PyObject * obj3 = 0 ;
40266 PyObject * obj4 = 0 ;
40267 PyObject * obj5 = 0 ;
40268 PyObject * obj6 = 0 ;
40269 char *kwnames[] = {
40270 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40271 };
40272
40273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40275 if (SWIG_arg_fail(1)) SWIG_fail;
40276 {
40277 arg2 = (int)(SWIG_As_int(obj1));
40278 if (SWIG_arg_fail(2)) SWIG_fail;
40279 }
40280 arg3 = obj2;
40281 if (obj3) {
40282 {
40283 arg4 = (int)(SWIG_As_int(obj3));
40284 if (SWIG_arg_fail(4)) SWIG_fail;
40285 }
40286 }
40287 if (obj4) {
40288 {
40289 arg5 = (int)(SWIG_As_int(obj4));
40290 if (SWIG_arg_fail(5)) SWIG_fail;
40291 }
40292 }
40293 if (obj5) {
40294 {
40295 arg6 = (int)(SWIG_As_int(obj5));
40296 if (SWIG_arg_fail(6)) SWIG_fail;
40297 }
40298 }
40299 if (obj6) {
40300 arg7 = obj6;
40301 }
40302 {
40303 PyThreadState* __tstate = wxPyBeginAllowThreads();
40304 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40305
40306 wxPyEndAllowThreads(__tstate);
40307 if (PyErr_Occurred()) SWIG_fail;
40308 }
40309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40310 return resultobj;
40311 fail:
40312 return NULL;
40313 }
40314
40315
40316 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40317 PyObject *resultobj;
40318 wxSizer *arg1 = (wxSizer *) 0 ;
40319 PyObject *arg2 = (PyObject *) 0 ;
40320 int arg3 = (int) 0 ;
40321 int arg4 = (int) 0 ;
40322 int arg5 = (int) 0 ;
40323 PyObject *arg6 = (PyObject *) NULL ;
40324 wxSizerItem *result;
40325 PyObject * obj0 = 0 ;
40326 PyObject * obj1 = 0 ;
40327 PyObject * obj2 = 0 ;
40328 PyObject * obj3 = 0 ;
40329 PyObject * obj4 = 0 ;
40330 PyObject * obj5 = 0 ;
40331 char *kwnames[] = {
40332 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40333 };
40334
40335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40337 if (SWIG_arg_fail(1)) SWIG_fail;
40338 arg2 = obj1;
40339 if (obj2) {
40340 {
40341 arg3 = (int)(SWIG_As_int(obj2));
40342 if (SWIG_arg_fail(3)) SWIG_fail;
40343 }
40344 }
40345 if (obj3) {
40346 {
40347 arg4 = (int)(SWIG_As_int(obj3));
40348 if (SWIG_arg_fail(4)) SWIG_fail;
40349 }
40350 }
40351 if (obj4) {
40352 {
40353 arg5 = (int)(SWIG_As_int(obj4));
40354 if (SWIG_arg_fail(5)) SWIG_fail;
40355 }
40356 }
40357 if (obj5) {
40358 arg6 = obj5;
40359 }
40360 {
40361 PyThreadState* __tstate = wxPyBeginAllowThreads();
40362 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40363
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40368 return resultobj;
40369 fail:
40370 return NULL;
40371 }
40372
40373
40374 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40375 PyObject *resultobj;
40376 wxSizer *arg1 = (wxSizer *) 0 ;
40377 PyObject *arg2 = (PyObject *) 0 ;
40378 bool result;
40379 PyObject * obj0 = 0 ;
40380 PyObject * obj1 = 0 ;
40381 char *kwnames[] = {
40382 (char *) "self",(char *) "item", NULL
40383 };
40384
40385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40387 if (SWIG_arg_fail(1)) SWIG_fail;
40388 arg2 = obj1;
40389 {
40390 PyThreadState* __tstate = wxPyBeginAllowThreads();
40391 result = (bool)wxSizer_Remove(arg1,arg2);
40392
40393 wxPyEndAllowThreads(__tstate);
40394 if (PyErr_Occurred()) SWIG_fail;
40395 }
40396 {
40397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40398 }
40399 return resultobj;
40400 fail:
40401 return NULL;
40402 }
40403
40404
40405 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40406 PyObject *resultobj;
40407 wxSizer *arg1 = (wxSizer *) 0 ;
40408 PyObject *arg2 = (PyObject *) 0 ;
40409 bool result;
40410 PyObject * obj0 = 0 ;
40411 PyObject * obj1 = 0 ;
40412 char *kwnames[] = {
40413 (char *) "self",(char *) "item", NULL
40414 };
40415
40416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40418 if (SWIG_arg_fail(1)) SWIG_fail;
40419 arg2 = obj1;
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 result = (bool)wxSizer_Detach(arg1,arg2);
40423
40424 wxPyEndAllowThreads(__tstate);
40425 if (PyErr_Occurred()) SWIG_fail;
40426 }
40427 {
40428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40429 }
40430 return resultobj;
40431 fail:
40432 return NULL;
40433 }
40434
40435
40436 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40437 PyObject *resultobj;
40438 wxSizer *arg1 = (wxSizer *) 0 ;
40439 PyObject *arg2 = (PyObject *) 0 ;
40440 wxSizerItem *result;
40441 PyObject * obj0 = 0 ;
40442 PyObject * obj1 = 0 ;
40443 char *kwnames[] = {
40444 (char *) "self",(char *) "item", NULL
40445 };
40446
40447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40449 if (SWIG_arg_fail(1)) SWIG_fail;
40450 arg2 = obj1;
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40454
40455 wxPyEndAllowThreads(__tstate);
40456 if (PyErr_Occurred()) SWIG_fail;
40457 }
40458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40459 return resultobj;
40460 fail:
40461 return NULL;
40462 }
40463
40464
40465 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40466 PyObject *resultobj;
40467 wxSizer *arg1 = (wxSizer *) 0 ;
40468 PyObject *arg2 = (PyObject *) 0 ;
40469 wxSize *arg3 = 0 ;
40470 wxSize temp3 ;
40471 PyObject * obj0 = 0 ;
40472 PyObject * obj1 = 0 ;
40473 PyObject * obj2 = 0 ;
40474 char *kwnames[] = {
40475 (char *) "self",(char *) "item",(char *) "size", NULL
40476 };
40477
40478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40480 if (SWIG_arg_fail(1)) SWIG_fail;
40481 arg2 = obj1;
40482 {
40483 arg3 = &temp3;
40484 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40485 }
40486 {
40487 PyThreadState* __tstate = wxPyBeginAllowThreads();
40488 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40489
40490 wxPyEndAllowThreads(__tstate);
40491 if (PyErr_Occurred()) SWIG_fail;
40492 }
40493 Py_INCREF(Py_None); resultobj = Py_None;
40494 return resultobj;
40495 fail:
40496 return NULL;
40497 }
40498
40499
40500 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40501 PyObject *resultobj;
40502 wxSizer *arg1 = (wxSizer *) 0 ;
40503 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40504 wxSizerItem *result;
40505 PyObject * obj0 = 0 ;
40506 PyObject * obj1 = 0 ;
40507 char *kwnames[] = {
40508 (char *) "self",(char *) "item", NULL
40509 };
40510
40511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40513 if (SWIG_arg_fail(1)) SWIG_fail;
40514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40515 if (SWIG_arg_fail(2)) SWIG_fail;
40516 {
40517 PyThreadState* __tstate = wxPyBeginAllowThreads();
40518 result = (wxSizerItem *)(arg1)->Add(arg2);
40519
40520 wxPyEndAllowThreads(__tstate);
40521 if (PyErr_Occurred()) SWIG_fail;
40522 }
40523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40531 PyObject *resultobj;
40532 wxSizer *arg1 = (wxSizer *) 0 ;
40533 size_t arg2 ;
40534 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40535 wxSizerItem *result;
40536 PyObject * obj0 = 0 ;
40537 PyObject * obj1 = 0 ;
40538 PyObject * obj2 = 0 ;
40539 char *kwnames[] = {
40540 (char *) "self",(char *) "index",(char *) "item", NULL
40541 };
40542
40543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40545 if (SWIG_arg_fail(1)) SWIG_fail;
40546 {
40547 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40548 if (SWIG_arg_fail(2)) SWIG_fail;
40549 }
40550 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40551 if (SWIG_arg_fail(3)) SWIG_fail;
40552 {
40553 PyThreadState* __tstate = wxPyBeginAllowThreads();
40554 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40555
40556 wxPyEndAllowThreads(__tstate);
40557 if (PyErr_Occurred()) SWIG_fail;
40558 }
40559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40560 return resultobj;
40561 fail:
40562 return NULL;
40563 }
40564
40565
40566 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40567 PyObject *resultobj;
40568 wxSizer *arg1 = (wxSizer *) 0 ;
40569 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40570 wxSizerItem *result;
40571 PyObject * obj0 = 0 ;
40572 PyObject * obj1 = 0 ;
40573 char *kwnames[] = {
40574 (char *) "self",(char *) "item", NULL
40575 };
40576
40577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40579 if (SWIG_arg_fail(1)) SWIG_fail;
40580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40581 if (SWIG_arg_fail(2)) SWIG_fail;
40582 {
40583 PyThreadState* __tstate = wxPyBeginAllowThreads();
40584 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40585
40586 wxPyEndAllowThreads(__tstate);
40587 if (PyErr_Occurred()) SWIG_fail;
40588 }
40589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40590 return resultobj;
40591 fail:
40592 return NULL;
40593 }
40594
40595
40596 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40597 PyObject *resultobj;
40598 wxSizer *arg1 = (wxSizer *) 0 ;
40599 int arg2 ;
40600 int arg3 ;
40601 int arg4 ;
40602 int arg5 ;
40603 PyObject * obj0 = 0 ;
40604 PyObject * obj1 = 0 ;
40605 PyObject * obj2 = 0 ;
40606 PyObject * obj3 = 0 ;
40607 PyObject * obj4 = 0 ;
40608 char *kwnames[] = {
40609 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40610 };
40611
40612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40614 if (SWIG_arg_fail(1)) SWIG_fail;
40615 {
40616 arg2 = (int)(SWIG_As_int(obj1));
40617 if (SWIG_arg_fail(2)) SWIG_fail;
40618 }
40619 {
40620 arg3 = (int)(SWIG_As_int(obj2));
40621 if (SWIG_arg_fail(3)) SWIG_fail;
40622 }
40623 {
40624 arg4 = (int)(SWIG_As_int(obj3));
40625 if (SWIG_arg_fail(4)) SWIG_fail;
40626 }
40627 {
40628 arg5 = (int)(SWIG_As_int(obj4));
40629 if (SWIG_arg_fail(5)) SWIG_fail;
40630 }
40631 {
40632 PyThreadState* __tstate = wxPyBeginAllowThreads();
40633 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40634
40635 wxPyEndAllowThreads(__tstate);
40636 if (PyErr_Occurred()) SWIG_fail;
40637 }
40638 Py_INCREF(Py_None); resultobj = Py_None;
40639 return resultobj;
40640 fail:
40641 return NULL;
40642 }
40643
40644
40645 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40646 PyObject *resultobj;
40647 wxSizer *arg1 = (wxSizer *) 0 ;
40648 wxSize *arg2 = 0 ;
40649 wxSize temp2 ;
40650 PyObject * obj0 = 0 ;
40651 PyObject * obj1 = 0 ;
40652 char *kwnames[] = {
40653 (char *) "self",(char *) "size", NULL
40654 };
40655
40656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40658 if (SWIG_arg_fail(1)) SWIG_fail;
40659 {
40660 arg2 = &temp2;
40661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40662 }
40663 {
40664 PyThreadState* __tstate = wxPyBeginAllowThreads();
40665 (arg1)->SetMinSize((wxSize const &)*arg2);
40666
40667 wxPyEndAllowThreads(__tstate);
40668 if (PyErr_Occurred()) SWIG_fail;
40669 }
40670 Py_INCREF(Py_None); resultobj = Py_None;
40671 return resultobj;
40672 fail:
40673 return NULL;
40674 }
40675
40676
40677 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40678 PyObject *resultobj;
40679 wxSizer *arg1 = (wxSizer *) 0 ;
40680 wxSize result;
40681 PyObject * obj0 = 0 ;
40682 char *kwnames[] = {
40683 (char *) "self", NULL
40684 };
40685
40686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40688 if (SWIG_arg_fail(1)) SWIG_fail;
40689 {
40690 PyThreadState* __tstate = wxPyBeginAllowThreads();
40691 result = (arg1)->GetSize();
40692
40693 wxPyEndAllowThreads(__tstate);
40694 if (PyErr_Occurred()) SWIG_fail;
40695 }
40696 {
40697 wxSize * resultptr;
40698 resultptr = new wxSize((wxSize &)(result));
40699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40700 }
40701 return resultobj;
40702 fail:
40703 return NULL;
40704 }
40705
40706
40707 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40708 PyObject *resultobj;
40709 wxSizer *arg1 = (wxSizer *) 0 ;
40710 wxPoint result;
40711 PyObject * obj0 = 0 ;
40712 char *kwnames[] = {
40713 (char *) "self", NULL
40714 };
40715
40716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40718 if (SWIG_arg_fail(1)) SWIG_fail;
40719 {
40720 PyThreadState* __tstate = wxPyBeginAllowThreads();
40721 result = (arg1)->GetPosition();
40722
40723 wxPyEndAllowThreads(__tstate);
40724 if (PyErr_Occurred()) SWIG_fail;
40725 }
40726 {
40727 wxPoint * resultptr;
40728 resultptr = new wxPoint((wxPoint &)(result));
40729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40730 }
40731 return resultobj;
40732 fail:
40733 return NULL;
40734 }
40735
40736
40737 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40738 PyObject *resultobj;
40739 wxSizer *arg1 = (wxSizer *) 0 ;
40740 wxSize result;
40741 PyObject * obj0 = 0 ;
40742 char *kwnames[] = {
40743 (char *) "self", NULL
40744 };
40745
40746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40748 if (SWIG_arg_fail(1)) SWIG_fail;
40749 {
40750 PyThreadState* __tstate = wxPyBeginAllowThreads();
40751 result = (arg1)->GetMinSize();
40752
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 {
40757 wxSize * resultptr;
40758 resultptr = new wxSize((wxSize &)(result));
40759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40760 }
40761 return resultobj;
40762 fail:
40763 return NULL;
40764 }
40765
40766
40767 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40768 PyObject *resultobj;
40769 wxSizer *arg1 = (wxSizer *) 0 ;
40770 PyObject * obj0 = 0 ;
40771 char *kwnames[] = {
40772 (char *) "self", NULL
40773 };
40774
40775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40777 if (SWIG_arg_fail(1)) SWIG_fail;
40778 {
40779 PyThreadState* __tstate = wxPyBeginAllowThreads();
40780 (arg1)->RecalcSizes();
40781
40782 wxPyEndAllowThreads(__tstate);
40783 if (PyErr_Occurred()) SWIG_fail;
40784 }
40785 Py_INCREF(Py_None); resultobj = Py_None;
40786 return resultobj;
40787 fail:
40788 return NULL;
40789 }
40790
40791
40792 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40793 PyObject *resultobj;
40794 wxSizer *arg1 = (wxSizer *) 0 ;
40795 wxSize result;
40796 PyObject * obj0 = 0 ;
40797 char *kwnames[] = {
40798 (char *) "self", NULL
40799 };
40800
40801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40803 if (SWIG_arg_fail(1)) SWIG_fail;
40804 {
40805 PyThreadState* __tstate = wxPyBeginAllowThreads();
40806 result = (arg1)->CalcMin();
40807
40808 wxPyEndAllowThreads(__tstate);
40809 if (PyErr_Occurred()) SWIG_fail;
40810 }
40811 {
40812 wxSize * resultptr;
40813 resultptr = new wxSize((wxSize &)(result));
40814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40815 }
40816 return resultobj;
40817 fail:
40818 return NULL;
40819 }
40820
40821
40822 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40823 PyObject *resultobj;
40824 wxSizer *arg1 = (wxSizer *) 0 ;
40825 PyObject * obj0 = 0 ;
40826 char *kwnames[] = {
40827 (char *) "self", NULL
40828 };
40829
40830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40832 if (SWIG_arg_fail(1)) SWIG_fail;
40833 {
40834 PyThreadState* __tstate = wxPyBeginAllowThreads();
40835 (arg1)->Layout();
40836
40837 wxPyEndAllowThreads(__tstate);
40838 if (PyErr_Occurred()) SWIG_fail;
40839 }
40840 Py_INCREF(Py_None); resultobj = Py_None;
40841 return resultobj;
40842 fail:
40843 return NULL;
40844 }
40845
40846
40847 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40848 PyObject *resultobj;
40849 wxSizer *arg1 = (wxSizer *) 0 ;
40850 wxWindow *arg2 = (wxWindow *) 0 ;
40851 wxSize result;
40852 PyObject * obj0 = 0 ;
40853 PyObject * obj1 = 0 ;
40854 char *kwnames[] = {
40855 (char *) "self",(char *) "window", NULL
40856 };
40857
40858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40860 if (SWIG_arg_fail(1)) SWIG_fail;
40861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40862 if (SWIG_arg_fail(2)) SWIG_fail;
40863 {
40864 PyThreadState* __tstate = wxPyBeginAllowThreads();
40865 result = (arg1)->Fit(arg2);
40866
40867 wxPyEndAllowThreads(__tstate);
40868 if (PyErr_Occurred()) SWIG_fail;
40869 }
40870 {
40871 wxSize * resultptr;
40872 resultptr = new wxSize((wxSize &)(result));
40873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40874 }
40875 return resultobj;
40876 fail:
40877 return NULL;
40878 }
40879
40880
40881 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40882 PyObject *resultobj;
40883 wxSizer *arg1 = (wxSizer *) 0 ;
40884 wxWindow *arg2 = (wxWindow *) 0 ;
40885 PyObject * obj0 = 0 ;
40886 PyObject * obj1 = 0 ;
40887 char *kwnames[] = {
40888 (char *) "self",(char *) "window", NULL
40889 };
40890
40891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40893 if (SWIG_arg_fail(1)) SWIG_fail;
40894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40895 if (SWIG_arg_fail(2)) SWIG_fail;
40896 {
40897 PyThreadState* __tstate = wxPyBeginAllowThreads();
40898 (arg1)->FitInside(arg2);
40899
40900 wxPyEndAllowThreads(__tstate);
40901 if (PyErr_Occurred()) SWIG_fail;
40902 }
40903 Py_INCREF(Py_None); resultobj = Py_None;
40904 return resultobj;
40905 fail:
40906 return NULL;
40907 }
40908
40909
40910 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40911 PyObject *resultobj;
40912 wxSizer *arg1 = (wxSizer *) 0 ;
40913 wxWindow *arg2 = (wxWindow *) 0 ;
40914 PyObject * obj0 = 0 ;
40915 PyObject * obj1 = 0 ;
40916 char *kwnames[] = {
40917 (char *) "self",(char *) "window", NULL
40918 };
40919
40920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40922 if (SWIG_arg_fail(1)) SWIG_fail;
40923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40924 if (SWIG_arg_fail(2)) SWIG_fail;
40925 {
40926 PyThreadState* __tstate = wxPyBeginAllowThreads();
40927 (arg1)->SetSizeHints(arg2);
40928
40929 wxPyEndAllowThreads(__tstate);
40930 if (PyErr_Occurred()) SWIG_fail;
40931 }
40932 Py_INCREF(Py_None); resultobj = Py_None;
40933 return resultobj;
40934 fail:
40935 return NULL;
40936 }
40937
40938
40939 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40940 PyObject *resultobj;
40941 wxSizer *arg1 = (wxSizer *) 0 ;
40942 wxWindow *arg2 = (wxWindow *) 0 ;
40943 PyObject * obj0 = 0 ;
40944 PyObject * obj1 = 0 ;
40945 char *kwnames[] = {
40946 (char *) "self",(char *) "window", NULL
40947 };
40948
40949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40951 if (SWIG_arg_fail(1)) SWIG_fail;
40952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40953 if (SWIG_arg_fail(2)) SWIG_fail;
40954 {
40955 PyThreadState* __tstate = wxPyBeginAllowThreads();
40956 (arg1)->SetVirtualSizeHints(arg2);
40957
40958 wxPyEndAllowThreads(__tstate);
40959 if (PyErr_Occurred()) SWIG_fail;
40960 }
40961 Py_INCREF(Py_None); resultobj = Py_None;
40962 return resultobj;
40963 fail:
40964 return NULL;
40965 }
40966
40967
40968 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40969 PyObject *resultobj;
40970 wxSizer *arg1 = (wxSizer *) 0 ;
40971 bool arg2 = (bool) false ;
40972 PyObject * obj0 = 0 ;
40973 PyObject * obj1 = 0 ;
40974 char *kwnames[] = {
40975 (char *) "self",(char *) "deleteWindows", NULL
40976 };
40977
40978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40980 if (SWIG_arg_fail(1)) SWIG_fail;
40981 if (obj1) {
40982 {
40983 arg2 = (bool)(SWIG_As_bool(obj1));
40984 if (SWIG_arg_fail(2)) SWIG_fail;
40985 }
40986 }
40987 {
40988 PyThreadState* __tstate = wxPyBeginAllowThreads();
40989 (arg1)->Clear(arg2);
40990
40991 wxPyEndAllowThreads(__tstate);
40992 if (PyErr_Occurred()) SWIG_fail;
40993 }
40994 Py_INCREF(Py_None); resultobj = Py_None;
40995 return resultobj;
40996 fail:
40997 return NULL;
40998 }
40999
41000
41001 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41002 PyObject *resultobj;
41003 wxSizer *arg1 = (wxSizer *) 0 ;
41004 PyObject * obj0 = 0 ;
41005 char *kwnames[] = {
41006 (char *) "self", NULL
41007 };
41008
41009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41011 if (SWIG_arg_fail(1)) SWIG_fail;
41012 {
41013 PyThreadState* __tstate = wxPyBeginAllowThreads();
41014 (arg1)->DeleteWindows();
41015
41016 wxPyEndAllowThreads(__tstate);
41017 if (PyErr_Occurred()) SWIG_fail;
41018 }
41019 Py_INCREF(Py_None); resultobj = Py_None;
41020 return resultobj;
41021 fail:
41022 return NULL;
41023 }
41024
41025
41026 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41027 PyObject *resultobj;
41028 wxSizer *arg1 = (wxSizer *) 0 ;
41029 PyObject *result;
41030 PyObject * obj0 = 0 ;
41031 char *kwnames[] = {
41032 (char *) "self", NULL
41033 };
41034
41035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41037 if (SWIG_arg_fail(1)) SWIG_fail;
41038 {
41039 PyThreadState* __tstate = wxPyBeginAllowThreads();
41040 result = (PyObject *)wxSizer_GetChildren(arg1);
41041
41042 wxPyEndAllowThreads(__tstate);
41043 if (PyErr_Occurred()) SWIG_fail;
41044 }
41045 resultobj = result;
41046 return resultobj;
41047 fail:
41048 return NULL;
41049 }
41050
41051
41052 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41053 PyObject *resultobj;
41054 wxSizer *arg1 = (wxSizer *) 0 ;
41055 PyObject *arg2 = (PyObject *) 0 ;
41056 bool arg3 = (bool) true ;
41057 bool arg4 = (bool) false ;
41058 bool result;
41059 PyObject * obj0 = 0 ;
41060 PyObject * obj1 = 0 ;
41061 PyObject * obj2 = 0 ;
41062 PyObject * obj3 = 0 ;
41063 char *kwnames[] = {
41064 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41065 };
41066
41067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41069 if (SWIG_arg_fail(1)) SWIG_fail;
41070 arg2 = obj1;
41071 if (obj2) {
41072 {
41073 arg3 = (bool)(SWIG_As_bool(obj2));
41074 if (SWIG_arg_fail(3)) SWIG_fail;
41075 }
41076 }
41077 if (obj3) {
41078 {
41079 arg4 = (bool)(SWIG_As_bool(obj3));
41080 if (SWIG_arg_fail(4)) SWIG_fail;
41081 }
41082 }
41083 {
41084 PyThreadState* __tstate = wxPyBeginAllowThreads();
41085 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41086
41087 wxPyEndAllowThreads(__tstate);
41088 if (PyErr_Occurred()) SWIG_fail;
41089 }
41090 {
41091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41092 }
41093 return resultobj;
41094 fail:
41095 return NULL;
41096 }
41097
41098
41099 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41100 PyObject *resultobj;
41101 wxSizer *arg1 = (wxSizer *) 0 ;
41102 PyObject *arg2 = (PyObject *) 0 ;
41103 bool result;
41104 PyObject * obj0 = 0 ;
41105 PyObject * obj1 = 0 ;
41106 char *kwnames[] = {
41107 (char *) "self",(char *) "item", NULL
41108 };
41109
41110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41112 if (SWIG_arg_fail(1)) SWIG_fail;
41113 arg2 = obj1;
41114 {
41115 PyThreadState* __tstate = wxPyBeginAllowThreads();
41116 result = (bool)wxSizer_IsShown(arg1,arg2);
41117
41118 wxPyEndAllowThreads(__tstate);
41119 if (PyErr_Occurred()) SWIG_fail;
41120 }
41121 {
41122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41123 }
41124 return resultobj;
41125 fail:
41126 return NULL;
41127 }
41128
41129
41130 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41131 PyObject *resultobj;
41132 wxSizer *arg1 = (wxSizer *) 0 ;
41133 bool arg2 ;
41134 PyObject * obj0 = 0 ;
41135 PyObject * obj1 = 0 ;
41136 char *kwnames[] = {
41137 (char *) "self",(char *) "show", NULL
41138 };
41139
41140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41142 if (SWIG_arg_fail(1)) SWIG_fail;
41143 {
41144 arg2 = (bool)(SWIG_As_bool(obj1));
41145 if (SWIG_arg_fail(2)) SWIG_fail;
41146 }
41147 {
41148 PyThreadState* __tstate = wxPyBeginAllowThreads();
41149 (arg1)->ShowItems(arg2);
41150
41151 wxPyEndAllowThreads(__tstate);
41152 if (PyErr_Occurred()) SWIG_fail;
41153 }
41154 Py_INCREF(Py_None); resultobj = Py_None;
41155 return resultobj;
41156 fail:
41157 return NULL;
41158 }
41159
41160
41161 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41162 PyObject *obj;
41163 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41164 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41165 Py_INCREF(obj);
41166 return Py_BuildValue((char *)"");
41167 }
41168 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41169 PyObject *resultobj;
41170 wxPySizer *result;
41171 char *kwnames[] = {
41172 NULL
41173 };
41174
41175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41176 {
41177 PyThreadState* __tstate = wxPyBeginAllowThreads();
41178 result = (wxPySizer *)new wxPySizer();
41179
41180 wxPyEndAllowThreads(__tstate);
41181 if (PyErr_Occurred()) SWIG_fail;
41182 }
41183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41184 return resultobj;
41185 fail:
41186 return NULL;
41187 }
41188
41189
41190 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41191 PyObject *resultobj;
41192 wxPySizer *arg1 = (wxPySizer *) 0 ;
41193 PyObject *arg2 = (PyObject *) 0 ;
41194 PyObject *arg3 = (PyObject *) 0 ;
41195 PyObject * obj0 = 0 ;
41196 PyObject * obj1 = 0 ;
41197 PyObject * obj2 = 0 ;
41198 char *kwnames[] = {
41199 (char *) "self",(char *) "self",(char *) "_class", NULL
41200 };
41201
41202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41204 if (SWIG_arg_fail(1)) SWIG_fail;
41205 arg2 = obj1;
41206 arg3 = obj2;
41207 {
41208 PyThreadState* __tstate = wxPyBeginAllowThreads();
41209 (arg1)->_setCallbackInfo(arg2,arg3);
41210
41211 wxPyEndAllowThreads(__tstate);
41212 if (PyErr_Occurred()) SWIG_fail;
41213 }
41214 Py_INCREF(Py_None); resultobj = Py_None;
41215 return resultobj;
41216 fail:
41217 return NULL;
41218 }
41219
41220
41221 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41222 PyObject *obj;
41223 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41224 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41225 Py_INCREF(obj);
41226 return Py_BuildValue((char *)"");
41227 }
41228 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41229 PyObject *resultobj;
41230 int arg1 = (int) wxHORIZONTAL ;
41231 wxBoxSizer *result;
41232 PyObject * obj0 = 0 ;
41233 char *kwnames[] = {
41234 (char *) "orient", NULL
41235 };
41236
41237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41238 if (obj0) {
41239 {
41240 arg1 = (int)(SWIG_As_int(obj0));
41241 if (SWIG_arg_fail(1)) SWIG_fail;
41242 }
41243 }
41244 {
41245 PyThreadState* __tstate = wxPyBeginAllowThreads();
41246 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41247
41248 wxPyEndAllowThreads(__tstate);
41249 if (PyErr_Occurred()) SWIG_fail;
41250 }
41251 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41252 return resultobj;
41253 fail:
41254 return NULL;
41255 }
41256
41257
41258 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41259 PyObject *resultobj;
41260 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41261 int result;
41262 PyObject * obj0 = 0 ;
41263 char *kwnames[] = {
41264 (char *) "self", NULL
41265 };
41266
41267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41269 if (SWIG_arg_fail(1)) SWIG_fail;
41270 {
41271 PyThreadState* __tstate = wxPyBeginAllowThreads();
41272 result = (int)(arg1)->GetOrientation();
41273
41274 wxPyEndAllowThreads(__tstate);
41275 if (PyErr_Occurred()) SWIG_fail;
41276 }
41277 {
41278 resultobj = SWIG_From_int((int)(result));
41279 }
41280 return resultobj;
41281 fail:
41282 return NULL;
41283 }
41284
41285
41286 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41287 PyObject *resultobj;
41288 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41289 int arg2 ;
41290 PyObject * obj0 = 0 ;
41291 PyObject * obj1 = 0 ;
41292 char *kwnames[] = {
41293 (char *) "self",(char *) "orient", NULL
41294 };
41295
41296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41298 if (SWIG_arg_fail(1)) SWIG_fail;
41299 {
41300 arg2 = (int)(SWIG_As_int(obj1));
41301 if (SWIG_arg_fail(2)) SWIG_fail;
41302 }
41303 {
41304 PyThreadState* __tstate = wxPyBeginAllowThreads();
41305 (arg1)->SetOrientation(arg2);
41306
41307 wxPyEndAllowThreads(__tstate);
41308 if (PyErr_Occurred()) SWIG_fail;
41309 }
41310 Py_INCREF(Py_None); resultobj = Py_None;
41311 return resultobj;
41312 fail:
41313 return NULL;
41314 }
41315
41316
41317 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41318 PyObject *obj;
41319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41320 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41321 Py_INCREF(obj);
41322 return Py_BuildValue((char *)"");
41323 }
41324 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41325 PyObject *resultobj;
41326 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41327 int arg2 = (int) wxHORIZONTAL ;
41328 wxStaticBoxSizer *result;
41329 PyObject * obj0 = 0 ;
41330 PyObject * obj1 = 0 ;
41331 char *kwnames[] = {
41332 (char *) "box",(char *) "orient", NULL
41333 };
41334
41335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41337 if (SWIG_arg_fail(1)) SWIG_fail;
41338 if (obj1) {
41339 {
41340 arg2 = (int)(SWIG_As_int(obj1));
41341 if (SWIG_arg_fail(2)) SWIG_fail;
41342 }
41343 }
41344 {
41345 PyThreadState* __tstate = wxPyBeginAllowThreads();
41346 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41347
41348 wxPyEndAllowThreads(__tstate);
41349 if (PyErr_Occurred()) SWIG_fail;
41350 }
41351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41352 return resultobj;
41353 fail:
41354 return NULL;
41355 }
41356
41357
41358 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41359 PyObject *resultobj;
41360 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41361 wxStaticBox *result;
41362 PyObject * obj0 = 0 ;
41363 char *kwnames[] = {
41364 (char *) "self", NULL
41365 };
41366
41367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41369 if (SWIG_arg_fail(1)) SWIG_fail;
41370 {
41371 PyThreadState* __tstate = wxPyBeginAllowThreads();
41372 result = (wxStaticBox *)(arg1)->GetStaticBox();
41373
41374 wxPyEndAllowThreads(__tstate);
41375 if (PyErr_Occurred()) SWIG_fail;
41376 }
41377 {
41378 resultobj = wxPyMake_wxObject(result, 0);
41379 }
41380 return resultobj;
41381 fail:
41382 return NULL;
41383 }
41384
41385
41386 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41387 PyObject *obj;
41388 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41389 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41390 Py_INCREF(obj);
41391 return Py_BuildValue((char *)"");
41392 }
41393 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj;
41395 int arg1 = (int) 1 ;
41396 int arg2 = (int) 0 ;
41397 int arg3 = (int) 0 ;
41398 int arg4 = (int) 0 ;
41399 wxGridSizer *result;
41400 PyObject * obj0 = 0 ;
41401 PyObject * obj1 = 0 ;
41402 PyObject * obj2 = 0 ;
41403 PyObject * obj3 = 0 ;
41404 char *kwnames[] = {
41405 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41406 };
41407
41408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41409 if (obj0) {
41410 {
41411 arg1 = (int)(SWIG_As_int(obj0));
41412 if (SWIG_arg_fail(1)) SWIG_fail;
41413 }
41414 }
41415 if (obj1) {
41416 {
41417 arg2 = (int)(SWIG_As_int(obj1));
41418 if (SWIG_arg_fail(2)) SWIG_fail;
41419 }
41420 }
41421 if (obj2) {
41422 {
41423 arg3 = (int)(SWIG_As_int(obj2));
41424 if (SWIG_arg_fail(3)) SWIG_fail;
41425 }
41426 }
41427 if (obj3) {
41428 {
41429 arg4 = (int)(SWIG_As_int(obj3));
41430 if (SWIG_arg_fail(4)) SWIG_fail;
41431 }
41432 }
41433 {
41434 PyThreadState* __tstate = wxPyBeginAllowThreads();
41435 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41436
41437 wxPyEndAllowThreads(__tstate);
41438 if (PyErr_Occurred()) SWIG_fail;
41439 }
41440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41441 return resultobj;
41442 fail:
41443 return NULL;
41444 }
41445
41446
41447 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41448 PyObject *resultobj;
41449 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41450 int arg2 ;
41451 PyObject * obj0 = 0 ;
41452 PyObject * obj1 = 0 ;
41453 char *kwnames[] = {
41454 (char *) "self",(char *) "cols", NULL
41455 };
41456
41457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41459 if (SWIG_arg_fail(1)) SWIG_fail;
41460 {
41461 arg2 = (int)(SWIG_As_int(obj1));
41462 if (SWIG_arg_fail(2)) SWIG_fail;
41463 }
41464 {
41465 PyThreadState* __tstate = wxPyBeginAllowThreads();
41466 (arg1)->SetCols(arg2);
41467
41468 wxPyEndAllowThreads(__tstate);
41469 if (PyErr_Occurred()) SWIG_fail;
41470 }
41471 Py_INCREF(Py_None); resultobj = Py_None;
41472 return resultobj;
41473 fail:
41474 return NULL;
41475 }
41476
41477
41478 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41479 PyObject *resultobj;
41480 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41481 int arg2 ;
41482 PyObject * obj0 = 0 ;
41483 PyObject * obj1 = 0 ;
41484 char *kwnames[] = {
41485 (char *) "self",(char *) "rows", NULL
41486 };
41487
41488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41490 if (SWIG_arg_fail(1)) SWIG_fail;
41491 {
41492 arg2 = (int)(SWIG_As_int(obj1));
41493 if (SWIG_arg_fail(2)) SWIG_fail;
41494 }
41495 {
41496 PyThreadState* __tstate = wxPyBeginAllowThreads();
41497 (arg1)->SetRows(arg2);
41498
41499 wxPyEndAllowThreads(__tstate);
41500 if (PyErr_Occurred()) SWIG_fail;
41501 }
41502 Py_INCREF(Py_None); resultobj = Py_None;
41503 return resultobj;
41504 fail:
41505 return NULL;
41506 }
41507
41508
41509 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41510 PyObject *resultobj;
41511 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41512 int arg2 ;
41513 PyObject * obj0 = 0 ;
41514 PyObject * obj1 = 0 ;
41515 char *kwnames[] = {
41516 (char *) "self",(char *) "gap", NULL
41517 };
41518
41519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41521 if (SWIG_arg_fail(1)) SWIG_fail;
41522 {
41523 arg2 = (int)(SWIG_As_int(obj1));
41524 if (SWIG_arg_fail(2)) SWIG_fail;
41525 }
41526 {
41527 PyThreadState* __tstate = wxPyBeginAllowThreads();
41528 (arg1)->SetVGap(arg2);
41529
41530 wxPyEndAllowThreads(__tstate);
41531 if (PyErr_Occurred()) SWIG_fail;
41532 }
41533 Py_INCREF(Py_None); resultobj = Py_None;
41534 return resultobj;
41535 fail:
41536 return NULL;
41537 }
41538
41539
41540 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41541 PyObject *resultobj;
41542 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41543 int arg2 ;
41544 PyObject * obj0 = 0 ;
41545 PyObject * obj1 = 0 ;
41546 char *kwnames[] = {
41547 (char *) "self",(char *) "gap", NULL
41548 };
41549
41550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41552 if (SWIG_arg_fail(1)) SWIG_fail;
41553 {
41554 arg2 = (int)(SWIG_As_int(obj1));
41555 if (SWIG_arg_fail(2)) SWIG_fail;
41556 }
41557 {
41558 PyThreadState* __tstate = wxPyBeginAllowThreads();
41559 (arg1)->SetHGap(arg2);
41560
41561 wxPyEndAllowThreads(__tstate);
41562 if (PyErr_Occurred()) SWIG_fail;
41563 }
41564 Py_INCREF(Py_None); resultobj = Py_None;
41565 return resultobj;
41566 fail:
41567 return NULL;
41568 }
41569
41570
41571 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41572 PyObject *resultobj;
41573 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41574 int result;
41575 PyObject * obj0 = 0 ;
41576 char *kwnames[] = {
41577 (char *) "self", NULL
41578 };
41579
41580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41582 if (SWIG_arg_fail(1)) SWIG_fail;
41583 {
41584 PyThreadState* __tstate = wxPyBeginAllowThreads();
41585 result = (int)(arg1)->GetCols();
41586
41587 wxPyEndAllowThreads(__tstate);
41588 if (PyErr_Occurred()) SWIG_fail;
41589 }
41590 {
41591 resultobj = SWIG_From_int((int)(result));
41592 }
41593 return resultobj;
41594 fail:
41595 return NULL;
41596 }
41597
41598
41599 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41600 PyObject *resultobj;
41601 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41602 int result;
41603 PyObject * obj0 = 0 ;
41604 char *kwnames[] = {
41605 (char *) "self", NULL
41606 };
41607
41608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41610 if (SWIG_arg_fail(1)) SWIG_fail;
41611 {
41612 PyThreadState* __tstate = wxPyBeginAllowThreads();
41613 result = (int)(arg1)->GetRows();
41614
41615 wxPyEndAllowThreads(__tstate);
41616 if (PyErr_Occurred()) SWIG_fail;
41617 }
41618 {
41619 resultobj = SWIG_From_int((int)(result));
41620 }
41621 return resultobj;
41622 fail:
41623 return NULL;
41624 }
41625
41626
41627 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41628 PyObject *resultobj;
41629 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41630 int result;
41631 PyObject * obj0 = 0 ;
41632 char *kwnames[] = {
41633 (char *) "self", NULL
41634 };
41635
41636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41638 if (SWIG_arg_fail(1)) SWIG_fail;
41639 {
41640 PyThreadState* __tstate = wxPyBeginAllowThreads();
41641 result = (int)(arg1)->GetVGap();
41642
41643 wxPyEndAllowThreads(__tstate);
41644 if (PyErr_Occurred()) SWIG_fail;
41645 }
41646 {
41647 resultobj = SWIG_From_int((int)(result));
41648 }
41649 return resultobj;
41650 fail:
41651 return NULL;
41652 }
41653
41654
41655 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41656 PyObject *resultobj;
41657 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41658 int result;
41659 PyObject * obj0 = 0 ;
41660 char *kwnames[] = {
41661 (char *) "self", NULL
41662 };
41663
41664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41666 if (SWIG_arg_fail(1)) SWIG_fail;
41667 {
41668 PyThreadState* __tstate = wxPyBeginAllowThreads();
41669 result = (int)(arg1)->GetHGap();
41670
41671 wxPyEndAllowThreads(__tstate);
41672 if (PyErr_Occurred()) SWIG_fail;
41673 }
41674 {
41675 resultobj = SWIG_From_int((int)(result));
41676 }
41677 return resultobj;
41678 fail:
41679 return NULL;
41680 }
41681
41682
41683 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41684 PyObject *obj;
41685 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41686 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41687 Py_INCREF(obj);
41688 return Py_BuildValue((char *)"");
41689 }
41690 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41691 PyObject *resultobj;
41692 int arg1 = (int) 1 ;
41693 int arg2 = (int) 0 ;
41694 int arg3 = (int) 0 ;
41695 int arg4 = (int) 0 ;
41696 wxFlexGridSizer *result;
41697 PyObject * obj0 = 0 ;
41698 PyObject * obj1 = 0 ;
41699 PyObject * obj2 = 0 ;
41700 PyObject * obj3 = 0 ;
41701 char *kwnames[] = {
41702 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41703 };
41704
41705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41706 if (obj0) {
41707 {
41708 arg1 = (int)(SWIG_As_int(obj0));
41709 if (SWIG_arg_fail(1)) SWIG_fail;
41710 }
41711 }
41712 if (obj1) {
41713 {
41714 arg2 = (int)(SWIG_As_int(obj1));
41715 if (SWIG_arg_fail(2)) SWIG_fail;
41716 }
41717 }
41718 if (obj2) {
41719 {
41720 arg3 = (int)(SWIG_As_int(obj2));
41721 if (SWIG_arg_fail(3)) SWIG_fail;
41722 }
41723 }
41724 if (obj3) {
41725 {
41726 arg4 = (int)(SWIG_As_int(obj3));
41727 if (SWIG_arg_fail(4)) SWIG_fail;
41728 }
41729 }
41730 {
41731 PyThreadState* __tstate = wxPyBeginAllowThreads();
41732 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41733
41734 wxPyEndAllowThreads(__tstate);
41735 if (PyErr_Occurred()) SWIG_fail;
41736 }
41737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41738 return resultobj;
41739 fail:
41740 return NULL;
41741 }
41742
41743
41744 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41745 PyObject *resultobj;
41746 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41747 size_t arg2 ;
41748 int arg3 = (int) 0 ;
41749 PyObject * obj0 = 0 ;
41750 PyObject * obj1 = 0 ;
41751 PyObject * obj2 = 0 ;
41752 char *kwnames[] = {
41753 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41754 };
41755
41756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41758 if (SWIG_arg_fail(1)) SWIG_fail;
41759 {
41760 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41761 if (SWIG_arg_fail(2)) SWIG_fail;
41762 }
41763 if (obj2) {
41764 {
41765 arg3 = (int)(SWIG_As_int(obj2));
41766 if (SWIG_arg_fail(3)) SWIG_fail;
41767 }
41768 }
41769 {
41770 PyThreadState* __tstate = wxPyBeginAllowThreads();
41771 (arg1)->AddGrowableRow(arg2,arg3);
41772
41773 wxPyEndAllowThreads(__tstate);
41774 if (PyErr_Occurred()) SWIG_fail;
41775 }
41776 Py_INCREF(Py_None); resultobj = Py_None;
41777 return resultobj;
41778 fail:
41779 return NULL;
41780 }
41781
41782
41783 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41784 PyObject *resultobj;
41785 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41786 size_t arg2 ;
41787 PyObject * obj0 = 0 ;
41788 PyObject * obj1 = 0 ;
41789 char *kwnames[] = {
41790 (char *) "self",(char *) "idx", NULL
41791 };
41792
41793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41795 if (SWIG_arg_fail(1)) SWIG_fail;
41796 {
41797 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41798 if (SWIG_arg_fail(2)) SWIG_fail;
41799 }
41800 {
41801 PyThreadState* __tstate = wxPyBeginAllowThreads();
41802 (arg1)->RemoveGrowableRow(arg2);
41803
41804 wxPyEndAllowThreads(__tstate);
41805 if (PyErr_Occurred()) SWIG_fail;
41806 }
41807 Py_INCREF(Py_None); resultobj = Py_None;
41808 return resultobj;
41809 fail:
41810 return NULL;
41811 }
41812
41813
41814 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41815 PyObject *resultobj;
41816 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41817 size_t arg2 ;
41818 int arg3 = (int) 0 ;
41819 PyObject * obj0 = 0 ;
41820 PyObject * obj1 = 0 ;
41821 PyObject * obj2 = 0 ;
41822 char *kwnames[] = {
41823 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41824 };
41825
41826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41828 if (SWIG_arg_fail(1)) SWIG_fail;
41829 {
41830 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41831 if (SWIG_arg_fail(2)) SWIG_fail;
41832 }
41833 if (obj2) {
41834 {
41835 arg3 = (int)(SWIG_As_int(obj2));
41836 if (SWIG_arg_fail(3)) SWIG_fail;
41837 }
41838 }
41839 {
41840 PyThreadState* __tstate = wxPyBeginAllowThreads();
41841 (arg1)->AddGrowableCol(arg2,arg3);
41842
41843 wxPyEndAllowThreads(__tstate);
41844 if (PyErr_Occurred()) SWIG_fail;
41845 }
41846 Py_INCREF(Py_None); resultobj = Py_None;
41847 return resultobj;
41848 fail:
41849 return NULL;
41850 }
41851
41852
41853 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41854 PyObject *resultobj;
41855 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41856 size_t arg2 ;
41857 PyObject * obj0 = 0 ;
41858 PyObject * obj1 = 0 ;
41859 char *kwnames[] = {
41860 (char *) "self",(char *) "idx", NULL
41861 };
41862
41863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41865 if (SWIG_arg_fail(1)) SWIG_fail;
41866 {
41867 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41868 if (SWIG_arg_fail(2)) SWIG_fail;
41869 }
41870 {
41871 PyThreadState* __tstate = wxPyBeginAllowThreads();
41872 (arg1)->RemoveGrowableCol(arg2);
41873
41874 wxPyEndAllowThreads(__tstate);
41875 if (PyErr_Occurred()) SWIG_fail;
41876 }
41877 Py_INCREF(Py_None); resultobj = Py_None;
41878 return resultobj;
41879 fail:
41880 return NULL;
41881 }
41882
41883
41884 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41885 PyObject *resultobj;
41886 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41887 int arg2 ;
41888 PyObject * obj0 = 0 ;
41889 PyObject * obj1 = 0 ;
41890 char *kwnames[] = {
41891 (char *) "self",(char *) "direction", NULL
41892 };
41893
41894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41896 if (SWIG_arg_fail(1)) SWIG_fail;
41897 {
41898 arg2 = (int)(SWIG_As_int(obj1));
41899 if (SWIG_arg_fail(2)) SWIG_fail;
41900 }
41901 {
41902 PyThreadState* __tstate = wxPyBeginAllowThreads();
41903 (arg1)->SetFlexibleDirection(arg2);
41904
41905 wxPyEndAllowThreads(__tstate);
41906 if (PyErr_Occurred()) SWIG_fail;
41907 }
41908 Py_INCREF(Py_None); resultobj = Py_None;
41909 return resultobj;
41910 fail:
41911 return NULL;
41912 }
41913
41914
41915 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41916 PyObject *resultobj;
41917 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41918 int result;
41919 PyObject * obj0 = 0 ;
41920 char *kwnames[] = {
41921 (char *) "self", NULL
41922 };
41923
41924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41926 if (SWIG_arg_fail(1)) SWIG_fail;
41927 {
41928 PyThreadState* __tstate = wxPyBeginAllowThreads();
41929 result = (int)(arg1)->GetFlexibleDirection();
41930
41931 wxPyEndAllowThreads(__tstate);
41932 if (PyErr_Occurred()) SWIG_fail;
41933 }
41934 {
41935 resultobj = SWIG_From_int((int)(result));
41936 }
41937 return resultobj;
41938 fail:
41939 return NULL;
41940 }
41941
41942
41943 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41944 PyObject *resultobj;
41945 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41946 wxFlexSizerGrowMode arg2 ;
41947 PyObject * obj0 = 0 ;
41948 PyObject * obj1 = 0 ;
41949 char *kwnames[] = {
41950 (char *) "self",(char *) "mode", NULL
41951 };
41952
41953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41955 if (SWIG_arg_fail(1)) SWIG_fail;
41956 {
41957 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41958 if (SWIG_arg_fail(2)) SWIG_fail;
41959 }
41960 {
41961 PyThreadState* __tstate = wxPyBeginAllowThreads();
41962 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41963
41964 wxPyEndAllowThreads(__tstate);
41965 if (PyErr_Occurred()) SWIG_fail;
41966 }
41967 Py_INCREF(Py_None); resultobj = Py_None;
41968 return resultobj;
41969 fail:
41970 return NULL;
41971 }
41972
41973
41974 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41975 PyObject *resultobj;
41976 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41977 wxFlexSizerGrowMode result;
41978 PyObject * obj0 = 0 ;
41979 char *kwnames[] = {
41980 (char *) "self", NULL
41981 };
41982
41983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41985 if (SWIG_arg_fail(1)) SWIG_fail;
41986 {
41987 PyThreadState* __tstate = wxPyBeginAllowThreads();
41988 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41989
41990 wxPyEndAllowThreads(__tstate);
41991 if (PyErr_Occurred()) SWIG_fail;
41992 }
41993 resultobj = SWIG_From_int((result));
41994 return resultobj;
41995 fail:
41996 return NULL;
41997 }
41998
41999
42000 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42001 PyObject *resultobj;
42002 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42003 wxArrayInt *result;
42004 PyObject * obj0 = 0 ;
42005 char *kwnames[] = {
42006 (char *) "self", NULL
42007 };
42008
42009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42011 if (SWIG_arg_fail(1)) SWIG_fail;
42012 {
42013 PyThreadState* __tstate = wxPyBeginAllowThreads();
42014 {
42015 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42016 result = (wxArrayInt *) &_result_ref;
42017 }
42018
42019 wxPyEndAllowThreads(__tstate);
42020 if (PyErr_Occurred()) SWIG_fail;
42021 }
42022 {
42023 resultobj = PyList_New(0);
42024 size_t idx;
42025 for (idx = 0; idx < result->GetCount(); idx += 1) {
42026 PyObject* val = PyInt_FromLong( result->Item(idx) );
42027 PyList_Append(resultobj, val);
42028 Py_DECREF(val);
42029 }
42030 }
42031 return resultobj;
42032 fail:
42033 return NULL;
42034 }
42035
42036
42037 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42038 PyObject *resultobj;
42039 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42040 wxArrayInt *result;
42041 PyObject * obj0 = 0 ;
42042 char *kwnames[] = {
42043 (char *) "self", NULL
42044 };
42045
42046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42048 if (SWIG_arg_fail(1)) SWIG_fail;
42049 {
42050 PyThreadState* __tstate = wxPyBeginAllowThreads();
42051 {
42052 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42053 result = (wxArrayInt *) &_result_ref;
42054 }
42055
42056 wxPyEndAllowThreads(__tstate);
42057 if (PyErr_Occurred()) SWIG_fail;
42058 }
42059 {
42060 resultobj = PyList_New(0);
42061 size_t idx;
42062 for (idx = 0; idx < result->GetCount(); idx += 1) {
42063 PyObject* val = PyInt_FromLong( result->Item(idx) );
42064 PyList_Append(resultobj, val);
42065 Py_DECREF(val);
42066 }
42067 }
42068 return resultobj;
42069 fail:
42070 return NULL;
42071 }
42072
42073
42074 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42075 PyObject *obj;
42076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42077 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42078 Py_INCREF(obj);
42079 return Py_BuildValue((char *)"");
42080 }
42081 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42082 PyObject *resultobj;
42083 wxStdDialogButtonSizer *result;
42084 char *kwnames[] = {
42085 NULL
42086 };
42087
42088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42089 {
42090 PyThreadState* __tstate = wxPyBeginAllowThreads();
42091 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42092
42093 wxPyEndAllowThreads(__tstate);
42094 if (PyErr_Occurred()) SWIG_fail;
42095 }
42096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42097 return resultobj;
42098 fail:
42099 return NULL;
42100 }
42101
42102
42103 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42104 PyObject *resultobj;
42105 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42106 wxButton *arg2 = (wxButton *) 0 ;
42107 PyObject * obj0 = 0 ;
42108 PyObject * obj1 = 0 ;
42109 char *kwnames[] = {
42110 (char *) "self",(char *) "button", NULL
42111 };
42112
42113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42115 if (SWIG_arg_fail(1)) SWIG_fail;
42116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42117 if (SWIG_arg_fail(2)) SWIG_fail;
42118 {
42119 PyThreadState* __tstate = wxPyBeginAllowThreads();
42120 (arg1)->AddButton(arg2);
42121
42122 wxPyEndAllowThreads(__tstate);
42123 if (PyErr_Occurred()) SWIG_fail;
42124 }
42125 Py_INCREF(Py_None); resultobj = Py_None;
42126 return resultobj;
42127 fail:
42128 return NULL;
42129 }
42130
42131
42132 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42133 PyObject *resultobj;
42134 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42135 PyObject * obj0 = 0 ;
42136 char *kwnames[] = {
42137 (char *) "self", NULL
42138 };
42139
42140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42142 if (SWIG_arg_fail(1)) SWIG_fail;
42143 {
42144 PyThreadState* __tstate = wxPyBeginAllowThreads();
42145 (arg1)->Realize();
42146
42147 wxPyEndAllowThreads(__tstate);
42148 if (PyErr_Occurred()) SWIG_fail;
42149 }
42150 Py_INCREF(Py_None); resultobj = Py_None;
42151 return resultobj;
42152 fail:
42153 return NULL;
42154 }
42155
42156
42157 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42158 PyObject *resultobj;
42159 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42160 wxButton *arg2 = (wxButton *) 0 ;
42161 PyObject * obj0 = 0 ;
42162 PyObject * obj1 = 0 ;
42163 char *kwnames[] = {
42164 (char *) "self",(char *) "button", NULL
42165 };
42166
42167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42169 if (SWIG_arg_fail(1)) SWIG_fail;
42170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42171 if (SWIG_arg_fail(2)) SWIG_fail;
42172 {
42173 PyThreadState* __tstate = wxPyBeginAllowThreads();
42174 (arg1)->SetAffirmativeButton(arg2);
42175
42176 wxPyEndAllowThreads(__tstate);
42177 if (PyErr_Occurred()) SWIG_fail;
42178 }
42179 Py_INCREF(Py_None); resultobj = Py_None;
42180 return resultobj;
42181 fail:
42182 return NULL;
42183 }
42184
42185
42186 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42187 PyObject *resultobj;
42188 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42189 wxButton *arg2 = (wxButton *) 0 ;
42190 PyObject * obj0 = 0 ;
42191 PyObject * obj1 = 0 ;
42192 char *kwnames[] = {
42193 (char *) "self",(char *) "button", NULL
42194 };
42195
42196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42198 if (SWIG_arg_fail(1)) SWIG_fail;
42199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42200 if (SWIG_arg_fail(2)) SWIG_fail;
42201 {
42202 PyThreadState* __tstate = wxPyBeginAllowThreads();
42203 (arg1)->SetNegativeButton(arg2);
42204
42205 wxPyEndAllowThreads(__tstate);
42206 if (PyErr_Occurred()) SWIG_fail;
42207 }
42208 Py_INCREF(Py_None); resultobj = Py_None;
42209 return resultobj;
42210 fail:
42211 return NULL;
42212 }
42213
42214
42215 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42216 PyObject *resultobj;
42217 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42218 wxButton *arg2 = (wxButton *) 0 ;
42219 PyObject * obj0 = 0 ;
42220 PyObject * obj1 = 0 ;
42221 char *kwnames[] = {
42222 (char *) "self",(char *) "button", NULL
42223 };
42224
42225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42227 if (SWIG_arg_fail(1)) SWIG_fail;
42228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42229 if (SWIG_arg_fail(2)) SWIG_fail;
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 (arg1)->SetCancelButton(arg2);
42233
42234 wxPyEndAllowThreads(__tstate);
42235 if (PyErr_Occurred()) SWIG_fail;
42236 }
42237 Py_INCREF(Py_None); resultobj = Py_None;
42238 return resultobj;
42239 fail:
42240 return NULL;
42241 }
42242
42243
42244 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42245 PyObject *resultobj;
42246 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42247 wxButton *result;
42248 PyObject * obj0 = 0 ;
42249 char *kwnames[] = {
42250 (char *) "self", NULL
42251 };
42252
42253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42255 if (SWIG_arg_fail(1)) SWIG_fail;
42256 {
42257 PyThreadState* __tstate = wxPyBeginAllowThreads();
42258 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42259
42260 wxPyEndAllowThreads(__tstate);
42261 if (PyErr_Occurred()) SWIG_fail;
42262 }
42263 {
42264 resultobj = wxPyMake_wxObject(result, 0);
42265 }
42266 return resultobj;
42267 fail:
42268 return NULL;
42269 }
42270
42271
42272 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42273 PyObject *resultobj;
42274 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42275 wxButton *result;
42276 PyObject * obj0 = 0 ;
42277 char *kwnames[] = {
42278 (char *) "self", NULL
42279 };
42280
42281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42283 if (SWIG_arg_fail(1)) SWIG_fail;
42284 {
42285 PyThreadState* __tstate = wxPyBeginAllowThreads();
42286 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42287
42288 wxPyEndAllowThreads(__tstate);
42289 if (PyErr_Occurred()) SWIG_fail;
42290 }
42291 {
42292 resultobj = wxPyMake_wxObject(result, 0);
42293 }
42294 return resultobj;
42295 fail:
42296 return NULL;
42297 }
42298
42299
42300 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42301 PyObject *resultobj;
42302 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42303 wxButton *result;
42304 PyObject * obj0 = 0 ;
42305 char *kwnames[] = {
42306 (char *) "self", NULL
42307 };
42308
42309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42311 if (SWIG_arg_fail(1)) SWIG_fail;
42312 {
42313 PyThreadState* __tstate = wxPyBeginAllowThreads();
42314 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42315
42316 wxPyEndAllowThreads(__tstate);
42317 if (PyErr_Occurred()) SWIG_fail;
42318 }
42319 {
42320 resultobj = wxPyMake_wxObject(result, 0);
42321 }
42322 return resultobj;
42323 fail:
42324 return NULL;
42325 }
42326
42327
42328 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42329 PyObject *resultobj;
42330 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42331 wxButton *result;
42332 PyObject * obj0 = 0 ;
42333 char *kwnames[] = {
42334 (char *) "self", NULL
42335 };
42336
42337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42339 if (SWIG_arg_fail(1)) SWIG_fail;
42340 {
42341 PyThreadState* __tstate = wxPyBeginAllowThreads();
42342 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42343
42344 wxPyEndAllowThreads(__tstate);
42345 if (PyErr_Occurred()) SWIG_fail;
42346 }
42347 {
42348 resultobj = wxPyMake_wxObject(result, 0);
42349 }
42350 return resultobj;
42351 fail:
42352 return NULL;
42353 }
42354
42355
42356 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42357 PyObject *resultobj;
42358 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42359 wxButton *result;
42360 PyObject * obj0 = 0 ;
42361 char *kwnames[] = {
42362 (char *) "self", NULL
42363 };
42364
42365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42367 if (SWIG_arg_fail(1)) SWIG_fail;
42368 {
42369 PyThreadState* __tstate = wxPyBeginAllowThreads();
42370 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42371
42372 wxPyEndAllowThreads(__tstate);
42373 if (PyErr_Occurred()) SWIG_fail;
42374 }
42375 {
42376 resultobj = wxPyMake_wxObject(result, 0);
42377 }
42378 return resultobj;
42379 fail:
42380 return NULL;
42381 }
42382
42383
42384 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42385 PyObject *obj;
42386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42387 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42388 Py_INCREF(obj);
42389 return Py_BuildValue((char *)"");
42390 }
42391 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42392 PyObject *resultobj;
42393 int arg1 = (int) 0 ;
42394 int arg2 = (int) 0 ;
42395 wxGBPosition *result;
42396 PyObject * obj0 = 0 ;
42397 PyObject * obj1 = 0 ;
42398 char *kwnames[] = {
42399 (char *) "row",(char *) "col", NULL
42400 };
42401
42402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42403 if (obj0) {
42404 {
42405 arg1 = (int)(SWIG_As_int(obj0));
42406 if (SWIG_arg_fail(1)) SWIG_fail;
42407 }
42408 }
42409 if (obj1) {
42410 {
42411 arg2 = (int)(SWIG_As_int(obj1));
42412 if (SWIG_arg_fail(2)) SWIG_fail;
42413 }
42414 }
42415 {
42416 PyThreadState* __tstate = wxPyBeginAllowThreads();
42417 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42418
42419 wxPyEndAllowThreads(__tstate);
42420 if (PyErr_Occurred()) SWIG_fail;
42421 }
42422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42423 return resultobj;
42424 fail:
42425 return NULL;
42426 }
42427
42428
42429 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42430 PyObject *resultobj;
42431 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42432 int result;
42433 PyObject * obj0 = 0 ;
42434 char *kwnames[] = {
42435 (char *) "self", NULL
42436 };
42437
42438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42440 if (SWIG_arg_fail(1)) SWIG_fail;
42441 {
42442 PyThreadState* __tstate = wxPyBeginAllowThreads();
42443 result = (int)((wxGBPosition const *)arg1)->GetRow();
42444
42445 wxPyEndAllowThreads(__tstate);
42446 if (PyErr_Occurred()) SWIG_fail;
42447 }
42448 {
42449 resultobj = SWIG_From_int((int)(result));
42450 }
42451 return resultobj;
42452 fail:
42453 return NULL;
42454 }
42455
42456
42457 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42458 PyObject *resultobj;
42459 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42460 int result;
42461 PyObject * obj0 = 0 ;
42462 char *kwnames[] = {
42463 (char *) "self", NULL
42464 };
42465
42466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42468 if (SWIG_arg_fail(1)) SWIG_fail;
42469 {
42470 PyThreadState* __tstate = wxPyBeginAllowThreads();
42471 result = (int)((wxGBPosition const *)arg1)->GetCol();
42472
42473 wxPyEndAllowThreads(__tstate);
42474 if (PyErr_Occurred()) SWIG_fail;
42475 }
42476 {
42477 resultobj = SWIG_From_int((int)(result));
42478 }
42479 return resultobj;
42480 fail:
42481 return NULL;
42482 }
42483
42484
42485 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42486 PyObject *resultobj;
42487 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42488 int arg2 ;
42489 PyObject * obj0 = 0 ;
42490 PyObject * obj1 = 0 ;
42491 char *kwnames[] = {
42492 (char *) "self",(char *) "row", NULL
42493 };
42494
42495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42497 if (SWIG_arg_fail(1)) SWIG_fail;
42498 {
42499 arg2 = (int)(SWIG_As_int(obj1));
42500 if (SWIG_arg_fail(2)) SWIG_fail;
42501 }
42502 {
42503 PyThreadState* __tstate = wxPyBeginAllowThreads();
42504 (arg1)->SetRow(arg2);
42505
42506 wxPyEndAllowThreads(__tstate);
42507 if (PyErr_Occurred()) SWIG_fail;
42508 }
42509 Py_INCREF(Py_None); resultobj = Py_None;
42510 return resultobj;
42511 fail:
42512 return NULL;
42513 }
42514
42515
42516 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42517 PyObject *resultobj;
42518 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42519 int arg2 ;
42520 PyObject * obj0 = 0 ;
42521 PyObject * obj1 = 0 ;
42522 char *kwnames[] = {
42523 (char *) "self",(char *) "col", NULL
42524 };
42525
42526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42528 if (SWIG_arg_fail(1)) SWIG_fail;
42529 {
42530 arg2 = (int)(SWIG_As_int(obj1));
42531 if (SWIG_arg_fail(2)) SWIG_fail;
42532 }
42533 {
42534 PyThreadState* __tstate = wxPyBeginAllowThreads();
42535 (arg1)->SetCol(arg2);
42536
42537 wxPyEndAllowThreads(__tstate);
42538 if (PyErr_Occurred()) SWIG_fail;
42539 }
42540 Py_INCREF(Py_None); resultobj = Py_None;
42541 return resultobj;
42542 fail:
42543 return NULL;
42544 }
42545
42546
42547 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42548 PyObject *resultobj;
42549 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42550 wxGBPosition *arg2 = 0 ;
42551 bool result;
42552 wxGBPosition temp2 ;
42553 PyObject * obj0 = 0 ;
42554 PyObject * obj1 = 0 ;
42555 char *kwnames[] = {
42556 (char *) "self",(char *) "other", NULL
42557 };
42558
42559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42561 if (SWIG_arg_fail(1)) SWIG_fail;
42562 {
42563 arg2 = &temp2;
42564 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42565 }
42566 {
42567 PyThreadState* __tstate = wxPyBeginAllowThreads();
42568 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42569
42570 wxPyEndAllowThreads(__tstate);
42571 if (PyErr_Occurred()) SWIG_fail;
42572 }
42573 {
42574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42575 }
42576 return resultobj;
42577 fail:
42578 return NULL;
42579 }
42580
42581
42582 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42583 PyObject *resultobj;
42584 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42585 wxGBPosition *arg2 = 0 ;
42586 bool result;
42587 wxGBPosition temp2 ;
42588 PyObject * obj0 = 0 ;
42589 PyObject * obj1 = 0 ;
42590 char *kwnames[] = {
42591 (char *) "self",(char *) "other", NULL
42592 };
42593
42594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42596 if (SWIG_arg_fail(1)) SWIG_fail;
42597 {
42598 arg2 = &temp2;
42599 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42600 }
42601 {
42602 PyThreadState* __tstate = wxPyBeginAllowThreads();
42603 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42604
42605 wxPyEndAllowThreads(__tstate);
42606 if (PyErr_Occurred()) SWIG_fail;
42607 }
42608 {
42609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42610 }
42611 return resultobj;
42612 fail:
42613 return NULL;
42614 }
42615
42616
42617 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42618 PyObject *resultobj;
42619 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42620 int arg2 = (int) 0 ;
42621 int arg3 = (int) 0 ;
42622 PyObject * obj0 = 0 ;
42623 PyObject * obj1 = 0 ;
42624 PyObject * obj2 = 0 ;
42625 char *kwnames[] = {
42626 (char *) "self",(char *) "row",(char *) "col", NULL
42627 };
42628
42629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42631 if (SWIG_arg_fail(1)) SWIG_fail;
42632 if (obj1) {
42633 {
42634 arg2 = (int)(SWIG_As_int(obj1));
42635 if (SWIG_arg_fail(2)) SWIG_fail;
42636 }
42637 }
42638 if (obj2) {
42639 {
42640 arg3 = (int)(SWIG_As_int(obj2));
42641 if (SWIG_arg_fail(3)) SWIG_fail;
42642 }
42643 }
42644 {
42645 PyThreadState* __tstate = wxPyBeginAllowThreads();
42646 wxGBPosition_Set(arg1,arg2,arg3);
42647
42648 wxPyEndAllowThreads(__tstate);
42649 if (PyErr_Occurred()) SWIG_fail;
42650 }
42651 Py_INCREF(Py_None); resultobj = Py_None;
42652 return resultobj;
42653 fail:
42654 return NULL;
42655 }
42656
42657
42658 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42659 PyObject *resultobj;
42660 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42661 PyObject *result;
42662 PyObject * obj0 = 0 ;
42663 char *kwnames[] = {
42664 (char *) "self", NULL
42665 };
42666
42667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42669 if (SWIG_arg_fail(1)) SWIG_fail;
42670 {
42671 PyThreadState* __tstate = wxPyBeginAllowThreads();
42672 result = (PyObject *)wxGBPosition_Get(arg1);
42673
42674 wxPyEndAllowThreads(__tstate);
42675 if (PyErr_Occurred()) SWIG_fail;
42676 }
42677 resultobj = result;
42678 return resultobj;
42679 fail:
42680 return NULL;
42681 }
42682
42683
42684 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42685 PyObject *obj;
42686 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42687 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42688 Py_INCREF(obj);
42689 return Py_BuildValue((char *)"");
42690 }
42691 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42692 PyObject *resultobj;
42693 int arg1 = (int) 1 ;
42694 int arg2 = (int) 1 ;
42695 wxGBSpan *result;
42696 PyObject * obj0 = 0 ;
42697 PyObject * obj1 = 0 ;
42698 char *kwnames[] = {
42699 (char *) "rowspan",(char *) "colspan", NULL
42700 };
42701
42702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42703 if (obj0) {
42704 {
42705 arg1 = (int)(SWIG_As_int(obj0));
42706 if (SWIG_arg_fail(1)) SWIG_fail;
42707 }
42708 }
42709 if (obj1) {
42710 {
42711 arg2 = (int)(SWIG_As_int(obj1));
42712 if (SWIG_arg_fail(2)) SWIG_fail;
42713 }
42714 }
42715 {
42716 PyThreadState* __tstate = wxPyBeginAllowThreads();
42717 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42718
42719 wxPyEndAllowThreads(__tstate);
42720 if (PyErr_Occurred()) SWIG_fail;
42721 }
42722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42723 return resultobj;
42724 fail:
42725 return NULL;
42726 }
42727
42728
42729 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42730 PyObject *resultobj;
42731 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42732 int result;
42733 PyObject * obj0 = 0 ;
42734 char *kwnames[] = {
42735 (char *) "self", NULL
42736 };
42737
42738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42740 if (SWIG_arg_fail(1)) SWIG_fail;
42741 {
42742 PyThreadState* __tstate = wxPyBeginAllowThreads();
42743 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42744
42745 wxPyEndAllowThreads(__tstate);
42746 if (PyErr_Occurred()) SWIG_fail;
42747 }
42748 {
42749 resultobj = SWIG_From_int((int)(result));
42750 }
42751 return resultobj;
42752 fail:
42753 return NULL;
42754 }
42755
42756
42757 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42758 PyObject *resultobj;
42759 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42760 int result;
42761 PyObject * obj0 = 0 ;
42762 char *kwnames[] = {
42763 (char *) "self", NULL
42764 };
42765
42766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42768 if (SWIG_arg_fail(1)) SWIG_fail;
42769 {
42770 PyThreadState* __tstate = wxPyBeginAllowThreads();
42771 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42772
42773 wxPyEndAllowThreads(__tstate);
42774 if (PyErr_Occurred()) SWIG_fail;
42775 }
42776 {
42777 resultobj = SWIG_From_int((int)(result));
42778 }
42779 return resultobj;
42780 fail:
42781 return NULL;
42782 }
42783
42784
42785 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42786 PyObject *resultobj;
42787 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42788 int arg2 ;
42789 PyObject * obj0 = 0 ;
42790 PyObject * obj1 = 0 ;
42791 char *kwnames[] = {
42792 (char *) "self",(char *) "rowspan", NULL
42793 };
42794
42795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42797 if (SWIG_arg_fail(1)) SWIG_fail;
42798 {
42799 arg2 = (int)(SWIG_As_int(obj1));
42800 if (SWIG_arg_fail(2)) SWIG_fail;
42801 }
42802 {
42803 PyThreadState* __tstate = wxPyBeginAllowThreads();
42804 (arg1)->SetRowspan(arg2);
42805
42806 wxPyEndAllowThreads(__tstate);
42807 if (PyErr_Occurred()) SWIG_fail;
42808 }
42809 Py_INCREF(Py_None); resultobj = Py_None;
42810 return resultobj;
42811 fail:
42812 return NULL;
42813 }
42814
42815
42816 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42817 PyObject *resultobj;
42818 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42819 int arg2 ;
42820 PyObject * obj0 = 0 ;
42821 PyObject * obj1 = 0 ;
42822 char *kwnames[] = {
42823 (char *) "self",(char *) "colspan", NULL
42824 };
42825
42826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42828 if (SWIG_arg_fail(1)) SWIG_fail;
42829 {
42830 arg2 = (int)(SWIG_As_int(obj1));
42831 if (SWIG_arg_fail(2)) SWIG_fail;
42832 }
42833 {
42834 PyThreadState* __tstate = wxPyBeginAllowThreads();
42835 (arg1)->SetColspan(arg2);
42836
42837 wxPyEndAllowThreads(__tstate);
42838 if (PyErr_Occurred()) SWIG_fail;
42839 }
42840 Py_INCREF(Py_None); resultobj = Py_None;
42841 return resultobj;
42842 fail:
42843 return NULL;
42844 }
42845
42846
42847 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42848 PyObject *resultobj;
42849 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42850 wxGBSpan *arg2 = 0 ;
42851 bool result;
42852 wxGBSpan temp2 ;
42853 PyObject * obj0 = 0 ;
42854 PyObject * obj1 = 0 ;
42855 char *kwnames[] = {
42856 (char *) "self",(char *) "other", NULL
42857 };
42858
42859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42861 if (SWIG_arg_fail(1)) SWIG_fail;
42862 {
42863 arg2 = &temp2;
42864 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42865 }
42866 {
42867 PyThreadState* __tstate = wxPyBeginAllowThreads();
42868 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42869
42870 wxPyEndAllowThreads(__tstate);
42871 if (PyErr_Occurred()) SWIG_fail;
42872 }
42873 {
42874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42875 }
42876 return resultobj;
42877 fail:
42878 return NULL;
42879 }
42880
42881
42882 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42883 PyObject *resultobj;
42884 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42885 wxGBSpan *arg2 = 0 ;
42886 bool result;
42887 wxGBSpan temp2 ;
42888 PyObject * obj0 = 0 ;
42889 PyObject * obj1 = 0 ;
42890 char *kwnames[] = {
42891 (char *) "self",(char *) "other", NULL
42892 };
42893
42894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42896 if (SWIG_arg_fail(1)) SWIG_fail;
42897 {
42898 arg2 = &temp2;
42899 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42900 }
42901 {
42902 PyThreadState* __tstate = wxPyBeginAllowThreads();
42903 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42904
42905 wxPyEndAllowThreads(__tstate);
42906 if (PyErr_Occurred()) SWIG_fail;
42907 }
42908 {
42909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42910 }
42911 return resultobj;
42912 fail:
42913 return NULL;
42914 }
42915
42916
42917 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42918 PyObject *resultobj;
42919 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42920 int arg2 = (int) 1 ;
42921 int arg3 = (int) 1 ;
42922 PyObject * obj0 = 0 ;
42923 PyObject * obj1 = 0 ;
42924 PyObject * obj2 = 0 ;
42925 char *kwnames[] = {
42926 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42927 };
42928
42929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42931 if (SWIG_arg_fail(1)) SWIG_fail;
42932 if (obj1) {
42933 {
42934 arg2 = (int)(SWIG_As_int(obj1));
42935 if (SWIG_arg_fail(2)) SWIG_fail;
42936 }
42937 }
42938 if (obj2) {
42939 {
42940 arg3 = (int)(SWIG_As_int(obj2));
42941 if (SWIG_arg_fail(3)) SWIG_fail;
42942 }
42943 }
42944 {
42945 PyThreadState* __tstate = wxPyBeginAllowThreads();
42946 wxGBSpan_Set(arg1,arg2,arg3);
42947
42948 wxPyEndAllowThreads(__tstate);
42949 if (PyErr_Occurred()) SWIG_fail;
42950 }
42951 Py_INCREF(Py_None); resultobj = Py_None;
42952 return resultobj;
42953 fail:
42954 return NULL;
42955 }
42956
42957
42958 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42959 PyObject *resultobj;
42960 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42961 PyObject *result;
42962 PyObject * obj0 = 0 ;
42963 char *kwnames[] = {
42964 (char *) "self", NULL
42965 };
42966
42967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42969 if (SWIG_arg_fail(1)) SWIG_fail;
42970 {
42971 PyThreadState* __tstate = wxPyBeginAllowThreads();
42972 result = (PyObject *)wxGBSpan_Get(arg1);
42973
42974 wxPyEndAllowThreads(__tstate);
42975 if (PyErr_Occurred()) SWIG_fail;
42976 }
42977 resultobj = result;
42978 return resultobj;
42979 fail:
42980 return NULL;
42981 }
42982
42983
42984 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42985 PyObject *obj;
42986 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42987 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42988 Py_INCREF(obj);
42989 return Py_BuildValue((char *)"");
42990 }
42991 static int _wrap_DefaultSpan_set(PyObject *) {
42992 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42993 return 1;
42994 }
42995
42996
42997 static PyObject *_wrap_DefaultSpan_get(void) {
42998 PyObject *pyobj;
42999
43000 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43001 return pyobj;
43002 }
43003
43004
43005 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43006 PyObject *resultobj;
43007 wxGBSizerItem *result;
43008 char *kwnames[] = {
43009 NULL
43010 };
43011
43012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43013 {
43014 PyThreadState* __tstate = wxPyBeginAllowThreads();
43015 result = (wxGBSizerItem *)new wxGBSizerItem();
43016
43017 wxPyEndAllowThreads(__tstate);
43018 if (PyErr_Occurred()) SWIG_fail;
43019 }
43020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43021 return resultobj;
43022 fail:
43023 return NULL;
43024 }
43025
43026
43027 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43028 PyObject *resultobj;
43029 wxWindow *arg1 = (wxWindow *) 0 ;
43030 wxGBPosition *arg2 = 0 ;
43031 wxGBSpan *arg3 = 0 ;
43032 int arg4 ;
43033 int arg5 ;
43034 PyObject *arg6 = (PyObject *) NULL ;
43035 wxGBSizerItem *result;
43036 wxGBPosition temp2 ;
43037 wxGBSpan temp3 ;
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 char *kwnames[] = {
43045 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43046 };
43047
43048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43050 if (SWIG_arg_fail(1)) SWIG_fail;
43051 {
43052 arg2 = &temp2;
43053 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43054 }
43055 {
43056 arg3 = &temp3;
43057 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43058 }
43059 {
43060 arg4 = (int)(SWIG_As_int(obj3));
43061 if (SWIG_arg_fail(4)) SWIG_fail;
43062 }
43063 {
43064 arg5 = (int)(SWIG_As_int(obj4));
43065 if (SWIG_arg_fail(5)) SWIG_fail;
43066 }
43067 if (obj5) {
43068 arg6 = obj5;
43069 }
43070 {
43071 PyThreadState* __tstate = wxPyBeginAllowThreads();
43072 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43073
43074 wxPyEndAllowThreads(__tstate);
43075 if (PyErr_Occurred()) SWIG_fail;
43076 }
43077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43078 return resultobj;
43079 fail:
43080 return NULL;
43081 }
43082
43083
43084 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43085 PyObject *resultobj;
43086 wxSizer *arg1 = (wxSizer *) 0 ;
43087 wxGBPosition *arg2 = 0 ;
43088 wxGBSpan *arg3 = 0 ;
43089 int arg4 ;
43090 int arg5 ;
43091 PyObject *arg6 = (PyObject *) NULL ;
43092 wxGBSizerItem *result;
43093 wxGBPosition temp2 ;
43094 wxGBSpan temp3 ;
43095 PyObject * obj0 = 0 ;
43096 PyObject * obj1 = 0 ;
43097 PyObject * obj2 = 0 ;
43098 PyObject * obj3 = 0 ;
43099 PyObject * obj4 = 0 ;
43100 PyObject * obj5 = 0 ;
43101 char *kwnames[] = {
43102 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43103 };
43104
43105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43107 if (SWIG_arg_fail(1)) SWIG_fail;
43108 {
43109 arg2 = &temp2;
43110 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43111 }
43112 {
43113 arg3 = &temp3;
43114 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43115 }
43116 {
43117 arg4 = (int)(SWIG_As_int(obj3));
43118 if (SWIG_arg_fail(4)) SWIG_fail;
43119 }
43120 {
43121 arg5 = (int)(SWIG_As_int(obj4));
43122 if (SWIG_arg_fail(5)) SWIG_fail;
43123 }
43124 if (obj5) {
43125 arg6 = obj5;
43126 }
43127 {
43128 PyThreadState* __tstate = wxPyBeginAllowThreads();
43129 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43130
43131 wxPyEndAllowThreads(__tstate);
43132 if (PyErr_Occurred()) SWIG_fail;
43133 }
43134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43135 return resultobj;
43136 fail:
43137 return NULL;
43138 }
43139
43140
43141 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43142 PyObject *resultobj;
43143 int arg1 ;
43144 int arg2 ;
43145 wxGBPosition *arg3 = 0 ;
43146 wxGBSpan *arg4 = 0 ;
43147 int arg5 ;
43148 int arg6 ;
43149 PyObject *arg7 = (PyObject *) NULL ;
43150 wxGBSizerItem *result;
43151 wxGBPosition temp3 ;
43152 wxGBSpan temp4 ;
43153 PyObject * obj0 = 0 ;
43154 PyObject * obj1 = 0 ;
43155 PyObject * obj2 = 0 ;
43156 PyObject * obj3 = 0 ;
43157 PyObject * obj4 = 0 ;
43158 PyObject * obj5 = 0 ;
43159 PyObject * obj6 = 0 ;
43160 char *kwnames[] = {
43161 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43162 };
43163
43164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43165 {
43166 arg1 = (int)(SWIG_As_int(obj0));
43167 if (SWIG_arg_fail(1)) SWIG_fail;
43168 }
43169 {
43170 arg2 = (int)(SWIG_As_int(obj1));
43171 if (SWIG_arg_fail(2)) SWIG_fail;
43172 }
43173 {
43174 arg3 = &temp3;
43175 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43176 }
43177 {
43178 arg4 = &temp4;
43179 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43180 }
43181 {
43182 arg5 = (int)(SWIG_As_int(obj4));
43183 if (SWIG_arg_fail(5)) SWIG_fail;
43184 }
43185 {
43186 arg6 = (int)(SWIG_As_int(obj5));
43187 if (SWIG_arg_fail(6)) SWIG_fail;
43188 }
43189 if (obj6) {
43190 arg7 = obj6;
43191 }
43192 {
43193 PyThreadState* __tstate = wxPyBeginAllowThreads();
43194 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43195
43196 wxPyEndAllowThreads(__tstate);
43197 if (PyErr_Occurred()) SWIG_fail;
43198 }
43199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43200 return resultobj;
43201 fail:
43202 return NULL;
43203 }
43204
43205
43206 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43207 PyObject *resultobj;
43208 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43209 wxGBPosition result;
43210 PyObject * obj0 = 0 ;
43211 char *kwnames[] = {
43212 (char *) "self", NULL
43213 };
43214
43215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43217 if (SWIG_arg_fail(1)) SWIG_fail;
43218 {
43219 PyThreadState* __tstate = wxPyBeginAllowThreads();
43220 result = ((wxGBSizerItem const *)arg1)->GetPos();
43221
43222 wxPyEndAllowThreads(__tstate);
43223 if (PyErr_Occurred()) SWIG_fail;
43224 }
43225 {
43226 wxGBPosition * resultptr;
43227 resultptr = new wxGBPosition((wxGBPosition &)(result));
43228 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43229 }
43230 return resultobj;
43231 fail:
43232 return NULL;
43233 }
43234
43235
43236 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43237 PyObject *resultobj;
43238 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43239 wxGBSpan result;
43240 PyObject * obj0 = 0 ;
43241 char *kwnames[] = {
43242 (char *) "self", NULL
43243 };
43244
43245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43247 if (SWIG_arg_fail(1)) SWIG_fail;
43248 {
43249 PyThreadState* __tstate = wxPyBeginAllowThreads();
43250 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43251
43252 wxPyEndAllowThreads(__tstate);
43253 if (PyErr_Occurred()) SWIG_fail;
43254 }
43255 {
43256 wxGBSpan * resultptr;
43257 resultptr = new wxGBSpan((wxGBSpan &)(result));
43258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43259 }
43260 return resultobj;
43261 fail:
43262 return NULL;
43263 }
43264
43265
43266 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43267 PyObject *resultobj;
43268 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43269 wxGBPosition *arg2 = 0 ;
43270 bool result;
43271 wxGBPosition temp2 ;
43272 PyObject * obj0 = 0 ;
43273 PyObject * obj1 = 0 ;
43274 char *kwnames[] = {
43275 (char *) "self",(char *) "pos", NULL
43276 };
43277
43278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43280 if (SWIG_arg_fail(1)) SWIG_fail;
43281 {
43282 arg2 = &temp2;
43283 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43284 }
43285 {
43286 PyThreadState* __tstate = wxPyBeginAllowThreads();
43287 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43288
43289 wxPyEndAllowThreads(__tstate);
43290 if (PyErr_Occurred()) SWIG_fail;
43291 }
43292 {
43293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43294 }
43295 return resultobj;
43296 fail:
43297 return NULL;
43298 }
43299
43300
43301 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43302 PyObject *resultobj;
43303 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43304 wxGBSpan *arg2 = 0 ;
43305 bool result;
43306 wxGBSpan temp2 ;
43307 PyObject * obj0 = 0 ;
43308 PyObject * obj1 = 0 ;
43309 char *kwnames[] = {
43310 (char *) "self",(char *) "span", NULL
43311 };
43312
43313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43315 if (SWIG_arg_fail(1)) SWIG_fail;
43316 {
43317 arg2 = &temp2;
43318 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43319 }
43320 {
43321 PyThreadState* __tstate = wxPyBeginAllowThreads();
43322 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43323
43324 wxPyEndAllowThreads(__tstate);
43325 if (PyErr_Occurred()) SWIG_fail;
43326 }
43327 {
43328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43329 }
43330 return resultobj;
43331 fail:
43332 return NULL;
43333 }
43334
43335
43336 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43337 PyObject *resultobj;
43338 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43339 wxGBSizerItem *arg2 = 0 ;
43340 bool result;
43341 PyObject * obj0 = 0 ;
43342 PyObject * obj1 = 0 ;
43343 char *kwnames[] = {
43344 (char *) "self",(char *) "other", NULL
43345 };
43346
43347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43349 if (SWIG_arg_fail(1)) SWIG_fail;
43350 {
43351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43352 if (SWIG_arg_fail(2)) SWIG_fail;
43353 if (arg2 == NULL) {
43354 SWIG_null_ref("wxGBSizerItem");
43355 }
43356 if (SWIG_arg_fail(2)) SWIG_fail;
43357 }
43358 {
43359 PyThreadState* __tstate = wxPyBeginAllowThreads();
43360 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43361
43362 wxPyEndAllowThreads(__tstate);
43363 if (PyErr_Occurred()) SWIG_fail;
43364 }
43365 {
43366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43367 }
43368 return resultobj;
43369 fail:
43370 return NULL;
43371 }
43372
43373
43374 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43375 PyObject *resultobj;
43376 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43377 wxGBPosition *arg2 = 0 ;
43378 wxGBSpan *arg3 = 0 ;
43379 bool result;
43380 wxGBPosition temp2 ;
43381 wxGBSpan temp3 ;
43382 PyObject * obj0 = 0 ;
43383 PyObject * obj1 = 0 ;
43384 PyObject * obj2 = 0 ;
43385 char *kwnames[] = {
43386 (char *) "self",(char *) "pos",(char *) "span", NULL
43387 };
43388
43389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43391 if (SWIG_arg_fail(1)) SWIG_fail;
43392 {
43393 arg2 = &temp2;
43394 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43395 }
43396 {
43397 arg3 = &temp3;
43398 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43399 }
43400 {
43401 PyThreadState* __tstate = wxPyBeginAllowThreads();
43402 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43403
43404 wxPyEndAllowThreads(__tstate);
43405 if (PyErr_Occurred()) SWIG_fail;
43406 }
43407 {
43408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43409 }
43410 return resultobj;
43411 fail:
43412 return NULL;
43413 }
43414
43415
43416 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43417 PyObject *resultobj;
43418 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43419 wxGBPosition result;
43420 PyObject * obj0 = 0 ;
43421 char *kwnames[] = {
43422 (char *) "self", NULL
43423 };
43424
43425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43427 if (SWIG_arg_fail(1)) SWIG_fail;
43428 {
43429 PyThreadState* __tstate = wxPyBeginAllowThreads();
43430 result = wxGBSizerItem_GetEndPos(arg1);
43431
43432 wxPyEndAllowThreads(__tstate);
43433 if (PyErr_Occurred()) SWIG_fail;
43434 }
43435 {
43436 wxGBPosition * resultptr;
43437 resultptr = new wxGBPosition((wxGBPosition &)(result));
43438 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43439 }
43440 return resultobj;
43441 fail:
43442 return NULL;
43443 }
43444
43445
43446 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43447 PyObject *resultobj;
43448 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43449 wxGridBagSizer *result;
43450 PyObject * obj0 = 0 ;
43451 char *kwnames[] = {
43452 (char *) "self", NULL
43453 };
43454
43455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43457 if (SWIG_arg_fail(1)) SWIG_fail;
43458 {
43459 PyThreadState* __tstate = wxPyBeginAllowThreads();
43460 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43461
43462 wxPyEndAllowThreads(__tstate);
43463 if (PyErr_Occurred()) SWIG_fail;
43464 }
43465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43466 return resultobj;
43467 fail:
43468 return NULL;
43469 }
43470
43471
43472 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43473 PyObject *resultobj;
43474 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43475 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43476 PyObject * obj0 = 0 ;
43477 PyObject * obj1 = 0 ;
43478 char *kwnames[] = {
43479 (char *) "self",(char *) "sizer", NULL
43480 };
43481
43482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43484 if (SWIG_arg_fail(1)) SWIG_fail;
43485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43486 if (SWIG_arg_fail(2)) SWIG_fail;
43487 {
43488 PyThreadState* __tstate = wxPyBeginAllowThreads();
43489 (arg1)->SetGBSizer(arg2);
43490
43491 wxPyEndAllowThreads(__tstate);
43492 if (PyErr_Occurred()) SWIG_fail;
43493 }
43494 Py_INCREF(Py_None); resultobj = Py_None;
43495 return resultobj;
43496 fail:
43497 return NULL;
43498 }
43499
43500
43501 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43502 PyObject *obj;
43503 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43504 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43505 Py_INCREF(obj);
43506 return Py_BuildValue((char *)"");
43507 }
43508 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43509 PyObject *resultobj;
43510 int arg1 = (int) 0 ;
43511 int arg2 = (int) 0 ;
43512 wxGridBagSizer *result;
43513 PyObject * obj0 = 0 ;
43514 PyObject * obj1 = 0 ;
43515 char *kwnames[] = {
43516 (char *) "vgap",(char *) "hgap", NULL
43517 };
43518
43519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43520 if (obj0) {
43521 {
43522 arg1 = (int)(SWIG_As_int(obj0));
43523 if (SWIG_arg_fail(1)) SWIG_fail;
43524 }
43525 }
43526 if (obj1) {
43527 {
43528 arg2 = (int)(SWIG_As_int(obj1));
43529 if (SWIG_arg_fail(2)) SWIG_fail;
43530 }
43531 }
43532 {
43533 PyThreadState* __tstate = wxPyBeginAllowThreads();
43534 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43535
43536 wxPyEndAllowThreads(__tstate);
43537 if (PyErr_Occurred()) SWIG_fail;
43538 }
43539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43540 return resultobj;
43541 fail:
43542 return NULL;
43543 }
43544
43545
43546 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43547 PyObject *resultobj;
43548 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43549 PyObject *arg2 = (PyObject *) 0 ;
43550 wxGBPosition *arg3 = 0 ;
43551 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43552 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43553 int arg5 = (int) 0 ;
43554 int arg6 = (int) 0 ;
43555 PyObject *arg7 = (PyObject *) NULL ;
43556 wxGBSizerItem *result;
43557 wxGBPosition temp3 ;
43558 wxGBSpan temp4 ;
43559 PyObject * obj0 = 0 ;
43560 PyObject * obj1 = 0 ;
43561 PyObject * obj2 = 0 ;
43562 PyObject * obj3 = 0 ;
43563 PyObject * obj4 = 0 ;
43564 PyObject * obj5 = 0 ;
43565 PyObject * obj6 = 0 ;
43566 char *kwnames[] = {
43567 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43568 };
43569
43570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43572 if (SWIG_arg_fail(1)) SWIG_fail;
43573 arg2 = obj1;
43574 {
43575 arg3 = &temp3;
43576 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43577 }
43578 if (obj3) {
43579 {
43580 arg4 = &temp4;
43581 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43582 }
43583 }
43584 if (obj4) {
43585 {
43586 arg5 = (int)(SWIG_As_int(obj4));
43587 if (SWIG_arg_fail(5)) SWIG_fail;
43588 }
43589 }
43590 if (obj5) {
43591 {
43592 arg6 = (int)(SWIG_As_int(obj5));
43593 if (SWIG_arg_fail(6)) SWIG_fail;
43594 }
43595 }
43596 if (obj6) {
43597 arg7 = obj6;
43598 }
43599 {
43600 PyThreadState* __tstate = wxPyBeginAllowThreads();
43601 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43602
43603 wxPyEndAllowThreads(__tstate);
43604 if (PyErr_Occurred()) SWIG_fail;
43605 }
43606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43607 return resultobj;
43608 fail:
43609 return NULL;
43610 }
43611
43612
43613 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43614 PyObject *resultobj;
43615 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43616 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43617 wxGBSizerItem *result;
43618 PyObject * obj0 = 0 ;
43619 PyObject * obj1 = 0 ;
43620 char *kwnames[] = {
43621 (char *) "self",(char *) "item", NULL
43622 };
43623
43624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&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_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43628 if (SWIG_arg_fail(2)) SWIG_fail;
43629 {
43630 PyThreadState* __tstate = wxPyBeginAllowThreads();
43631 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43632
43633 wxPyEndAllowThreads(__tstate);
43634 if (PyErr_Occurred()) SWIG_fail;
43635 }
43636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43637 return resultobj;
43638 fail:
43639 return NULL;
43640 }
43641
43642
43643 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43644 PyObject *resultobj;
43645 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43646 int arg2 ;
43647 int arg3 ;
43648 wxSize result;
43649 PyObject * obj0 = 0 ;
43650 PyObject * obj1 = 0 ;
43651 PyObject * obj2 = 0 ;
43652 char *kwnames[] = {
43653 (char *) "self",(char *) "row",(char *) "col", NULL
43654 };
43655
43656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43658 if (SWIG_arg_fail(1)) SWIG_fail;
43659 {
43660 arg2 = (int)(SWIG_As_int(obj1));
43661 if (SWIG_arg_fail(2)) SWIG_fail;
43662 }
43663 {
43664 arg3 = (int)(SWIG_As_int(obj2));
43665 if (SWIG_arg_fail(3)) SWIG_fail;
43666 }
43667 {
43668 PyThreadState* __tstate = wxPyBeginAllowThreads();
43669 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43670
43671 wxPyEndAllowThreads(__tstate);
43672 if (PyErr_Occurred()) SWIG_fail;
43673 }
43674 {
43675 wxSize * resultptr;
43676 resultptr = new wxSize((wxSize &)(result));
43677 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43678 }
43679 return resultobj;
43680 fail:
43681 return NULL;
43682 }
43683
43684
43685 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43686 PyObject *resultobj;
43687 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43688 wxSize result;
43689 PyObject * obj0 = 0 ;
43690 char *kwnames[] = {
43691 (char *) "self", NULL
43692 };
43693
43694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43696 if (SWIG_arg_fail(1)) SWIG_fail;
43697 {
43698 PyThreadState* __tstate = wxPyBeginAllowThreads();
43699 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43700
43701 wxPyEndAllowThreads(__tstate);
43702 if (PyErr_Occurred()) SWIG_fail;
43703 }
43704 {
43705 wxSize * resultptr;
43706 resultptr = new wxSize((wxSize &)(result));
43707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43708 }
43709 return resultobj;
43710 fail:
43711 return NULL;
43712 }
43713
43714
43715 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43716 PyObject *resultobj;
43717 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43718 wxSize *arg2 = 0 ;
43719 wxSize temp2 ;
43720 PyObject * obj0 = 0 ;
43721 PyObject * obj1 = 0 ;
43722 char *kwnames[] = {
43723 (char *) "self",(char *) "sz", NULL
43724 };
43725
43726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43728 if (SWIG_arg_fail(1)) SWIG_fail;
43729 {
43730 arg2 = &temp2;
43731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43732 }
43733 {
43734 PyThreadState* __tstate = wxPyBeginAllowThreads();
43735 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43736
43737 wxPyEndAllowThreads(__tstate);
43738 if (PyErr_Occurred()) SWIG_fail;
43739 }
43740 Py_INCREF(Py_None); resultobj = Py_None;
43741 return resultobj;
43742 fail:
43743 return NULL;
43744 }
43745
43746
43747 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43748 PyObject *resultobj;
43749 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43750 wxWindow *arg2 = (wxWindow *) 0 ;
43751 wxGBPosition result;
43752 PyObject * obj0 = 0 ;
43753 PyObject * obj1 = 0 ;
43754
43755 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43757 if (SWIG_arg_fail(1)) SWIG_fail;
43758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43759 if (SWIG_arg_fail(2)) SWIG_fail;
43760 {
43761 PyThreadState* __tstate = wxPyBeginAllowThreads();
43762 result = (arg1)->GetItemPosition(arg2);
43763
43764 wxPyEndAllowThreads(__tstate);
43765 if (PyErr_Occurred()) SWIG_fail;
43766 }
43767 {
43768 wxGBPosition * resultptr;
43769 resultptr = new wxGBPosition((wxGBPosition &)(result));
43770 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43771 }
43772 return resultobj;
43773 fail:
43774 return NULL;
43775 }
43776
43777
43778 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43779 PyObject *resultobj;
43780 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43781 wxSizer *arg2 = (wxSizer *) 0 ;
43782 wxGBPosition result;
43783 PyObject * obj0 = 0 ;
43784 PyObject * obj1 = 0 ;
43785
43786 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43788 if (SWIG_arg_fail(1)) SWIG_fail;
43789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43790 if (SWIG_arg_fail(2)) SWIG_fail;
43791 {
43792 PyThreadState* __tstate = wxPyBeginAllowThreads();
43793 result = (arg1)->GetItemPosition(arg2);
43794
43795 wxPyEndAllowThreads(__tstate);
43796 if (PyErr_Occurred()) SWIG_fail;
43797 }
43798 {
43799 wxGBPosition * resultptr;
43800 resultptr = new wxGBPosition((wxGBPosition &)(result));
43801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43802 }
43803 return resultobj;
43804 fail:
43805 return NULL;
43806 }
43807
43808
43809 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43810 PyObject *resultobj;
43811 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43812 size_t arg2 ;
43813 wxGBPosition result;
43814 PyObject * obj0 = 0 ;
43815 PyObject * obj1 = 0 ;
43816
43817 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43819 if (SWIG_arg_fail(1)) SWIG_fail;
43820 {
43821 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43822 if (SWIG_arg_fail(2)) SWIG_fail;
43823 }
43824 {
43825 PyThreadState* __tstate = wxPyBeginAllowThreads();
43826 result = (arg1)->GetItemPosition(arg2);
43827
43828 wxPyEndAllowThreads(__tstate);
43829 if (PyErr_Occurred()) SWIG_fail;
43830 }
43831 {
43832 wxGBPosition * resultptr;
43833 resultptr = new wxGBPosition((wxGBPosition &)(result));
43834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43835 }
43836 return resultobj;
43837 fail:
43838 return NULL;
43839 }
43840
43841
43842 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43843 int argc;
43844 PyObject *argv[3];
43845 int ii;
43846
43847 argc = PyObject_Length(args);
43848 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43849 argv[ii] = PyTuple_GetItem(args,ii);
43850 }
43851 if (argc == 2) {
43852 int _v;
43853 {
43854 void *ptr;
43855 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43856 _v = 0;
43857 PyErr_Clear();
43858 } else {
43859 _v = 1;
43860 }
43861 }
43862 if (_v) {
43863 {
43864 void *ptr;
43865 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43866 _v = 0;
43867 PyErr_Clear();
43868 } else {
43869 _v = 1;
43870 }
43871 }
43872 if (_v) {
43873 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43874 }
43875 }
43876 }
43877 if (argc == 2) {
43878 int _v;
43879 {
43880 void *ptr;
43881 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43882 _v = 0;
43883 PyErr_Clear();
43884 } else {
43885 _v = 1;
43886 }
43887 }
43888 if (_v) {
43889 {
43890 void *ptr;
43891 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43892 _v = 0;
43893 PyErr_Clear();
43894 } else {
43895 _v = 1;
43896 }
43897 }
43898 if (_v) {
43899 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43900 }
43901 }
43902 }
43903 if (argc == 2) {
43904 int _v;
43905 {
43906 void *ptr;
43907 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43908 _v = 0;
43909 PyErr_Clear();
43910 } else {
43911 _v = 1;
43912 }
43913 }
43914 if (_v) {
43915 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43916 if (_v) {
43917 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43918 }
43919 }
43920 }
43921
43922 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43923 return NULL;
43924 }
43925
43926
43927 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43928 PyObject *resultobj;
43929 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43930 wxWindow *arg2 = (wxWindow *) 0 ;
43931 wxGBPosition *arg3 = 0 ;
43932 bool result;
43933 wxGBPosition temp3 ;
43934 PyObject * obj0 = 0 ;
43935 PyObject * obj1 = 0 ;
43936 PyObject * obj2 = 0 ;
43937
43938 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43940 if (SWIG_arg_fail(1)) SWIG_fail;
43941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43942 if (SWIG_arg_fail(2)) SWIG_fail;
43943 {
43944 arg3 = &temp3;
43945 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43946 }
43947 {
43948 PyThreadState* __tstate = wxPyBeginAllowThreads();
43949 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43950
43951 wxPyEndAllowThreads(__tstate);
43952 if (PyErr_Occurred()) SWIG_fail;
43953 }
43954 {
43955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43956 }
43957 return resultobj;
43958 fail:
43959 return NULL;
43960 }
43961
43962
43963 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43964 PyObject *resultobj;
43965 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43966 wxSizer *arg2 = (wxSizer *) 0 ;
43967 wxGBPosition *arg3 = 0 ;
43968 bool result;
43969 wxGBPosition temp3 ;
43970 PyObject * obj0 = 0 ;
43971 PyObject * obj1 = 0 ;
43972 PyObject * obj2 = 0 ;
43973
43974 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43976 if (SWIG_arg_fail(1)) SWIG_fail;
43977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43978 if (SWIG_arg_fail(2)) SWIG_fail;
43979 {
43980 arg3 = &temp3;
43981 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43982 }
43983 {
43984 PyThreadState* __tstate = wxPyBeginAllowThreads();
43985 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43986
43987 wxPyEndAllowThreads(__tstate);
43988 if (PyErr_Occurred()) SWIG_fail;
43989 }
43990 {
43991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43992 }
43993 return resultobj;
43994 fail:
43995 return NULL;
43996 }
43997
43998
43999 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44000 PyObject *resultobj;
44001 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44002 size_t arg2 ;
44003 wxGBPosition *arg3 = 0 ;
44004 bool result;
44005 wxGBPosition temp3 ;
44006 PyObject * obj0 = 0 ;
44007 PyObject * obj1 = 0 ;
44008 PyObject * obj2 = 0 ;
44009
44010 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44012 if (SWIG_arg_fail(1)) SWIG_fail;
44013 {
44014 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44015 if (SWIG_arg_fail(2)) SWIG_fail;
44016 }
44017 {
44018 arg3 = &temp3;
44019 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44020 }
44021 {
44022 PyThreadState* __tstate = wxPyBeginAllowThreads();
44023 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44024
44025 wxPyEndAllowThreads(__tstate);
44026 if (PyErr_Occurred()) SWIG_fail;
44027 }
44028 {
44029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44030 }
44031 return resultobj;
44032 fail:
44033 return NULL;
44034 }
44035
44036
44037 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44038 int argc;
44039 PyObject *argv[4];
44040 int ii;
44041
44042 argc = PyObject_Length(args);
44043 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44044 argv[ii] = PyTuple_GetItem(args,ii);
44045 }
44046 if (argc == 3) {
44047 int _v;
44048 {
44049 void *ptr;
44050 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44051 _v = 0;
44052 PyErr_Clear();
44053 } else {
44054 _v = 1;
44055 }
44056 }
44057 if (_v) {
44058 {
44059 void *ptr;
44060 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44061 _v = 0;
44062 PyErr_Clear();
44063 } else {
44064 _v = 1;
44065 }
44066 }
44067 if (_v) {
44068 {
44069 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44070 }
44071 if (_v) {
44072 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44073 }
44074 }
44075 }
44076 }
44077 if (argc == 3) {
44078 int _v;
44079 {
44080 void *ptr;
44081 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44082 _v = 0;
44083 PyErr_Clear();
44084 } else {
44085 _v = 1;
44086 }
44087 }
44088 if (_v) {
44089 {
44090 void *ptr;
44091 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44092 _v = 0;
44093 PyErr_Clear();
44094 } else {
44095 _v = 1;
44096 }
44097 }
44098 if (_v) {
44099 {
44100 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44101 }
44102 if (_v) {
44103 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44104 }
44105 }
44106 }
44107 }
44108 if (argc == 3) {
44109 int _v;
44110 {
44111 void *ptr;
44112 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44113 _v = 0;
44114 PyErr_Clear();
44115 } else {
44116 _v = 1;
44117 }
44118 }
44119 if (_v) {
44120 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44121 if (_v) {
44122 {
44123 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44124 }
44125 if (_v) {
44126 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44127 }
44128 }
44129 }
44130 }
44131
44132 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44133 return NULL;
44134 }
44135
44136
44137 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44138 PyObject *resultobj;
44139 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44140 wxWindow *arg2 = (wxWindow *) 0 ;
44141 wxGBSpan result;
44142 PyObject * obj0 = 0 ;
44143 PyObject * obj1 = 0 ;
44144
44145 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44147 if (SWIG_arg_fail(1)) SWIG_fail;
44148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44149 if (SWIG_arg_fail(2)) SWIG_fail;
44150 {
44151 PyThreadState* __tstate = wxPyBeginAllowThreads();
44152 result = (arg1)->GetItemSpan(arg2);
44153
44154 wxPyEndAllowThreads(__tstate);
44155 if (PyErr_Occurred()) SWIG_fail;
44156 }
44157 {
44158 wxGBSpan * resultptr;
44159 resultptr = new wxGBSpan((wxGBSpan &)(result));
44160 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44161 }
44162 return resultobj;
44163 fail:
44164 return NULL;
44165 }
44166
44167
44168 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44169 PyObject *resultobj;
44170 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44171 wxSizer *arg2 = (wxSizer *) 0 ;
44172 wxGBSpan result;
44173 PyObject * obj0 = 0 ;
44174 PyObject * obj1 = 0 ;
44175
44176 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44178 if (SWIG_arg_fail(1)) SWIG_fail;
44179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44180 if (SWIG_arg_fail(2)) SWIG_fail;
44181 {
44182 PyThreadState* __tstate = wxPyBeginAllowThreads();
44183 result = (arg1)->GetItemSpan(arg2);
44184
44185 wxPyEndAllowThreads(__tstate);
44186 if (PyErr_Occurred()) SWIG_fail;
44187 }
44188 {
44189 wxGBSpan * resultptr;
44190 resultptr = new wxGBSpan((wxGBSpan &)(result));
44191 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44192 }
44193 return resultobj;
44194 fail:
44195 return NULL;
44196 }
44197
44198
44199 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44200 PyObject *resultobj;
44201 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44202 size_t arg2 ;
44203 wxGBSpan result;
44204 PyObject * obj0 = 0 ;
44205 PyObject * obj1 = 0 ;
44206
44207 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44209 if (SWIG_arg_fail(1)) SWIG_fail;
44210 {
44211 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44212 if (SWIG_arg_fail(2)) SWIG_fail;
44213 }
44214 {
44215 PyThreadState* __tstate = wxPyBeginAllowThreads();
44216 result = (arg1)->GetItemSpan(arg2);
44217
44218 wxPyEndAllowThreads(__tstate);
44219 if (PyErr_Occurred()) SWIG_fail;
44220 }
44221 {
44222 wxGBSpan * resultptr;
44223 resultptr = new wxGBSpan((wxGBSpan &)(result));
44224 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44225 }
44226 return resultobj;
44227 fail:
44228 return NULL;
44229 }
44230
44231
44232 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44233 int argc;
44234 PyObject *argv[3];
44235 int ii;
44236
44237 argc = PyObject_Length(args);
44238 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44239 argv[ii] = PyTuple_GetItem(args,ii);
44240 }
44241 if (argc == 2) {
44242 int _v;
44243 {
44244 void *ptr;
44245 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44246 _v = 0;
44247 PyErr_Clear();
44248 } else {
44249 _v = 1;
44250 }
44251 }
44252 if (_v) {
44253 {
44254 void *ptr;
44255 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44256 _v = 0;
44257 PyErr_Clear();
44258 } else {
44259 _v = 1;
44260 }
44261 }
44262 if (_v) {
44263 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44264 }
44265 }
44266 }
44267 if (argc == 2) {
44268 int _v;
44269 {
44270 void *ptr;
44271 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44272 _v = 0;
44273 PyErr_Clear();
44274 } else {
44275 _v = 1;
44276 }
44277 }
44278 if (_v) {
44279 {
44280 void *ptr;
44281 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44282 _v = 0;
44283 PyErr_Clear();
44284 } else {
44285 _v = 1;
44286 }
44287 }
44288 if (_v) {
44289 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44290 }
44291 }
44292 }
44293 if (argc == 2) {
44294 int _v;
44295 {
44296 void *ptr;
44297 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44298 _v = 0;
44299 PyErr_Clear();
44300 } else {
44301 _v = 1;
44302 }
44303 }
44304 if (_v) {
44305 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44306 if (_v) {
44307 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44308 }
44309 }
44310 }
44311
44312 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44313 return NULL;
44314 }
44315
44316
44317 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44318 PyObject *resultobj;
44319 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44320 wxWindow *arg2 = (wxWindow *) 0 ;
44321 wxGBSpan *arg3 = 0 ;
44322 bool result;
44323 wxGBSpan temp3 ;
44324 PyObject * obj0 = 0 ;
44325 PyObject * obj1 = 0 ;
44326 PyObject * obj2 = 0 ;
44327
44328 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44330 if (SWIG_arg_fail(1)) SWIG_fail;
44331 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44332 if (SWIG_arg_fail(2)) SWIG_fail;
44333 {
44334 arg3 = &temp3;
44335 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44336 }
44337 {
44338 PyThreadState* __tstate = wxPyBeginAllowThreads();
44339 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44340
44341 wxPyEndAllowThreads(__tstate);
44342 if (PyErr_Occurred()) SWIG_fail;
44343 }
44344 {
44345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44346 }
44347 return resultobj;
44348 fail:
44349 return NULL;
44350 }
44351
44352
44353 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44354 PyObject *resultobj;
44355 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44356 wxSizer *arg2 = (wxSizer *) 0 ;
44357 wxGBSpan *arg3 = 0 ;
44358 bool result;
44359 wxGBSpan temp3 ;
44360 PyObject * obj0 = 0 ;
44361 PyObject * obj1 = 0 ;
44362 PyObject * obj2 = 0 ;
44363
44364 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44366 if (SWIG_arg_fail(1)) SWIG_fail;
44367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44368 if (SWIG_arg_fail(2)) SWIG_fail;
44369 {
44370 arg3 = &temp3;
44371 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44372 }
44373 {
44374 PyThreadState* __tstate = wxPyBeginAllowThreads();
44375 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44376
44377 wxPyEndAllowThreads(__tstate);
44378 if (PyErr_Occurred()) SWIG_fail;
44379 }
44380 {
44381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44382 }
44383 return resultobj;
44384 fail:
44385 return NULL;
44386 }
44387
44388
44389 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44390 PyObject *resultobj;
44391 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44392 size_t arg2 ;
44393 wxGBSpan *arg3 = 0 ;
44394 bool result;
44395 wxGBSpan temp3 ;
44396 PyObject * obj0 = 0 ;
44397 PyObject * obj1 = 0 ;
44398 PyObject * obj2 = 0 ;
44399
44400 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44402 if (SWIG_arg_fail(1)) SWIG_fail;
44403 {
44404 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44405 if (SWIG_arg_fail(2)) SWIG_fail;
44406 }
44407 {
44408 arg3 = &temp3;
44409 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44410 }
44411 {
44412 PyThreadState* __tstate = wxPyBeginAllowThreads();
44413 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44414
44415 wxPyEndAllowThreads(__tstate);
44416 if (PyErr_Occurred()) SWIG_fail;
44417 }
44418 {
44419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44420 }
44421 return resultobj;
44422 fail:
44423 return NULL;
44424 }
44425
44426
44427 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44428 int argc;
44429 PyObject *argv[4];
44430 int ii;
44431
44432 argc = PyObject_Length(args);
44433 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44434 argv[ii] = PyTuple_GetItem(args,ii);
44435 }
44436 if (argc == 3) {
44437 int _v;
44438 {
44439 void *ptr;
44440 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44441 _v = 0;
44442 PyErr_Clear();
44443 } else {
44444 _v = 1;
44445 }
44446 }
44447 if (_v) {
44448 {
44449 void *ptr;
44450 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44451 _v = 0;
44452 PyErr_Clear();
44453 } else {
44454 _v = 1;
44455 }
44456 }
44457 if (_v) {
44458 {
44459 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44460 }
44461 if (_v) {
44462 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44463 }
44464 }
44465 }
44466 }
44467 if (argc == 3) {
44468 int _v;
44469 {
44470 void *ptr;
44471 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44472 _v = 0;
44473 PyErr_Clear();
44474 } else {
44475 _v = 1;
44476 }
44477 }
44478 if (_v) {
44479 {
44480 void *ptr;
44481 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44482 _v = 0;
44483 PyErr_Clear();
44484 } else {
44485 _v = 1;
44486 }
44487 }
44488 if (_v) {
44489 {
44490 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44491 }
44492 if (_v) {
44493 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44494 }
44495 }
44496 }
44497 }
44498 if (argc == 3) {
44499 int _v;
44500 {
44501 void *ptr;
44502 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44503 _v = 0;
44504 PyErr_Clear();
44505 } else {
44506 _v = 1;
44507 }
44508 }
44509 if (_v) {
44510 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44511 if (_v) {
44512 {
44513 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44514 }
44515 if (_v) {
44516 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44517 }
44518 }
44519 }
44520 }
44521
44522 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44523 return NULL;
44524 }
44525
44526
44527 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44528 PyObject *resultobj;
44529 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44530 wxWindow *arg2 = (wxWindow *) 0 ;
44531 wxGBSizerItem *result;
44532 PyObject * obj0 = 0 ;
44533 PyObject * obj1 = 0 ;
44534
44535 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44537 if (SWIG_arg_fail(1)) SWIG_fail;
44538 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44539 if (SWIG_arg_fail(2)) SWIG_fail;
44540 {
44541 PyThreadState* __tstate = wxPyBeginAllowThreads();
44542 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44543
44544 wxPyEndAllowThreads(__tstate);
44545 if (PyErr_Occurred()) SWIG_fail;
44546 }
44547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44548 return resultobj;
44549 fail:
44550 return NULL;
44551 }
44552
44553
44554 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44555 PyObject *resultobj;
44556 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44557 wxSizer *arg2 = (wxSizer *) 0 ;
44558 wxGBSizerItem *result;
44559 PyObject * obj0 = 0 ;
44560 PyObject * obj1 = 0 ;
44561
44562 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44564 if (SWIG_arg_fail(1)) SWIG_fail;
44565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44566 if (SWIG_arg_fail(2)) SWIG_fail;
44567 {
44568 PyThreadState* __tstate = wxPyBeginAllowThreads();
44569 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44570
44571 wxPyEndAllowThreads(__tstate);
44572 if (PyErr_Occurred()) SWIG_fail;
44573 }
44574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44575 return resultobj;
44576 fail:
44577 return NULL;
44578 }
44579
44580
44581 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44582 int argc;
44583 PyObject *argv[3];
44584 int ii;
44585
44586 argc = PyObject_Length(args);
44587 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44588 argv[ii] = PyTuple_GetItem(args,ii);
44589 }
44590 if (argc == 2) {
44591 int _v;
44592 {
44593 void *ptr;
44594 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44595 _v = 0;
44596 PyErr_Clear();
44597 } else {
44598 _v = 1;
44599 }
44600 }
44601 if (_v) {
44602 {
44603 void *ptr;
44604 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44605 _v = 0;
44606 PyErr_Clear();
44607 } else {
44608 _v = 1;
44609 }
44610 }
44611 if (_v) {
44612 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44613 }
44614 }
44615 }
44616 if (argc == 2) {
44617 int _v;
44618 {
44619 void *ptr;
44620 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44621 _v = 0;
44622 PyErr_Clear();
44623 } else {
44624 _v = 1;
44625 }
44626 }
44627 if (_v) {
44628 {
44629 void *ptr;
44630 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44631 _v = 0;
44632 PyErr_Clear();
44633 } else {
44634 _v = 1;
44635 }
44636 }
44637 if (_v) {
44638 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44639 }
44640 }
44641 }
44642
44643 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44644 return NULL;
44645 }
44646
44647
44648 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44649 PyObject *resultobj;
44650 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44651 wxGBPosition *arg2 = 0 ;
44652 wxGBSizerItem *result;
44653 wxGBPosition temp2 ;
44654 PyObject * obj0 = 0 ;
44655 PyObject * obj1 = 0 ;
44656 char *kwnames[] = {
44657 (char *) "self",(char *) "pos", NULL
44658 };
44659
44660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44662 if (SWIG_arg_fail(1)) SWIG_fail;
44663 {
44664 arg2 = &temp2;
44665 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44666 }
44667 {
44668 PyThreadState* __tstate = wxPyBeginAllowThreads();
44669 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44670
44671 wxPyEndAllowThreads(__tstate);
44672 if (PyErr_Occurred()) SWIG_fail;
44673 }
44674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44675 return resultobj;
44676 fail:
44677 return NULL;
44678 }
44679
44680
44681 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44682 PyObject *resultobj;
44683 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44684 wxPoint *arg2 = 0 ;
44685 wxGBSizerItem *result;
44686 wxPoint temp2 ;
44687 PyObject * obj0 = 0 ;
44688 PyObject * obj1 = 0 ;
44689 char *kwnames[] = {
44690 (char *) "self",(char *) "pt", NULL
44691 };
44692
44693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44695 if (SWIG_arg_fail(1)) SWIG_fail;
44696 {
44697 arg2 = &temp2;
44698 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44699 }
44700 {
44701 PyThreadState* __tstate = wxPyBeginAllowThreads();
44702 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44703
44704 wxPyEndAllowThreads(__tstate);
44705 if (PyErr_Occurred()) SWIG_fail;
44706 }
44707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44708 return resultobj;
44709 fail:
44710 return NULL;
44711 }
44712
44713
44714 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44715 PyObject *resultobj;
44716 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44717 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44718 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44719 bool result;
44720 PyObject * obj0 = 0 ;
44721 PyObject * obj1 = 0 ;
44722 PyObject * obj2 = 0 ;
44723 char *kwnames[] = {
44724 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44725 };
44726
44727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44729 if (SWIG_arg_fail(1)) SWIG_fail;
44730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44731 if (SWIG_arg_fail(2)) SWIG_fail;
44732 if (obj2) {
44733 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44734 if (SWIG_arg_fail(3)) SWIG_fail;
44735 }
44736 {
44737 PyThreadState* __tstate = wxPyBeginAllowThreads();
44738 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44739
44740 wxPyEndAllowThreads(__tstate);
44741 if (PyErr_Occurred()) SWIG_fail;
44742 }
44743 {
44744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44745 }
44746 return resultobj;
44747 fail:
44748 return NULL;
44749 }
44750
44751
44752 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44753 PyObject *resultobj;
44754 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44755 wxGBPosition *arg2 = 0 ;
44756 wxGBSpan *arg3 = 0 ;
44757 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44758 bool result;
44759 wxGBPosition temp2 ;
44760 wxGBSpan temp3 ;
44761 PyObject * obj0 = 0 ;
44762 PyObject * obj1 = 0 ;
44763 PyObject * obj2 = 0 ;
44764 PyObject * obj3 = 0 ;
44765 char *kwnames[] = {
44766 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44767 };
44768
44769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44771 if (SWIG_arg_fail(1)) SWIG_fail;
44772 {
44773 arg2 = &temp2;
44774 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44775 }
44776 {
44777 arg3 = &temp3;
44778 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44779 }
44780 if (obj3) {
44781 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44782 if (SWIG_arg_fail(4)) SWIG_fail;
44783 }
44784 {
44785 PyThreadState* __tstate = wxPyBeginAllowThreads();
44786 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44787
44788 wxPyEndAllowThreads(__tstate);
44789 if (PyErr_Occurred()) SWIG_fail;
44790 }
44791 {
44792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44793 }
44794 return resultobj;
44795 fail:
44796 return NULL;
44797 }
44798
44799
44800 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44801 PyObject *obj;
44802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44803 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44804 Py_INCREF(obj);
44805 return Py_BuildValue((char *)"");
44806 }
44807 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44808 PyObject *resultobj;
44809 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44810 wxRelationship arg2 ;
44811 wxWindow *arg3 = (wxWindow *) 0 ;
44812 wxEdge arg4 ;
44813 int arg5 = (int) 0 ;
44814 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44815 PyObject * obj0 = 0 ;
44816 PyObject * obj1 = 0 ;
44817 PyObject * obj2 = 0 ;
44818 PyObject * obj3 = 0 ;
44819 PyObject * obj4 = 0 ;
44820 PyObject * obj5 = 0 ;
44821 char *kwnames[] = {
44822 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44823 };
44824
44825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44827 if (SWIG_arg_fail(1)) SWIG_fail;
44828 {
44829 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44830 if (SWIG_arg_fail(2)) SWIG_fail;
44831 }
44832 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44833 if (SWIG_arg_fail(3)) SWIG_fail;
44834 {
44835 arg4 = (wxEdge)(SWIG_As_int(obj3));
44836 if (SWIG_arg_fail(4)) SWIG_fail;
44837 }
44838 if (obj4) {
44839 {
44840 arg5 = (int)(SWIG_As_int(obj4));
44841 if (SWIG_arg_fail(5)) SWIG_fail;
44842 }
44843 }
44844 if (obj5) {
44845 {
44846 arg6 = (int)(SWIG_As_int(obj5));
44847 if (SWIG_arg_fail(6)) SWIG_fail;
44848 }
44849 }
44850 {
44851 PyThreadState* __tstate = wxPyBeginAllowThreads();
44852 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44853
44854 wxPyEndAllowThreads(__tstate);
44855 if (PyErr_Occurred()) SWIG_fail;
44856 }
44857 Py_INCREF(Py_None); resultobj = Py_None;
44858 return resultobj;
44859 fail:
44860 return NULL;
44861 }
44862
44863
44864 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44865 PyObject *resultobj;
44866 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44867 wxWindow *arg2 = (wxWindow *) 0 ;
44868 int arg3 = (int) 0 ;
44869 PyObject * obj0 = 0 ;
44870 PyObject * obj1 = 0 ;
44871 PyObject * obj2 = 0 ;
44872 char *kwnames[] = {
44873 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44874 };
44875
44876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44878 if (SWIG_arg_fail(1)) SWIG_fail;
44879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44880 if (SWIG_arg_fail(2)) SWIG_fail;
44881 if (obj2) {
44882 {
44883 arg3 = (int)(SWIG_As_int(obj2));
44884 if (SWIG_arg_fail(3)) SWIG_fail;
44885 }
44886 }
44887 {
44888 PyThreadState* __tstate = wxPyBeginAllowThreads();
44889 (arg1)->LeftOf(arg2,arg3);
44890
44891 wxPyEndAllowThreads(__tstate);
44892 if (PyErr_Occurred()) SWIG_fail;
44893 }
44894 Py_INCREF(Py_None); resultobj = Py_None;
44895 return resultobj;
44896 fail:
44897 return NULL;
44898 }
44899
44900
44901 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44902 PyObject *resultobj;
44903 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44904 wxWindow *arg2 = (wxWindow *) 0 ;
44905 int arg3 = (int) 0 ;
44906 PyObject * obj0 = 0 ;
44907 PyObject * obj1 = 0 ;
44908 PyObject * obj2 = 0 ;
44909 char *kwnames[] = {
44910 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44911 };
44912
44913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44915 if (SWIG_arg_fail(1)) SWIG_fail;
44916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44917 if (SWIG_arg_fail(2)) SWIG_fail;
44918 if (obj2) {
44919 {
44920 arg3 = (int)(SWIG_As_int(obj2));
44921 if (SWIG_arg_fail(3)) SWIG_fail;
44922 }
44923 }
44924 {
44925 PyThreadState* __tstate = wxPyBeginAllowThreads();
44926 (arg1)->RightOf(arg2,arg3);
44927
44928 wxPyEndAllowThreads(__tstate);
44929 if (PyErr_Occurred()) SWIG_fail;
44930 }
44931 Py_INCREF(Py_None); resultobj = Py_None;
44932 return resultobj;
44933 fail:
44934 return NULL;
44935 }
44936
44937
44938 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44939 PyObject *resultobj;
44940 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44941 wxWindow *arg2 = (wxWindow *) 0 ;
44942 int arg3 = (int) 0 ;
44943 PyObject * obj0 = 0 ;
44944 PyObject * obj1 = 0 ;
44945 PyObject * obj2 = 0 ;
44946 char *kwnames[] = {
44947 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44948 };
44949
44950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44952 if (SWIG_arg_fail(1)) SWIG_fail;
44953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44954 if (SWIG_arg_fail(2)) SWIG_fail;
44955 if (obj2) {
44956 {
44957 arg3 = (int)(SWIG_As_int(obj2));
44958 if (SWIG_arg_fail(3)) SWIG_fail;
44959 }
44960 }
44961 {
44962 PyThreadState* __tstate = wxPyBeginAllowThreads();
44963 (arg1)->Above(arg2,arg3);
44964
44965 wxPyEndAllowThreads(__tstate);
44966 if (PyErr_Occurred()) SWIG_fail;
44967 }
44968 Py_INCREF(Py_None); resultobj = Py_None;
44969 return resultobj;
44970 fail:
44971 return NULL;
44972 }
44973
44974
44975 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44976 PyObject *resultobj;
44977 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44978 wxWindow *arg2 = (wxWindow *) 0 ;
44979 int arg3 = (int) 0 ;
44980 PyObject * obj0 = 0 ;
44981 PyObject * obj1 = 0 ;
44982 PyObject * obj2 = 0 ;
44983 char *kwnames[] = {
44984 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44985 };
44986
44987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44989 if (SWIG_arg_fail(1)) SWIG_fail;
44990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44991 if (SWIG_arg_fail(2)) SWIG_fail;
44992 if (obj2) {
44993 {
44994 arg3 = (int)(SWIG_As_int(obj2));
44995 if (SWIG_arg_fail(3)) SWIG_fail;
44996 }
44997 }
44998 {
44999 PyThreadState* __tstate = wxPyBeginAllowThreads();
45000 (arg1)->Below(arg2,arg3);
45001
45002 wxPyEndAllowThreads(__tstate);
45003 if (PyErr_Occurred()) SWIG_fail;
45004 }
45005 Py_INCREF(Py_None); resultobj = Py_None;
45006 return resultobj;
45007 fail:
45008 return NULL;
45009 }
45010
45011
45012 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45013 PyObject *resultobj;
45014 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45015 wxWindow *arg2 = (wxWindow *) 0 ;
45016 wxEdge arg3 ;
45017 int arg4 = (int) 0 ;
45018 PyObject * obj0 = 0 ;
45019 PyObject * obj1 = 0 ;
45020 PyObject * obj2 = 0 ;
45021 PyObject * obj3 = 0 ;
45022 char *kwnames[] = {
45023 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45024 };
45025
45026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45028 if (SWIG_arg_fail(1)) SWIG_fail;
45029 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45030 if (SWIG_arg_fail(2)) SWIG_fail;
45031 {
45032 arg3 = (wxEdge)(SWIG_As_int(obj2));
45033 if (SWIG_arg_fail(3)) SWIG_fail;
45034 }
45035 if (obj3) {
45036 {
45037 arg4 = (int)(SWIG_As_int(obj3));
45038 if (SWIG_arg_fail(4)) SWIG_fail;
45039 }
45040 }
45041 {
45042 PyThreadState* __tstate = wxPyBeginAllowThreads();
45043 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
45044
45045 wxPyEndAllowThreads(__tstate);
45046 if (PyErr_Occurred()) SWIG_fail;
45047 }
45048 Py_INCREF(Py_None); resultobj = Py_None;
45049 return resultobj;
45050 fail:
45051 return NULL;
45052 }
45053
45054
45055 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45056 PyObject *resultobj;
45057 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45058 wxWindow *arg2 = (wxWindow *) 0 ;
45059 wxEdge arg3 ;
45060 int arg4 ;
45061 PyObject * obj0 = 0 ;
45062 PyObject * obj1 = 0 ;
45063 PyObject * obj2 = 0 ;
45064 PyObject * obj3 = 0 ;
45065 char *kwnames[] = {
45066 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45067 };
45068
45069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45071 if (SWIG_arg_fail(1)) SWIG_fail;
45072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45073 if (SWIG_arg_fail(2)) SWIG_fail;
45074 {
45075 arg3 = (wxEdge)(SWIG_As_int(obj2));
45076 if (SWIG_arg_fail(3)) SWIG_fail;
45077 }
45078 {
45079 arg4 = (int)(SWIG_As_int(obj3));
45080 if (SWIG_arg_fail(4)) SWIG_fail;
45081 }
45082 {
45083 PyThreadState* __tstate = wxPyBeginAllowThreads();
45084 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
45085
45086 wxPyEndAllowThreads(__tstate);
45087 if (PyErr_Occurred()) SWIG_fail;
45088 }
45089 Py_INCREF(Py_None); resultobj = Py_None;
45090 return resultobj;
45091 fail:
45092 return NULL;
45093 }
45094
45095
45096 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45097 PyObject *resultobj;
45098 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45099 int arg2 ;
45100 PyObject * obj0 = 0 ;
45101 PyObject * obj1 = 0 ;
45102 char *kwnames[] = {
45103 (char *) "self",(char *) "val", NULL
45104 };
45105
45106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45108 if (SWIG_arg_fail(1)) SWIG_fail;
45109 {
45110 arg2 = (int)(SWIG_As_int(obj1));
45111 if (SWIG_arg_fail(2)) SWIG_fail;
45112 }
45113 {
45114 PyThreadState* __tstate = wxPyBeginAllowThreads();
45115 (arg1)->Absolute(arg2);
45116
45117 wxPyEndAllowThreads(__tstate);
45118 if (PyErr_Occurred()) SWIG_fail;
45119 }
45120 Py_INCREF(Py_None); resultobj = Py_None;
45121 return resultobj;
45122 fail:
45123 return NULL;
45124 }
45125
45126
45127 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45128 PyObject *resultobj;
45129 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45130 PyObject * obj0 = 0 ;
45131 char *kwnames[] = {
45132 (char *) "self", NULL
45133 };
45134
45135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45137 if (SWIG_arg_fail(1)) SWIG_fail;
45138 {
45139 PyThreadState* __tstate = wxPyBeginAllowThreads();
45140 (arg1)->Unconstrained();
45141
45142 wxPyEndAllowThreads(__tstate);
45143 if (PyErr_Occurred()) SWIG_fail;
45144 }
45145 Py_INCREF(Py_None); resultobj = Py_None;
45146 return resultobj;
45147 fail:
45148 return NULL;
45149 }
45150
45151
45152 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45153 PyObject *resultobj;
45154 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45155 PyObject * obj0 = 0 ;
45156 char *kwnames[] = {
45157 (char *) "self", NULL
45158 };
45159
45160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45162 if (SWIG_arg_fail(1)) SWIG_fail;
45163 {
45164 PyThreadState* __tstate = wxPyBeginAllowThreads();
45165 (arg1)->AsIs();
45166
45167 wxPyEndAllowThreads(__tstate);
45168 if (PyErr_Occurred()) SWIG_fail;
45169 }
45170 Py_INCREF(Py_None); resultobj = Py_None;
45171 return resultobj;
45172 fail:
45173 return NULL;
45174 }
45175
45176
45177 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45178 PyObject *resultobj;
45179 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45180 wxWindow *result;
45181 PyObject * obj0 = 0 ;
45182 char *kwnames[] = {
45183 (char *) "self", NULL
45184 };
45185
45186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45188 if (SWIG_arg_fail(1)) SWIG_fail;
45189 {
45190 PyThreadState* __tstate = wxPyBeginAllowThreads();
45191 result = (wxWindow *)(arg1)->GetOtherWindow();
45192
45193 wxPyEndAllowThreads(__tstate);
45194 if (PyErr_Occurred()) SWIG_fail;
45195 }
45196 {
45197 resultobj = wxPyMake_wxObject(result, 0);
45198 }
45199 return resultobj;
45200 fail:
45201 return NULL;
45202 }
45203
45204
45205 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45206 PyObject *resultobj;
45207 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45208 wxEdge result;
45209 PyObject * obj0 = 0 ;
45210 char *kwnames[] = {
45211 (char *) "self", NULL
45212 };
45213
45214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45216 if (SWIG_arg_fail(1)) SWIG_fail;
45217 {
45218 PyThreadState* __tstate = wxPyBeginAllowThreads();
45219 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45220
45221 wxPyEndAllowThreads(__tstate);
45222 if (PyErr_Occurred()) SWIG_fail;
45223 }
45224 resultobj = SWIG_From_int((result));
45225 return resultobj;
45226 fail:
45227 return NULL;
45228 }
45229
45230
45231 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45232 PyObject *resultobj;
45233 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45234 wxEdge arg2 ;
45235 PyObject * obj0 = 0 ;
45236 PyObject * obj1 = 0 ;
45237 char *kwnames[] = {
45238 (char *) "self",(char *) "which", NULL
45239 };
45240
45241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45243 if (SWIG_arg_fail(1)) SWIG_fail;
45244 {
45245 arg2 = (wxEdge)(SWIG_As_int(obj1));
45246 if (SWIG_arg_fail(2)) SWIG_fail;
45247 }
45248 {
45249 PyThreadState* __tstate = wxPyBeginAllowThreads();
45250 (arg1)->SetEdge((wxEdge )arg2);
45251
45252 wxPyEndAllowThreads(__tstate);
45253 if (PyErr_Occurred()) SWIG_fail;
45254 }
45255 Py_INCREF(Py_None); resultobj = Py_None;
45256 return resultobj;
45257 fail:
45258 return NULL;
45259 }
45260
45261
45262 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45263 PyObject *resultobj;
45264 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45265 int arg2 ;
45266 PyObject * obj0 = 0 ;
45267 PyObject * obj1 = 0 ;
45268 char *kwnames[] = {
45269 (char *) "self",(char *) "v", NULL
45270 };
45271
45272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45274 if (SWIG_arg_fail(1)) SWIG_fail;
45275 {
45276 arg2 = (int)(SWIG_As_int(obj1));
45277 if (SWIG_arg_fail(2)) SWIG_fail;
45278 }
45279 {
45280 PyThreadState* __tstate = wxPyBeginAllowThreads();
45281 (arg1)->SetValue(arg2);
45282
45283 wxPyEndAllowThreads(__tstate);
45284 if (PyErr_Occurred()) SWIG_fail;
45285 }
45286 Py_INCREF(Py_None); resultobj = Py_None;
45287 return resultobj;
45288 fail:
45289 return NULL;
45290 }
45291
45292
45293 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45294 PyObject *resultobj;
45295 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45296 int result;
45297 PyObject * obj0 = 0 ;
45298 char *kwnames[] = {
45299 (char *) "self", NULL
45300 };
45301
45302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45304 if (SWIG_arg_fail(1)) SWIG_fail;
45305 {
45306 PyThreadState* __tstate = wxPyBeginAllowThreads();
45307 result = (int)(arg1)->GetMargin();
45308
45309 wxPyEndAllowThreads(__tstate);
45310 if (PyErr_Occurred()) SWIG_fail;
45311 }
45312 {
45313 resultobj = SWIG_From_int((int)(result));
45314 }
45315 return resultobj;
45316 fail:
45317 return NULL;
45318 }
45319
45320
45321 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45322 PyObject *resultobj;
45323 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45324 int arg2 ;
45325 PyObject * obj0 = 0 ;
45326 PyObject * obj1 = 0 ;
45327 char *kwnames[] = {
45328 (char *) "self",(char *) "m", NULL
45329 };
45330
45331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45333 if (SWIG_arg_fail(1)) SWIG_fail;
45334 {
45335 arg2 = (int)(SWIG_As_int(obj1));
45336 if (SWIG_arg_fail(2)) SWIG_fail;
45337 }
45338 {
45339 PyThreadState* __tstate = wxPyBeginAllowThreads();
45340 (arg1)->SetMargin(arg2);
45341
45342 wxPyEndAllowThreads(__tstate);
45343 if (PyErr_Occurred()) SWIG_fail;
45344 }
45345 Py_INCREF(Py_None); resultobj = Py_None;
45346 return resultobj;
45347 fail:
45348 return NULL;
45349 }
45350
45351
45352 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45353 PyObject *resultobj;
45354 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45355 int result;
45356 PyObject * obj0 = 0 ;
45357 char *kwnames[] = {
45358 (char *) "self", NULL
45359 };
45360
45361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45363 if (SWIG_arg_fail(1)) SWIG_fail;
45364 {
45365 PyThreadState* __tstate = wxPyBeginAllowThreads();
45366 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45367
45368 wxPyEndAllowThreads(__tstate);
45369 if (PyErr_Occurred()) SWIG_fail;
45370 }
45371 {
45372 resultobj = SWIG_From_int((int)(result));
45373 }
45374 return resultobj;
45375 fail:
45376 return NULL;
45377 }
45378
45379
45380 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45381 PyObject *resultobj;
45382 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45383 int result;
45384 PyObject * obj0 = 0 ;
45385 char *kwnames[] = {
45386 (char *) "self", NULL
45387 };
45388
45389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45391 if (SWIG_arg_fail(1)) SWIG_fail;
45392 {
45393 PyThreadState* __tstate = wxPyBeginAllowThreads();
45394 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45395
45396 wxPyEndAllowThreads(__tstate);
45397 if (PyErr_Occurred()) SWIG_fail;
45398 }
45399 {
45400 resultobj = SWIG_From_int((int)(result));
45401 }
45402 return resultobj;
45403 fail:
45404 return NULL;
45405 }
45406
45407
45408 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45409 PyObject *resultobj;
45410 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45411 int result;
45412 PyObject * obj0 = 0 ;
45413 char *kwnames[] = {
45414 (char *) "self", NULL
45415 };
45416
45417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45419 if (SWIG_arg_fail(1)) SWIG_fail;
45420 {
45421 PyThreadState* __tstate = wxPyBeginAllowThreads();
45422 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45423
45424 wxPyEndAllowThreads(__tstate);
45425 if (PyErr_Occurred()) SWIG_fail;
45426 }
45427 {
45428 resultobj = SWIG_From_int((int)(result));
45429 }
45430 return resultobj;
45431 fail:
45432 return NULL;
45433 }
45434
45435
45436 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45437 PyObject *resultobj;
45438 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45439 bool result;
45440 PyObject * obj0 = 0 ;
45441 char *kwnames[] = {
45442 (char *) "self", NULL
45443 };
45444
45445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45447 if (SWIG_arg_fail(1)) SWIG_fail;
45448 {
45449 PyThreadState* __tstate = wxPyBeginAllowThreads();
45450 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45451
45452 wxPyEndAllowThreads(__tstate);
45453 if (PyErr_Occurred()) SWIG_fail;
45454 }
45455 {
45456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45457 }
45458 return resultobj;
45459 fail:
45460 return NULL;
45461 }
45462
45463
45464 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45465 PyObject *resultobj;
45466 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45467 bool arg2 ;
45468 PyObject * obj0 = 0 ;
45469 PyObject * obj1 = 0 ;
45470 char *kwnames[] = {
45471 (char *) "self",(char *) "d", NULL
45472 };
45473
45474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45476 if (SWIG_arg_fail(1)) SWIG_fail;
45477 {
45478 arg2 = (bool)(SWIG_As_bool(obj1));
45479 if (SWIG_arg_fail(2)) SWIG_fail;
45480 }
45481 {
45482 PyThreadState* __tstate = wxPyBeginAllowThreads();
45483 (arg1)->SetDone(arg2);
45484
45485 wxPyEndAllowThreads(__tstate);
45486 if (PyErr_Occurred()) SWIG_fail;
45487 }
45488 Py_INCREF(Py_None); resultobj = Py_None;
45489 return resultobj;
45490 fail:
45491 return NULL;
45492 }
45493
45494
45495 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45496 PyObject *resultobj;
45497 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45498 wxRelationship result;
45499 PyObject * obj0 = 0 ;
45500 char *kwnames[] = {
45501 (char *) "self", NULL
45502 };
45503
45504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45506 if (SWIG_arg_fail(1)) SWIG_fail;
45507 {
45508 PyThreadState* __tstate = wxPyBeginAllowThreads();
45509 result = (wxRelationship)(arg1)->GetRelationship();
45510
45511 wxPyEndAllowThreads(__tstate);
45512 if (PyErr_Occurred()) SWIG_fail;
45513 }
45514 resultobj = SWIG_From_int((result));
45515 return resultobj;
45516 fail:
45517 return NULL;
45518 }
45519
45520
45521 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45522 PyObject *resultobj;
45523 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45524 wxRelationship arg2 ;
45525 PyObject * obj0 = 0 ;
45526 PyObject * obj1 = 0 ;
45527 char *kwnames[] = {
45528 (char *) "self",(char *) "r", NULL
45529 };
45530
45531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45533 if (SWIG_arg_fail(1)) SWIG_fail;
45534 {
45535 arg2 = (wxRelationship)(SWIG_As_int(obj1));
45536 if (SWIG_arg_fail(2)) SWIG_fail;
45537 }
45538 {
45539 PyThreadState* __tstate = wxPyBeginAllowThreads();
45540 (arg1)->SetRelationship((wxRelationship )arg2);
45541
45542 wxPyEndAllowThreads(__tstate);
45543 if (PyErr_Occurred()) SWIG_fail;
45544 }
45545 Py_INCREF(Py_None); resultobj = Py_None;
45546 return resultobj;
45547 fail:
45548 return NULL;
45549 }
45550
45551
45552 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45553 PyObject *resultobj;
45554 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45555 wxWindow *arg2 = (wxWindow *) 0 ;
45556 bool result;
45557 PyObject * obj0 = 0 ;
45558 PyObject * obj1 = 0 ;
45559 char *kwnames[] = {
45560 (char *) "self",(char *) "otherW", NULL
45561 };
45562
45563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45565 if (SWIG_arg_fail(1)) SWIG_fail;
45566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45567 if (SWIG_arg_fail(2)) SWIG_fail;
45568 {
45569 PyThreadState* __tstate = wxPyBeginAllowThreads();
45570 result = (bool)(arg1)->ResetIfWin(arg2);
45571
45572 wxPyEndAllowThreads(__tstate);
45573 if (PyErr_Occurred()) SWIG_fail;
45574 }
45575 {
45576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45577 }
45578 return resultobj;
45579 fail:
45580 return NULL;
45581 }
45582
45583
45584 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45585 PyObject *resultobj;
45586 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45587 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45588 wxWindow *arg3 = (wxWindow *) 0 ;
45589 bool result;
45590 PyObject * obj0 = 0 ;
45591 PyObject * obj1 = 0 ;
45592 PyObject * obj2 = 0 ;
45593 char *kwnames[] = {
45594 (char *) "self",(char *) "constraints",(char *) "win", NULL
45595 };
45596
45597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45599 if (SWIG_arg_fail(1)) SWIG_fail;
45600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45601 if (SWIG_arg_fail(2)) SWIG_fail;
45602 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45603 if (SWIG_arg_fail(3)) SWIG_fail;
45604 {
45605 PyThreadState* __tstate = wxPyBeginAllowThreads();
45606 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45607
45608 wxPyEndAllowThreads(__tstate);
45609 if (PyErr_Occurred()) SWIG_fail;
45610 }
45611 {
45612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45613 }
45614 return resultobj;
45615 fail:
45616 return NULL;
45617 }
45618
45619
45620 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45621 PyObject *resultobj;
45622 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45623 wxEdge arg2 ;
45624 wxWindow *arg3 = (wxWindow *) 0 ;
45625 wxWindow *arg4 = (wxWindow *) 0 ;
45626 int result;
45627 PyObject * obj0 = 0 ;
45628 PyObject * obj1 = 0 ;
45629 PyObject * obj2 = 0 ;
45630 PyObject * obj3 = 0 ;
45631 char *kwnames[] = {
45632 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45633 };
45634
45635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45637 if (SWIG_arg_fail(1)) SWIG_fail;
45638 {
45639 arg2 = (wxEdge)(SWIG_As_int(obj1));
45640 if (SWIG_arg_fail(2)) SWIG_fail;
45641 }
45642 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45643 if (SWIG_arg_fail(3)) SWIG_fail;
45644 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45645 if (SWIG_arg_fail(4)) SWIG_fail;
45646 {
45647 PyThreadState* __tstate = wxPyBeginAllowThreads();
45648 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45649
45650 wxPyEndAllowThreads(__tstate);
45651 if (PyErr_Occurred()) SWIG_fail;
45652 }
45653 {
45654 resultobj = SWIG_From_int((int)(result));
45655 }
45656 return resultobj;
45657 fail:
45658 return NULL;
45659 }
45660
45661
45662 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45663 PyObject *obj;
45664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45665 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45666 Py_INCREF(obj);
45667 return Py_BuildValue((char *)"");
45668 }
45669 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45670 PyObject *resultobj;
45671 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45672 wxIndividualLayoutConstraint *result;
45673 PyObject * obj0 = 0 ;
45674 char *kwnames[] = {
45675 (char *) "self", NULL
45676 };
45677
45678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45680 if (SWIG_arg_fail(1)) SWIG_fail;
45681 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45682
45683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45684 return resultobj;
45685 fail:
45686 return NULL;
45687 }
45688
45689
45690 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45691 PyObject *resultobj;
45692 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45693 wxIndividualLayoutConstraint *result;
45694 PyObject * obj0 = 0 ;
45695 char *kwnames[] = {
45696 (char *) "self", NULL
45697 };
45698
45699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45701 if (SWIG_arg_fail(1)) SWIG_fail;
45702 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45703
45704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45705 return resultobj;
45706 fail:
45707 return NULL;
45708 }
45709
45710
45711 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45712 PyObject *resultobj;
45713 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45714 wxIndividualLayoutConstraint *result;
45715 PyObject * obj0 = 0 ;
45716 char *kwnames[] = {
45717 (char *) "self", NULL
45718 };
45719
45720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45722 if (SWIG_arg_fail(1)) SWIG_fail;
45723 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45724
45725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45726 return resultobj;
45727 fail:
45728 return NULL;
45729 }
45730
45731
45732 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45733 PyObject *resultobj;
45734 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45735 wxIndividualLayoutConstraint *result;
45736 PyObject * obj0 = 0 ;
45737 char *kwnames[] = {
45738 (char *) "self", NULL
45739 };
45740
45741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45743 if (SWIG_arg_fail(1)) SWIG_fail;
45744 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45745
45746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45747 return resultobj;
45748 fail:
45749 return NULL;
45750 }
45751
45752
45753 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45754 PyObject *resultobj;
45755 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45756 wxIndividualLayoutConstraint *result;
45757 PyObject * obj0 = 0 ;
45758 char *kwnames[] = {
45759 (char *) "self", NULL
45760 };
45761
45762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45764 if (SWIG_arg_fail(1)) SWIG_fail;
45765 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45766
45767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45768 return resultobj;
45769 fail:
45770 return NULL;
45771 }
45772
45773
45774 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45775 PyObject *resultobj;
45776 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45777 wxIndividualLayoutConstraint *result;
45778 PyObject * obj0 = 0 ;
45779 char *kwnames[] = {
45780 (char *) "self", NULL
45781 };
45782
45783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45785 if (SWIG_arg_fail(1)) SWIG_fail;
45786 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45787
45788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45789 return resultobj;
45790 fail:
45791 return NULL;
45792 }
45793
45794
45795 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45796 PyObject *resultobj;
45797 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45798 wxIndividualLayoutConstraint *result;
45799 PyObject * obj0 = 0 ;
45800 char *kwnames[] = {
45801 (char *) "self", NULL
45802 };
45803
45804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45806 if (SWIG_arg_fail(1)) SWIG_fail;
45807 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45808
45809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45810 return resultobj;
45811 fail:
45812 return NULL;
45813 }
45814
45815
45816 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45817 PyObject *resultobj;
45818 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45819 wxIndividualLayoutConstraint *result;
45820 PyObject * obj0 = 0 ;
45821 char *kwnames[] = {
45822 (char *) "self", NULL
45823 };
45824
45825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45827 if (SWIG_arg_fail(1)) SWIG_fail;
45828 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45829
45830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45831 return resultobj;
45832 fail:
45833 return NULL;
45834 }
45835
45836
45837 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45838 PyObject *resultobj;
45839 wxLayoutConstraints *result;
45840 char *kwnames[] = {
45841 NULL
45842 };
45843
45844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45845 {
45846 PyThreadState* __tstate = wxPyBeginAllowThreads();
45847 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45848
45849 wxPyEndAllowThreads(__tstate);
45850 if (PyErr_Occurred()) SWIG_fail;
45851 }
45852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45853 return resultobj;
45854 fail:
45855 return NULL;
45856 }
45857
45858
45859 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45860 PyObject *resultobj;
45861 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45862 wxWindow *arg2 = (wxWindow *) 0 ;
45863 int *arg3 = (int *) 0 ;
45864 bool result;
45865 int temp3 ;
45866 int res3 = 0 ;
45867 PyObject * obj0 = 0 ;
45868 PyObject * obj1 = 0 ;
45869 char *kwnames[] = {
45870 (char *) "self",(char *) "win", NULL
45871 };
45872
45873 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45876 if (SWIG_arg_fail(1)) SWIG_fail;
45877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45878 if (SWIG_arg_fail(2)) SWIG_fail;
45879 {
45880 PyThreadState* __tstate = wxPyBeginAllowThreads();
45881 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45882
45883 wxPyEndAllowThreads(__tstate);
45884 if (PyErr_Occurred()) SWIG_fail;
45885 }
45886 {
45887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45888 }
45889 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45890 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45891 return resultobj;
45892 fail:
45893 return NULL;
45894 }
45895
45896
45897 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45898 PyObject *resultobj;
45899 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45900 bool result;
45901 PyObject * obj0 = 0 ;
45902 char *kwnames[] = {
45903 (char *) "self", NULL
45904 };
45905
45906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45908 if (SWIG_arg_fail(1)) SWIG_fail;
45909 {
45910 PyThreadState* __tstate = wxPyBeginAllowThreads();
45911 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45912
45913 wxPyEndAllowThreads(__tstate);
45914 if (PyErr_Occurred()) SWIG_fail;
45915 }
45916 {
45917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45918 }
45919 return resultobj;
45920 fail:
45921 return NULL;
45922 }
45923
45924
45925 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45926 PyObject *obj;
45927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45928 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45929 Py_INCREF(obj);
45930 return Py_BuildValue((char *)"");
45931 }
45932 static PyMethodDef SwigMethods[] = {
45933 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45934 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45935 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45938 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45959 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45972 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45987 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46041 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46069 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46088 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46090 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46098 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46099 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46111 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46123 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46127 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46133 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46143 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46153 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46156 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46163 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46171 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46179 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46262 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46264 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46266 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46268 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46270 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46272 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46274 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46276 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46278 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46280 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46282 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46284 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46286 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46300 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46318 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46321 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46324 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46336 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46341 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46347 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46353 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46416 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46423 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46459 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46469 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46475 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46477 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46479 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46482 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46486 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46489 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46492 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46494 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46499 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46507 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46511 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46514 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46516 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46520 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46537 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46539 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46542 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46544 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46548 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46552 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46563 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46566 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46569 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46573 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46580 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46585 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46590 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46594 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46639 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46659 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46666 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46670 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46680 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46758 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46849 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46851 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46892 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46907 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46910 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46965 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46994 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47038 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47046 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47065 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47066 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47103 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47133 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47136 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47140 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47143 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47153 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47165 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47177 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47187 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47197 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47211 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47218 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47219 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47220 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47221 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47222 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47227 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47254 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47266 { NULL, NULL, 0, NULL }
47267 };
47268
47269
47270 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47271
47272 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47273 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47274 }
47275 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47276 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47277 }
47278 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47279 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47280 }
47281 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47282 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47283 }
47284 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47285 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47286 }
47287 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47288 return (void *)((wxSizer *) ((wxGridSizer *) x));
47289 }
47290 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47291 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47292 }
47293 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47294 return (void *)((wxSizer *) ((wxPySizer *) x));
47295 }
47296 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47297 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47298 }
47299 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47300 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47301 }
47302 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47303 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47304 }
47305 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47306 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47307 }
47308 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47309 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47310 }
47311 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47312 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47313 }
47314 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47315 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47316 }
47317 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47318 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47319 }
47320 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47321 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47322 }
47323 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47324 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47325 }
47326 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47327 return (void *)((wxEvent *) ((wxPyEvent *) x));
47328 }
47329 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47330 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47331 }
47332 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47333 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47334 }
47335 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47336 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47337 }
47338 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47339 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47340 }
47341 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47342 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47343 }
47344 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47345 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47346 }
47347 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47348 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47349 }
47350 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47351 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47352 }
47353 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47354 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47355 }
47356 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47357 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47358 }
47359 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47360 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47361 }
47362 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47363 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47364 }
47365 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47366 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47367 }
47368 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47369 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47370 }
47371 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47372 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47373 }
47374 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47375 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47376 }
47377 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47378 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47379 }
47380 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47381 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47382 }
47383 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47384 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47385 }
47386 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47387 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47388 }
47389 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47390 return (void *)((wxEvent *) ((wxShowEvent *) x));
47391 }
47392 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47393 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47394 }
47395 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47396 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47397 }
47398 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47399 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47400 }
47401 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47402 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47403 }
47404 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47405 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47406 }
47407 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47408 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47409 }
47410 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47411 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47412 }
47413 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47414 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47415 }
47416 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47417 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47418 }
47419 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47420 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47421 }
47422 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47423 return (void *)((wxControl *) ((wxControlWithItems *) x));
47424 }
47425 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47426 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47427 }
47428 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47429 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47430 }
47431 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47432 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47433 }
47434 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47435 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47436 }
47437 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47438 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47439 }
47440 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47441 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47442 }
47443 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47444 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47445 }
47446 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47447 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47448 }
47449 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47450 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47451 }
47452 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47453 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47454 }
47455 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47456 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47457 }
47458 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47459 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47460 }
47461 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47462 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47463 }
47464 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47465 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47466 }
47467 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47468 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47469 }
47470 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47471 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47472 }
47473 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47474 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47475 }
47476 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47477 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47478 }
47479 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47480 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47481 }
47482 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47483 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47484 }
47485 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47486 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47487 }
47488 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47489 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47490 }
47491 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47492 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47493 }
47494 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47495 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47496 }
47497 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47498 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47499 }
47500 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47501 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47502 }
47503 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47504 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47505 }
47506 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47507 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47508 }
47509 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47510 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47511 }
47512 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47513 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47514 }
47515 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47516 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47517 }
47518 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47519 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47520 }
47521 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47522 return (void *)((wxObject *) ((wxSizerItem *) x));
47523 }
47524 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47525 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47526 }
47527 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47528 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47529 }
47530 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47531 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47532 }
47533 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47534 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47535 }
47536 static void *_p_wxSizerTo_p_wxObject(void *x) {
47537 return (void *)((wxObject *) ((wxSizer *) x));
47538 }
47539 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47540 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47541 }
47542 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47543 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47544 }
47545 static void *_p_wxEventTo_p_wxObject(void *x) {
47546 return (void *)((wxObject *) ((wxEvent *) x));
47547 }
47548 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47549 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47550 }
47551 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47552 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47553 }
47554 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47555 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47556 }
47557 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47558 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47559 }
47560 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47561 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47562 }
47563 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47564 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47565 }
47566 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47567 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47568 }
47569 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47570 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47571 }
47572 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47573 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47574 }
47575 static void *_p_wxControlTo_p_wxObject(void *x) {
47576 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47577 }
47578 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47579 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47580 }
47581 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47582 return (void *)((wxObject *) ((wxFSFile *) x));
47583 }
47584 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47585 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47586 }
47587 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47588 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47589 }
47590 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47591 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47592 }
47593 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47594 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47595 }
47596 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47597 return (void *)((wxObject *) ((wxMenuItem *) x));
47598 }
47599 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47600 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47601 }
47602 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47603 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47604 }
47605 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47606 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47607 }
47608 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47609 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47610 }
47611 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47612 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47613 }
47614 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47615 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47616 }
47617 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47618 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47619 }
47620 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47621 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47622 }
47623 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47624 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47625 }
47626 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47627 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47628 }
47629 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47630 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47631 }
47632 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47633 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47634 }
47635 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47636 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47637 }
47638 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47639 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47640 }
47641 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47642 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47643 }
47644 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47645 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47646 }
47647 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47648 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47649 }
47650 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47651 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47652 }
47653 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
47654 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
47655 }
47656 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47657 return (void *)((wxObject *) ((wxImageHandler *) x));
47658 }
47659 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47660 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47661 }
47662 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47663 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47664 }
47665 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47666 return (void *)((wxObject *) ((wxEvtHandler *) x));
47667 }
47668 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47669 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47670 }
47671 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47672 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47673 }
47674 static void *_p_wxImageTo_p_wxObject(void *x) {
47675 return (void *)((wxObject *) ((wxImage *) x));
47676 }
47677 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47678 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47679 }
47680 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47681 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47682 }
47683 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47684 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47685 }
47686 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47687 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47688 }
47689 static void *_p_wxWindowTo_p_wxObject(void *x) {
47690 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47691 }
47692 static void *_p_wxMenuTo_p_wxObject(void *x) {
47693 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47694 }
47695 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47696 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47697 }
47698 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47699 return (void *)((wxObject *) ((wxFileSystem *) x));
47700 }
47701 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47702 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47703 }
47704 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47705 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47706 }
47707 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47708 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47709 }
47710 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47711 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47712 }
47713 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47714 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47715 }
47716 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47717 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47718 }
47719 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47720 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47721 }
47722 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47723 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47724 }
47725 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47726 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47727 }
47728 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47729 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47730 }
47731 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47732 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47733 }
47734 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47735 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47736 }
47737 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47738 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47739 }
47740 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47741 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47742 }
47743 static void *_p_wxControlTo_p_wxWindow(void *x) {
47744 return (void *)((wxWindow *) ((wxControl *) x));
47745 }
47746 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47747 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47748 }
47749 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47750 return (void *)((wxWindow *) ((wxMenuBar *) x));
47751 }
47752 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47753 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47754 }
47755 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47756 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47757 }
47758 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47759 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47760 }
47761 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47762 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47763 }
47764 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47765 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47766 }
47767 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47768 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47769 }
47770 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47771 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47772 }
47773 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47774 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47775 }
47776 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47777 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47778 }
47779 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47780 return (void *)((wxValidator *) ((wxPyValidator *) x));
47781 }
47782 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}};
47783 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}};
47784 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}};
47785 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}};
47786 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}};
47787 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}};
47788 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}};
47789 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}};
47790 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}};
47791 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}};
47792 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}};
47793 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}};
47794 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}};
47795 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}};
47796 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}};
47797 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}};
47798 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}};
47799 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}};
47800 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}};
47801 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}};
47802 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}};
47803 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}};
47804 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}};
47805 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}};
47806 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}};
47807 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}};
47808 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}};
47809 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}};
47810 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}};
47811 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}};
47812 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}};
47813 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}};
47814 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}};
47815 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}};
47816 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}};
47817 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}};
47818 static swig_type_info _swigt__p_wxImage_HSVValue[] = {{"_p_wxImage_HSVValue", 0, "wxImage_HSVValue *", 0, 0, 0, 0},{"_p_wxImage_HSVValue", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47819 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}};
47820 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}};
47821 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}};
47822 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}};
47823 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}};
47824 static swig_type_info _swigt__p_wxImage_RGBValue[] = {{"_p_wxImage_RGBValue", 0, "wxImage_RGBValue *", 0, 0, 0, 0},{"_p_wxImage_RGBValue", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47825 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}};
47826 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}};
47827 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}};
47828 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}};
47829 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}};
47830 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}};
47831 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}};
47832 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}};
47833 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}};
47834 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}};
47835 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}};
47836 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}};
47837 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}};
47838 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}};
47839 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}};
47840 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}};
47841 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}};
47842 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}};
47843 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}};
47844 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}};
47845 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}};
47846 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}};
47847 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}};
47848 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}};
47849 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}};
47850 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}};
47851 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}};
47852 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}};
47853 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}};
47854 static swig_type_info _swigt__p_wxPyImageHandler[] = {{"_p_wxPyImageHandler", 0, "wxPyImageHandler *", 0, 0, 0, 0},{"_p_wxPyImageHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47855 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}};
47856 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}};
47857 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}};
47858 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}};
47859 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}};
47860 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}};
47861 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}};
47862 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}};
47863 static swig_type_info _swigt__p_wxImageHandler[] = {{"_p_wxImageHandler", 0, "wxImageHandler *", 0, 0, 0, 0},{"_p_wxImageHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxImageHandler, 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}};
47864 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}};
47865 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}};
47866 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}};
47867 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}};
47868 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}};
47869 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}};
47870 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}};
47871 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}};
47872 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}};
47873 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}};
47874 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}};
47875 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}};
47876 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}};
47877 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}};
47878 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}};
47879 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}};
47880 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_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_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_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}};
47881 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}};
47882 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}};
47883 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}};
47884 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}};
47885 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}};
47886 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}};
47887 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}};
47888 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}};
47889 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}};
47890 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}};
47891 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}};
47892 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}};
47893 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}};
47894 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}};
47895 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}};
47896 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}};
47897 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}};
47898 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}};
47899 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}};
47900 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}};
47901 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}};
47902 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}};
47903 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}};
47904 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}};
47905 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}};
47906 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}};
47907 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}};
47908 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}};
47909 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}};
47910 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}};
47911 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}};
47912 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}};
47913
47914 static swig_type_info *swig_types_initial[] = {
47915 _swigt__p_wxLayoutConstraints,
47916 _swigt__p_wxRealPoint,
47917 _swigt__p_wxSizerItem,
47918 _swigt__p_wxGBSizerItem,
47919 _swigt__p_wxScrollEvent,
47920 _swigt__p_wxEventLoop,
47921 _swigt__p_wxIndividualLayoutConstraint,
47922 _swigt__p_wxSizer,
47923 _swigt__p_wxBoxSizer,
47924 _swigt__p_wxStaticBoxSizer,
47925 _swigt__p_wxGridBagSizer,
47926 _swigt__p_wxAcceleratorEntry,
47927 _swigt__p_wxUpdateUIEvent,
47928 _swigt__p_wxEvent,
47929 _swigt__p_buffer,
47930 _swigt__p_wxMenu,
47931 _swigt__p_wxGridSizer,
47932 _swigt__p_wxFlexGridSizer,
47933 _swigt__p_wxInitDialogEvent,
47934 _swigt__p_wxItemContainer,
47935 _swigt__p_wxPaintEvent,
47936 _swigt__p_wxNcPaintEvent,
47937 _swigt__p_wxSysColourChangedEvent,
47938 _swigt__p_wxMouseCaptureChangedEvent,
47939 _swigt__p_wxDisplayChangedEvent,
47940 _swigt__p_wxPaletteChangedEvent,
47941 _swigt__p_wxControl,
47942 _swigt__p_wxFont,
47943 _swigt__p_wxMenuBarBase,
47944 _swigt__p_wxSetCursorEvent,
47945 _swigt__p_wxFSFile,
47946 _swigt__p_wxCaret,
47947 _swigt__ptrdiff_t,
47948 _swigt__std__ptrdiff_t,
47949 _swigt__p_wxRegion,
47950 _swigt__p_wxPoint2D,
47951 _swigt__p_wxImage_HSVValue,
47952 _swigt__p_int,
47953 _swigt__p_wxSize,
47954 _swigt__p_wxDC,
47955 _swigt__p_wxPySizer,
47956 _swigt__p_wxVisualAttributes,
47957 _swigt__p_wxImage_RGBValue,
47958 _swigt__p_wxNotifyEvent,
47959 _swigt__p_wxPyEvent,
47960 _swigt__p_wxPropagationDisabler,
47961 _swigt__p_form_ops_t,
47962 _swigt__p_wxAppTraits,
47963 _swigt__p_wxArrayString,
47964 _swigt__p_wxShowEvent,
47965 _swigt__p_wxToolTip,
47966 _swigt__p_wxMoveEvent,
47967 _swigt__p_wxSizeEvent,
47968 _swigt__p_wxActivateEvent,
47969 _swigt__p_wxIconizeEvent,
47970 _swigt__p_wxMaximizeEvent,
47971 _swigt__p_wxQueryNewPaletteEvent,
47972 _swigt__p_wxWindowCreateEvent,
47973 _swigt__p_wxIdleEvent,
47974 _swigt__p_wxDateEvent,
47975 _swigt__p_wxMenuItem,
47976 _swigt__p_wxStaticBox,
47977 _swigt__p_long,
47978 _swigt__p_wxDuplexMode,
47979 _swigt__p_wxTIFFHandler,
47980 _swigt__p_wxXPMHandler,
47981 _swigt__p_wxPNMHandler,
47982 _swigt__p_wxJPEGHandler,
47983 _swigt__p_wxPCXHandler,
47984 _swigt__p_wxGIFHandler,
47985 _swigt__p_wxPNGHandler,
47986 _swigt__p_wxANIHandler,
47987 _swigt__p_wxPyImageHandler,
47988 _swigt__p_wxMemoryFSHandler,
47989 _swigt__p_wxZipFSHandler,
47990 _swigt__p_wxInternetFSHandler,
47991 _swigt__p_wxPyFileSystemHandler,
47992 _swigt__p_wxEvtHandler,
47993 _swigt__p_wxCURHandler,
47994 _swigt__p_wxICOHandler,
47995 _swigt__p_wxBMPHandler,
47996 _swigt__p_wxImageHandler,
47997 _swigt__p_wxFileSystemHandler,
47998 _swigt__p_wxRect,
47999 _swigt__p_wxButton,
48000 _swigt__p_wxGBSpan,
48001 _swigt__p_wxPropagateOnce,
48002 _swigt__p_wxAcceleratorTable,
48003 _swigt__p_wxStdDialogButtonSizer,
48004 _swigt__p_char,
48005 _swigt__p_wxGBPosition,
48006 _swigt__p_wxImage,
48007 _swigt__p_wxFrame,
48008 _swigt__p_wxScrollWinEvent,
48009 _swigt__p_wxPaperSize,
48010 _swigt__p_wxImageHistogram,
48011 _swigt__p_wxPoint,
48012 _swigt__p_wxCursor,
48013 _swigt__p_wxObject,
48014 _swigt__p_wxInputStream,
48015 _swigt__p_wxOutputStream,
48016 _swigt__p_wxPyInputStream,
48017 _swigt__p_wxDateTime,
48018 _swigt__p_wxKeyEvent,
48019 _swigt__p_wxNavigationKeyEvent,
48020 _swigt__p_wxWindowDestroyEvent,
48021 _swigt__p_unsigned_long,
48022 _swigt__p_wxWindow,
48023 _swigt__p_wxMenuBar,
48024 _swigt__p_wxFileSystem,
48025 _swigt__p_wxBitmap,
48026 _swigt__unsigned_int,
48027 _swigt__p_unsigned_int,
48028 _swigt__p_wxMenuEvent,
48029 _swigt__p_wxContextMenuEvent,
48030 _swigt__p_unsigned_char,
48031 _swigt__p_wxMouseEvent,
48032 _swigt__p_wxEraseEvent,
48033 _swigt__p_wxCloseEvent,
48034 _swigt__p_wxPyApp,
48035 _swigt__p_wxCommandEvent,
48036 _swigt__p_wxPyCommandEvent,
48037 _swigt__p_wxPyDropTarget,
48038 _swigt__p_wxQuantize,
48039 _swigt__p_wxFocusEvent,
48040 _swigt__p_wxChildFocusEvent,
48041 _swigt__p_wxDropFilesEvent,
48042 _swigt__p_wxControlWithItems,
48043 _swigt__p_wxColour,
48044 _swigt__p_wxValidator,
48045 _swigt__p_wxPyValidator,
48046 0
48047 };
48048
48049
48050 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48051
48052 static swig_const_info swig_const_table[] = {
48053 {0, 0, 0, 0.0, 0, 0}};
48054
48055 #ifdef __cplusplus
48056 }
48057 #endif
48058
48059
48060 #ifdef __cplusplus
48061 extern "C" {
48062 #endif
48063
48064 /* Python-specific SWIG API */
48065 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48066 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48067 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48068
48069 /* -----------------------------------------------------------------------------
48070 * global variable support code.
48071 * ----------------------------------------------------------------------------- */
48072
48073 typedef struct swig_globalvar {
48074 char *name; /* Name of global variable */
48075 PyObject *(*get_attr)(); /* Return the current value */
48076 int (*set_attr)(PyObject *); /* Set the value */
48077 struct swig_globalvar *next;
48078 } swig_globalvar;
48079
48080 typedef struct swig_varlinkobject {
48081 PyObject_HEAD
48082 swig_globalvar *vars;
48083 } swig_varlinkobject;
48084
48085 static PyObject *
48086 swig_varlink_repr(swig_varlinkobject *v) {
48087 v = v;
48088 return PyString_FromString("<Swig global variables>");
48089 }
48090
48091 static int
48092 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48093 swig_globalvar *var;
48094 flags = flags;
48095 fprintf(fp,"Swig global variables { ");
48096 for (var = v->vars; var; var=var->next) {
48097 fprintf(fp,"%s", var->name);
48098 if (var->next) fprintf(fp,", ");
48099 }
48100 fprintf(fp," }\n");
48101 return 0;
48102 }
48103
48104 static PyObject *
48105 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48106 swig_globalvar *var = v->vars;
48107 while (var) {
48108 if (strcmp(var->name,n) == 0) {
48109 return (*var->get_attr)();
48110 }
48111 var = var->next;
48112 }
48113 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48114 return NULL;
48115 }
48116
48117 static int
48118 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48119 swig_globalvar *var = v->vars;
48120 while (var) {
48121 if (strcmp(var->name,n) == 0) {
48122 return (*var->set_attr)(p);
48123 }
48124 var = var->next;
48125 }
48126 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48127 return 1;
48128 }
48129
48130 static PyTypeObject varlinktype = {
48131 PyObject_HEAD_INIT(0)
48132 0, /* Number of items in variable part (ob_size) */
48133 (char *)"swigvarlink", /* Type name (tp_name) */
48134 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
48135 0, /* Itemsize (tp_itemsize) */
48136 0, /* Deallocator (tp_dealloc) */
48137 (printfunc) swig_varlink_print, /* Print (tp_print) */
48138 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
48139 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
48140 0, /* tp_compare */
48141 (reprfunc) swig_varlink_repr, /* tp_repr */
48142 0, /* tp_as_number */
48143 0, /* tp_as_sequence */
48144 0, /* tp_as_mapping */
48145 0, /* tp_hash */
48146 0, /* tp_call */
48147 0, /* tp_str */
48148 0, /* tp_getattro */
48149 0, /* tp_setattro */
48150 0, /* tp_as_buffer */
48151 0, /* tp_flags */
48152 0, /* tp_doc */
48153 #if PY_VERSION_HEX >= 0x02000000
48154 0, /* tp_traverse */
48155 0, /* tp_clear */
48156 #endif
48157 #if PY_VERSION_HEX >= 0x02010000
48158 0, /* tp_richcompare */
48159 0, /* tp_weaklistoffset */
48160 #endif
48161 #if PY_VERSION_HEX >= 0x02020000
48162 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
48163 #endif
48164 #if PY_VERSION_HEX >= 0x02030000
48165 0, /* tp_del */
48166 #endif
48167 #ifdef COUNT_ALLOCS
48168 0,0,0,0 /* tp_alloc -> tp_next */
48169 #endif
48170 };
48171
48172 /* Create a variable linking object for use later */
48173 static PyObject *
48174 SWIG_Python_newvarlink(void) {
48175 swig_varlinkobject *result = 0;
48176 result = PyMem_NEW(swig_varlinkobject,1);
48177 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
48178 result->ob_type = &varlinktype;
48179 result->vars = 0;
48180 result->ob_refcnt = 0;
48181 Py_XINCREF((PyObject *) result);
48182 return ((PyObject*) result);
48183 }
48184
48185 static void
48186 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
48187 swig_varlinkobject *v;
48188 swig_globalvar *gv;
48189 v= (swig_varlinkobject *) p;
48190 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
48191 gv->name = (char *) malloc(strlen(name)+1);
48192 strcpy(gv->name,name);
48193 gv->get_attr = get_attr;
48194 gv->set_attr = set_attr;
48195 gv->next = v->vars;
48196 v->vars = gv;
48197 }
48198
48199 /* -----------------------------------------------------------------------------
48200 * constants/methods manipulation
48201 * ----------------------------------------------------------------------------- */
48202
48203 /* Install Constants */
48204 static void
48205 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
48206 PyObject *obj = 0;
48207 size_t i;
48208 for (i = 0; constants[i].type; i++) {
48209 switch(constants[i].type) {
48210 case SWIG_PY_INT:
48211 obj = PyInt_FromLong(constants[i].lvalue);
48212 break;
48213 case SWIG_PY_FLOAT:
48214 obj = PyFloat_FromDouble(constants[i].dvalue);
48215 break;
48216 case SWIG_PY_STRING:
48217 if (constants[i].pvalue) {
48218 obj = PyString_FromString((char *) constants[i].pvalue);
48219 } else {
48220 Py_INCREF(Py_None);
48221 obj = Py_None;
48222 }
48223 break;
48224 case SWIG_PY_POINTER:
48225 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
48226 break;
48227 case SWIG_PY_BINARY:
48228 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
48229 break;
48230 default:
48231 obj = 0;
48232 break;
48233 }
48234 if (obj) {
48235 PyDict_SetItemString(d,constants[i].name,obj);
48236 Py_DECREF(obj);
48237 }
48238 }
48239 }
48240
48241 /* -----------------------------------------------------------------------------*/
48242 /* Fix SwigMethods to carry the callback ptrs when needed */
48243 /* -----------------------------------------------------------------------------*/
48244
48245 static void
48246 SWIG_Python_FixMethods(PyMethodDef *methods,
48247 swig_const_info *const_table,
48248 swig_type_info **types,
48249 swig_type_info **types_initial) {
48250 size_t i;
48251 for (i = 0; methods[i].ml_name; ++i) {
48252 char *c = methods[i].ml_doc;
48253 if (c && (c = strstr(c, "swig_ptr: "))) {
48254 int j;
48255 swig_const_info *ci = 0;
48256 char *name = c + 10;
48257 for (j = 0; const_table[j].type; j++) {
48258 if (strncmp(const_table[j].name, name,
48259 strlen(const_table[j].name)) == 0) {
48260 ci = &(const_table[j]);
48261 break;
48262 }
48263 }
48264 if (ci) {
48265 size_t shift = (ci->ptype) - types;
48266 swig_type_info *ty = types_initial[shift];
48267 size_t ldoc = (c - methods[i].ml_doc);
48268 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
48269 char *ndoc = (char*)malloc(ldoc + lptr + 10);
48270 char *buff = ndoc;
48271 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
48272 strncpy(buff, methods[i].ml_doc, ldoc);
48273 buff += ldoc;
48274 strncpy(buff, "swig_ptr: ", 10);
48275 buff += 10;
48276 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
48277 methods[i].ml_doc = ndoc;
48278 }
48279 }
48280 }
48281 }
48282
48283 /* -----------------------------------------------------------------------------*
48284 * Initialize type list
48285 * -----------------------------------------------------------------------------*/
48286
48287 #if PY_MAJOR_VERSION < 2
48288 /* PyModule_AddObject function was introduced in Python 2.0. The following function
48289 is copied out of Python/modsupport.c in python version 2.3.4 */
48290 static int
48291 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
48292 {
48293 PyObject *dict;
48294 if (!PyModule_Check(m)) {
48295 PyErr_SetString(PyExc_TypeError,
48296 "PyModule_AddObject() needs module as first arg");
48297 return -1;
48298 }
48299 if (!o) {
48300 PyErr_SetString(PyExc_TypeError,
48301 "PyModule_AddObject() needs non-NULL value");
48302 return -1;
48303 }
48304
48305 dict = PyModule_GetDict(m);
48306 if (dict == NULL) {
48307 /* Internal error -- modules must have a dict! */
48308 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
48309 PyModule_GetName(m));
48310 return -1;
48311 }
48312 if (PyDict_SetItemString(dict, name, o))
48313 return -1;
48314 Py_DECREF(o);
48315 return 0;
48316 }
48317 #endif
48318
48319 static swig_type_info **
48320 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
48321 static PyMethodDef swig_empty_runtime_method_table[] = {
48322 {
48323 NULL, NULL, 0, NULL
48324 }
48325 };/* Sentinel */
48326
48327 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
48328 swig_empty_runtime_method_table);
48329 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
48330 if (pointer && module) {
48331 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
48332 }
48333 return type_list_handle;
48334 }
48335
48336 static swig_type_info **
48337 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
48338 swig_type_info **type_pointer;
48339
48340 /* first check if module already created */
48341 type_pointer = SWIG_Python_GetTypeListHandle();
48342 if (type_pointer) {
48343 return type_pointer;
48344 } else {
48345 /* create a new module and variable */
48346 return SWIG_Python_SetTypeListHandle(type_list_handle);
48347 }
48348 }
48349
48350 #ifdef __cplusplus
48351 }
48352 #endif
48353
48354 /* -----------------------------------------------------------------------------*
48355 * Partial Init method
48356 * -----------------------------------------------------------------------------*/
48357
48358 #ifdef SWIG_LINK_RUNTIME
48359 #ifdef __cplusplus
48360 extern "C"
48361 #endif
48362 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
48363 #endif
48364
48365 #ifdef __cplusplus
48366 extern "C"
48367 #endif
48368 SWIGEXPORT(void) SWIG_init(void) {
48369 static PyObject *SWIG_globals = 0;
48370 static int typeinit = 0;
48371 PyObject *m, *d;
48372 int i;
48373 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
48374
48375 /* Fix SwigMethods to carry the callback ptrs when needed */
48376 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
48377
48378 m = Py_InitModule((char *) SWIG_name, SwigMethods);
48379 d = PyModule_GetDict(m);
48380
48381 if (!typeinit) {
48382 #ifdef SWIG_LINK_RUNTIME
48383 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
48384 #else
48385 # ifndef SWIG_STATIC_RUNTIME
48386 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
48387 # endif
48388 #endif
48389 for (i = 0; swig_types_initial[i]; i++) {
48390 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
48391 }
48392 typeinit = 1;
48393 }
48394 SWIG_InstallConstants(d,swig_const_table);
48395
48396
48397 #ifndef wxPyUSE_EXPORT
48398 // Make our API structure a CObject so other modules can import it
48399 // from this module.
48400 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
48401 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
48402 Py_XDECREF(cobj);
48403 #endif
48404
48405 {
48406 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
48416 }
48417 {
48418 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
48419 }
48420 {
48421 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
48422 }
48423 {
48424 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
48425 }
48426 {
48427 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
48428 }
48429 {
48430 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
48431 }
48432 {
48433 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
48434 }
48435 {
48436 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
48437 }
48438 {
48439 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
48440 }
48441 {
48442 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
48443 }
48444 {
48445 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
48446 }
48447 {
48448 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
48449 }
48450 {
48451 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int((int)(wxSIZE_FORCE)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int((int)(wxID_NONE)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48965 }
48966 {
48967 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48974 }
48975 {
48976 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48977 }
48978 {
48979 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48980 }
48981 {
48982 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48986 }
48987 {
48988 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48989 }
48990 {
48991 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48992 }
48993 {
48994 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
49040 }
49041 {
49042 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
49043 }
49044 {
49045 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
49046 }
49047 {
49048 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
49049 }
49050 {
49051 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
49052 }
49053 {
49054 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
49055 }
49056 {
49057 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
49058 }
49059 {
49060 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
49061 }
49062 {
49063 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
49064 }
49065 {
49066 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
49067 }
49068 {
49069 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
49070 }
49071 {
49072 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
49073 }
49074 {
49075 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
49076 }
49077 {
49078 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
49079 }
49080 {
49081 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
49082 }
49083 {
49084 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
49097 }
49098 {
49099 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
49100 }
49101 {
49102 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
49103 }
49104 {
49105 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
49106 }
49107 {
49108 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
49109 }
49110 {
49111 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
49112 }
49113 {
49114 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
49115 }
49116 {
49117 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
49118 }
49119 {
49120 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
49121 }
49122 {
49123 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
49124 }
49125 {
49126 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
49127 }
49128 {
49129 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
49130 }
49131 {
49132 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
49133 }
49134 {
49135 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
49136 }
49137 {
49138 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
49139 }
49140 {
49141 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
49142 }
49143 {
49144 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
49154 }
49155 {
49156 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
49295 }
49296 {
49297 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
49298 }
49299 {
49300 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
49301 }
49302 {
49303 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
49304 }
49305 {
49306 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
49307 }
49308 {
49309 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
49310 }
49311 {
49312 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
49313 }
49314 {
49315 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
49316 }
49317 {
49318 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
49319 }
49320 {
49321 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
49322 }
49323 {
49324 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
49325 }
49326 {
49327 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
49328 }
49329 {
49330 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
49553 }
49554 {
49555 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
49556 }
49557 {
49558 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
49565 }
49566 {
49567 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
49568 }
49569 {
49570 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
49571 }
49572 {
49573 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
49574 }
49575 {
49576 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
49577 }
49578 {
49579 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
49580 }
49581 {
49582 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
49583 }
49584 {
49585 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
49586 }
49587 {
49588 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49631 }
49632 {
49633 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49634 }
49635 {
49636 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49637 }
49638 {
49639 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49640 }
49641 {
49642 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49643 }
49644 {
49645 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49646 }
49647 {
49648 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49649 }
49650 {
49651 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49652 }
49653 {
49654 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49655 }
49656 {
49657 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49658 }
49659 {
49660 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49661 }
49662 {
49663 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49664 }
49665 {
49666 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49667 }
49668 {
49669 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49670 }
49671 {
49672 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49673 }
49674 {
49675 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49676 }
49677 {
49678 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49679 }
49680 {
49681 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49682 }
49683 {
49684 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49685 }
49686 {
49687 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49688 }
49689 {
49690 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49691 }
49692 {
49693 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49694 }
49695 {
49696 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49697 }
49698 {
49699 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49700 }
49701 {
49702 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49703 }
49704 {
49705 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49706 }
49707 {
49708 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49709 }
49710 {
49711 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49712 }
49713 {
49714 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49715 }
49716 {
49717 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49718 }
49719 {
49720 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49721 }
49722 {
49723 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49724 }
49725 {
49726 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49727 }
49728 {
49729 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49730 }
49731 {
49732 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49733 }
49734 {
49735 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49736 }
49737 {
49738 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49739 }
49740 {
49741 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49742 }
49743 {
49744 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49745 }
49746 {
49747 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49748 }
49749 {
49750 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49751 }
49752 {
49753 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49754 }
49755 {
49756 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49757 }
49758 {
49759 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49760 }
49761 {
49762 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49763 }
49764 {
49765 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49766 }
49767 {
49768 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49769 }
49770 {
49771 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49772 }
49773 {
49774 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49775 }
49776 {
49777 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49778 }
49779 {
49780 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49781 }
49782 {
49783 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49784 }
49785 {
49786 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49787 }
49788 {
49789 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49790 }
49791 {
49792 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49793 }
49794 {
49795 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49796 }
49797 {
49798 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49799 }
49800 {
49801 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49802 }
49803 {
49804 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49805 }
49806 {
49807 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49808 }
49809 {
49810 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49811 }
49812 {
49813 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49814 }
49815 {
49816 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49817 }
49818 {
49819 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49820 }
49821 {
49822 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49823 }
49824 {
49825 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49826 }
49827 {
49828 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49829 }
49830 {
49831 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49832 }
49833 {
49834 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49835 }
49836 {
49837 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49838 }
49839 {
49840 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49841 }
49842 {
49843 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49847 }
49848 {
49849 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49850 }
49851 {
49852 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49853 }
49854 {
49855 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49856 }
49857 {
49858 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49859 }
49860 {
49861 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49862 }
49863 {
49864 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49865 }
49866 {
49867 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49868 }
49869 {
49870 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49871 }
49872 {
49873 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49874 }
49875 {
49876 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49877 }
49878 {
49879 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49880 }
49881 {
49882 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49883 }
49884 {
49885 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49886 }
49887 {
49888 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49889 }
49890 {
49891 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49892 }
49893 {
49894 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49895 }
49896 {
49897 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49898 }
49899 {
49900 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49901 }
49902 {
49903 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49904 }
49905 {
49906 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49907 }
49908 {
49909 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49910 }
49911 {
49912 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49913 }
49914 {
49915 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49916 }
49917 {
49918 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49919 }
49920 {
49921 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49922 }
49923 {
49924 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49925 }
49926 {
49927 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49928 }
49929 {
49930 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49931 }
49932 {
49933 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49934 }
49935 {
49936 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49937 }
49938 {
49939 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49940 }
49941 {
49942 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49943 }
49944 {
49945 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49946 }
49947 {
49948 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49949 }
49950 {
49951 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49952 }
49953 {
49954 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49955 }
49956 {
49957 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49958 }
49959 {
49960 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49961 }
49962 {
49963 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49964 }
49965 {
49966 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49967 }
49968 {
49969 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49970 }
49971 {
49972 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49973 }
49974 {
49975 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49976 }
49977 {
49978 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49979 }
49980 {
49981 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD)));
49982 }
49983 {
49984 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int((int)(wxPAPER_A6)));
49985 }
49986 {
49987 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int((int)(wxPAPER_JENV_KAKU2)));
49988 }
49989 {
49990 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int((int)(wxPAPER_JENV_KAKU3)));
49991 }
49992 {
49993 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int((int)(wxPAPER_JENV_CHOU3)));
49994 }
49995 {
49996 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int((int)(wxPAPER_JENV_CHOU4)));
49997 }
49998 {
49999 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int((int)(wxPAPER_LETTER_ROTATED)));
50000 }
50001 {
50002 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int((int)(wxPAPER_A3_ROTATED)));
50003 }
50004 {
50005 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int((int)(wxPAPER_A4_ROTATED)));
50006 }
50007 {
50008 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int((int)(wxPAPER_A5_ROTATED)));
50009 }
50010 {
50011 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B4_JIS_ROTATED)));
50012 }
50013 {
50014 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B5_JIS_ROTATED)));
50015 }
50016 {
50017 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50018 }
50019 {
50020 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50021 }
50022 {
50023 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int((int)(wxPAPER_A6_ROTATED)));
50024 }
50025 {
50026 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU2_ROTATED)));
50027 }
50028 {
50029 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU3_ROTATED)));
50030 }
50031 {
50032 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU3_ROTATED)));
50033 }
50034 {
50035 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU4_ROTATED)));
50036 }
50037 {
50038 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int((int)(wxPAPER_B6_JIS)));
50039 }
50040 {
50041 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B6_JIS_ROTATED)));
50042 }
50043 {
50044 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int((int)(wxPAPER_12X11)));
50045 }
50046 {
50047 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int((int)(wxPAPER_JENV_YOU4)));
50048 }
50049 {
50050 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_YOU4_ROTATED)));
50051 }
50052 {
50053 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int((int)(wxPAPER_P16K)));
50054 }
50055 {
50056 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int((int)(wxPAPER_P32K)));
50057 }
50058 {
50059 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int((int)(wxPAPER_P32KBIG)));
50060 }
50061 {
50062 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int((int)(wxPAPER_PENV_1)));
50063 }
50064 {
50065 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int((int)(wxPAPER_PENV_2)));
50066 }
50067 {
50068 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int((int)(wxPAPER_PENV_3)));
50069 }
50070 {
50071 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int((int)(wxPAPER_PENV_4)));
50072 }
50073 {
50074 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int((int)(wxPAPER_PENV_5)));
50075 }
50076 {
50077 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int((int)(wxPAPER_PENV_6)));
50078 }
50079 {
50080 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int((int)(wxPAPER_PENV_7)));
50081 }
50082 {
50083 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int((int)(wxPAPER_PENV_8)));
50084 }
50085 {
50086 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int((int)(wxPAPER_PENV_9)));
50087 }
50088 {
50089 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int((int)(wxPAPER_PENV_10)));
50090 }
50091 {
50092 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int((int)(wxPAPER_P16K_ROTATED)));
50093 }
50094 {
50095 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int((int)(wxPAPER_P32K_ROTATED)));
50096 }
50097 {
50098 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int((int)(wxPAPER_P32KBIG_ROTATED)));
50099 }
50100 {
50101 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_1_ROTATED)));
50102 }
50103 {
50104 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_2_ROTATED)));
50105 }
50106 {
50107 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_3_ROTATED)));
50108 }
50109 {
50110 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_4_ROTATED)));
50111 }
50112 {
50113 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_5_ROTATED)));
50114 }
50115 {
50116 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_6_ROTATED)));
50117 }
50118 {
50119 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_7_ROTATED)));
50120 }
50121 {
50122 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_8_ROTATED)));
50123 }
50124 {
50125 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_9_ROTATED)));
50126 }
50127 {
50128 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_10_ROTATED)));
50129 }
50130 {
50131 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
50132 }
50133 {
50134 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
50135 }
50136 {
50137 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
50138 }
50139 {
50140 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
50141 }
50142 {
50143 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
50144 }
50145 {
50146 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
50147 }
50148 {
50149 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
50150 }
50151 {
50152 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
50153 }
50154 {
50155 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
50156 }
50157 {
50158 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
50159 }
50160 {
50161 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
50162 }
50163 {
50164 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
50165 }
50166 {
50167 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50168 }
50169 {
50170 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50171 }
50172 {
50173 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
50174 }
50175 {
50176 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
50177 }
50178 {
50179 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
50180 }
50181 {
50182 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
50183 }
50184 {
50185 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
50186 }
50187 {
50188 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
50189 }
50190 {
50191 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
50192 }
50193 {
50194 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
50195 }
50196 {
50197 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
50198 }
50199 {
50200 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
50201 }
50202 {
50203 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
50204 }
50205 {
50206 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
50207 }
50208 {
50209 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
50210 }
50211 {
50212 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int((int)(wxMOD_ALTGR)));
50213 }
50214 {
50215 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
50216 }
50217 {
50218 PyDict_SetItemString(d,"MOD_META", SWIG_From_int((int)(wxMOD_META)));
50219 }
50220 {
50221 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
50222 }
50223 {
50224 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int((int)(wxMOD_CMD)));
50225 }
50226 {
50227 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int((int)(wxMOD_ALL)));
50228 }
50229 {
50230 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
50231 }
50232 {
50233 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
50234 }
50235 {
50236 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
50237 }
50238 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
50239 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
50240 {
50241 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
50242 }
50243 {
50244 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
50245 }
50246 {
50247 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
50248 }
50249 {
50250 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
50251 }
50252 {
50253 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
50254 }
50255 {
50256 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
50257 }
50258 {
50259 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
50260 }
50261 {
50262 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
50263 }
50264 {
50265 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
50266 }
50267 {
50268 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
50269 }
50270 {
50271 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
50272 }
50273 {
50274 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
50275 }
50276 {
50277 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
50278 }
50279 {
50280 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
50281 }
50282 {
50283 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
50284 }
50285 {
50286 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
50287 }
50288 {
50289 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
50290 }
50291 {
50292 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
50293 }
50294 {
50295 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
50296 }
50297 {
50298 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
50299 }
50300 {
50301 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
50302 }
50303 {
50304 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
50305 }
50306 {
50307 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
50308 }
50309 {
50310 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
50311 }
50312 {
50313 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
50314 }
50315 {
50316 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
50317 }
50318 {
50319 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
50320 }
50321 {
50322 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
50323 }
50324 {
50325 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
50326 }
50327 {
50328 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
50329 }
50330 {
50331 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
50332 }
50333 {
50334 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
50335 }
50336 {
50337 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
50338 }
50339 {
50340 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
50341 }
50342 {
50343 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
50344 }
50345 {
50346 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
50347 }
50348 {
50349 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
50350 }
50351 {
50352 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
50353 }
50354 {
50355 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
50356 }
50357 {
50358 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
50359 }
50360 {
50361 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
50362 }
50363 {
50364 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
50365 }
50366 {
50367 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
50368 }
50369 {
50370 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
50371 }
50372 {
50373 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
50374 }
50375 {
50376 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
50377 }
50378 {
50379 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
50380 }
50381 {
50382 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
50383 }
50384 {
50385 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
50386 }
50387 {
50388 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
50389 }
50390 {
50391 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
50392 }
50393 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
50394 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
50395 {
50396 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
50397 }
50398 {
50399 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
50400 }
50401 {
50402 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
50403 }
50404
50405 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
50406
50407
50408 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
50409
50410 {
50411 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
50412 }
50413 {
50414 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
50415 }
50416 {
50417 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
50418 }
50419 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
50420 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
50421 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
50422 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
50423 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
50424 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
50425 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
50426 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
50427 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
50428 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
50429 {
50430 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
50431 }
50432 {
50433 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
50434 }
50435 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
50436 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
50437 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
50438 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
50439 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
50440 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
50441 {
50442 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
50443 }
50444 {
50445 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
50446 }
50447 {
50448 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
50449 }
50450 {
50451 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
50452 }
50453 {
50454 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
50455 }
50456 {
50457 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
50458 }
50459 {
50460 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
50461 }
50462 {
50463 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
50464 }
50465 {
50466 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
50467 }
50468 {
50469 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
50470 }
50471 {
50472 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
50473 }
50474 {
50475 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
50476 }
50477 {
50478 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
50479 }
50480 {
50481 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
50482 }
50483 {
50484 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
50485 }
50486 {
50487 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
50488 }
50489 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
50490 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
50491 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
50492 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
50493 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
50494 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
50495 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
50496 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
50497 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
50498 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
50499 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
50500 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
50501 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
50502 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
50503 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
50504 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
50505 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
50506 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
50507 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
50508 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
50509 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
50510 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
50511 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
50512 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
50513 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
50514 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
50515 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
50516 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
50517 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
50518 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
50519 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
50520 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
50521 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
50522 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
50523 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
50524 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
50525 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
50526 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
50527 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
50528 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
50529 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
50530 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
50531 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
50532 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
50533 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
50534 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
50535 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
50536 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
50537 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
50538 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
50539 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
50540 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
50541 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
50542 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
50543 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
50544 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
50545 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
50546 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
50547 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
50548 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
50549 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
50550 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
50551 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
50552 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
50553 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
50554 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
50555 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
50556 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
50557 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
50558 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
50559 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
50560 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
50561 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
50562 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
50563 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
50564 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
50565 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
50566 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
50567 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
50568 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
50569 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
50570 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
50571 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
50572 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
50573 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
50574 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
50575 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
50576 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
50577 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
50578 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
50579 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
50580 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
50581 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
50582 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
50583 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
50584 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
50585 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
50586 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
50587 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
50588 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
50589 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
50590 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
50591 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
50592 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
50593 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
50594 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
50595 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
50596 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
50597 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
50598 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
50599 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
50600 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
50601 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
50602 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
50603 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
50604 {
50605 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
50606 }
50607 {
50608 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
50609 }
50610 {
50611 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
50612 }
50613 {
50614 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
50615 }
50616 {
50617 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
50618 }
50619 {
50620 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
50621 }
50622 {
50623 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
50624 }
50625 {
50626 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
50627 }
50628 {
50629 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
50630 }
50631 {
50632 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
50633 }
50634 {
50635 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
50636 }
50637 {
50638 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
50639 }
50640 {
50641 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
50642 }
50643 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
50644 {
50645 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
50646 }
50647 {
50648 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
50649 }
50650 {
50651 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
50652 }
50653 {
50654 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
50655 }
50656 {
50657 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
50658 }
50659 {
50660 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
50661 }
50662 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
50663 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
50664 {
50665 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
50666 }
50667 {
50668 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
50669 }
50670 {
50671 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
50672 }
50673 {
50674 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
50675 }
50676 {
50677 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
50678 }
50679 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
50680 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
50681 {
50682 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
50683 }
50684 {
50685 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
50686 }
50687 {
50688 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
50689 }
50690 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
50691 {
50692 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
50693 }
50694 {
50695 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
50696 }
50697 {
50698 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
50699 }
50700 {
50701 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
50702 }
50703 {
50704 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
50705 }
50706 {
50707 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
50708 }
50709 {
50710 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
50711 }
50712 {
50713 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
50714 }
50715 {
50716 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
50717 }
50718 {
50719 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
50720 }
50721 {
50722 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
50723 }
50724 {
50725 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
50726 }
50727 {
50728 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
50729 }
50730 {
50731 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
50732 }
50733 {
50734 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
50735 }
50736 {
50737 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
50738 }
50739 {
50740 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
50741 }
50742 {
50743 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
50744 }
50745 {
50746 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
50747 }
50748
50749 // Initialize threading, some globals and such
50750 __wxPyPreStart(d);
50751
50752
50753 // Although these are defined in __version__ they need to be here too so
50754 // that an assert can be done to ensure that the wxPython and the wxWindows
50755 // versions match.
50756 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
50757 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
50758 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
50759
50760 }
50761
wxWidgets (Impactor)