]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Change reference from GetForce to CanVeto
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2579 #define SWIG_From_unsigned_SS_int SWIG_From_long
2580 /*@@*/
2581 #else
2582 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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
2664 void wxApp_CleanUp() {
2665 __wxPyCleanup();
2666 }
2667
2668
2669 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2670
2671
2672 SWIGINTERNSHORT int
2673 SWIG_AsCharPtr(PyObject *obj, char **val)
2674 {
2675 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2676 return 1;
2677 }
2678 if (val) {
2679 PyErr_Clear();
2680 SWIG_type_error("char *", obj);
2681 }
2682 return 0;
2683 }
2684
2685
2686 SWIGINTERN PyObject *
2687 SWIG_FromCharPtr(const char* cptr)
2688 {
2689 if (cptr) {
2690 size_t size = strlen(cptr);
2691 if (size > INT_MAX) {
2692 return SWIG_NewPointerObj((char*)(cptr),
2693 SWIG_TypeQuery("char *"), 0);
2694 } else {
2695 if (size != 0) {
2696 return PyString_FromStringAndSize(cptr, size);
2697 } else {
2698 return PyString_FromString(cptr);
2699 }
2700 }
2701 }
2702 Py_INCREF(Py_None);
2703 return Py_None;
2704 }
2705
2706
2707 #ifdef __WXMAC__
2708
2709 // A dummy class that raises an exception if used...
2710 class wxEventLoop
2711 {
2712 public:
2713 wxEventLoop() { wxPyRaiseNotImplemented(); }
2714 int Run() { return 0; }
2715 void Exit(int rc = 0) {}
2716 bool Pending() const { return false; }
2717 bool Dispatch() { return false; }
2718 bool IsRunning() const { return false; }
2719 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2720 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2721 };
2722
2723 #else
2724
2725 #include <wx/evtloop.h>
2726
2727 #endif
2728
2729
2730
2731 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2732 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2733 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2734 static PyObject *wxWindow_GetChildren(wxWindow *self){
2735 wxWindowList& list = self->GetChildren();
2736 return wxPy_ConvertList(&list);
2737 }
2738 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2739 #if wxUSE_HOTKEY
2740 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2741 #else
2742 return false;
2743 #endif
2744 }
2745 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2746
2747
2748
2749 return false;
2750
2751 }
2752 static long wxWindow_GetHandle(wxWindow *self){
2753 return wxPyGetWinHandle(self);
2754 }
2755 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2756 self->AssociateHandle((WXWidget)handle);
2757 }
2758
2759 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2760 return wxWindow::FindWindowById(id, parent);
2761 }
2762
2763 wxWindow* wxFindWindowByName( const wxString& name,
2764 const wxWindow *parent = NULL ) {
2765 return wxWindow::FindWindowByName(name, parent);
2766 }
2767
2768 wxWindow* wxFindWindowByLabel( const wxString& label,
2769 const wxWindow *parent = NULL ) {
2770 return wxWindow::FindWindowByLabel(label, parent);
2771 }
2772
2773
2774 #ifdef __WXMSW__
2775 #include <wx/msw/private.h> // to get wxGetWindowId
2776 #endif
2777
2778
2779 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2780 #ifdef __WXMSW__
2781 WXHWND hWnd = (WXHWND)_hWnd;
2782 long id = wxGetWindowId(hWnd);
2783 wxWindow* win = new wxWindow;
2784 if (parent)
2785 parent->AddChild(win);
2786 win->SetEventHandler(win);
2787 win->SetHWND(hWnd);
2788 win->SetId(id);
2789 win->SubclassWin(hWnd);
2790 win->AdoptAttributesFromHWND();
2791 win->SetupColours();
2792 return win;
2793 #else
2794 wxPyRaiseNotImplemented();
2795 return NULL;
2796 #endif
2797 }
2798
2799
2800 PyObject* GetTopLevelWindows() {
2801 return wxPy_ConvertList(&wxTopLevelWindows);
2802 }
2803
2804
2805 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2806 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2807 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2808
2809 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2810
2811 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2812 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2813 wxMenuItemList& list = self->GetMenuItems();
2814 return wxPy_ConvertList(&list);
2815 }
2816 static void MenuBar_SetAutoWindowMenu(bool enable){}
2817 static bool MenuBar_GetAutoWindowMenu(){ return false; }
2818 static const wxString wxPyControlNameStr(wxControlNameStr);
2819 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2820 if (clientData) {
2821 wxPyClientData* data = new wxPyClientData(clientData);
2822 return self->Append(item, data);
2823 } else
2824 return self->Append(item);
2825 }
2826 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2827 if (clientData) {
2828 wxPyClientData* data = new wxPyClientData(clientData);
2829 return self->Insert(item, pos, data);
2830 } else
2831 return self->Insert(item, pos);
2832 }
2833 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2834 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2835 if (data) {
2836 Py_INCREF(data->m_obj);
2837 return data->m_obj;
2838 } else {
2839 Py_INCREF(Py_None);
2840 return Py_None;
2841 }
2842 }
2843 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2844 wxPyClientData* data = new wxPyClientData(clientData);
2845 self->SetClientObject(n, data);
2846 }
2847
2848
2849 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2850 wxPyUserData* data = NULL;
2851 if ( userData ) {
2852 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2853 data = new wxPyUserData(userData);
2854 wxPyEndBlockThreads(blocked);
2855 }
2856 return new wxSizerItem(window, proportion, flag, border, data);
2857 }
2858 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2859 wxPyUserData* data = NULL;
2860 if ( userData ) {
2861 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2862 data = new wxPyUserData(userData);
2863 wxPyEndBlockThreads(blocked);
2864 }
2865 return new wxSizerItem(width, height, proportion, flag, border, data);
2866 }
2867 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2868 wxPyUserData* data = NULL;
2869 if ( userData ) {
2870 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2871 data = new wxPyUserData(userData);
2872 wxPyEndBlockThreads(blocked);
2873 }
2874 return new wxSizerItem(sizer, proportion, flag, border, data);
2875 }
2876
2877 #include <float.h>
2878 SWIGINTERN int
2879 SWIG_CheckDoubleInRange(double value, double min_value,
2880 double max_value, const char* errmsg)
2881 {
2882 if (value < min_value) {
2883 if (errmsg) {
2884 PyErr_Format(PyExc_OverflowError,
2885 "value %g is less than %s minimum %g",
2886 value, errmsg, min_value);
2887 }
2888 return 0;
2889 } else if (value > max_value) {
2890 if (errmsg) {
2891 PyErr_Format(PyExc_OverflowError,
2892 "value %g is greater than %s maximum %g",
2893 value, errmsg, max_value);
2894 }
2895 return 0;
2896 }
2897 return 1;
2898 }
2899
2900
2901 SWIGINTERN int
2902 SWIG_AsVal_float(PyObject *obj, float *val)
2903 {
2904 const char* errmsg = val ? "float" : (char*)0;
2905 double v;
2906 if (SWIG_AsVal_double(obj, &v)) {
2907 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2908 if (val) *val = (float)(v);
2909 return 1;
2910 } else {
2911 return 0;
2912 }
2913 } else {
2914 PyErr_Clear();
2915 }
2916 if (val) {
2917 SWIG_type_error(errmsg, obj);
2918 }
2919 return 0;
2920 }
2921
2922
2923 SWIGINTERNSHORT float
2924 SWIG_As_float(PyObject* obj)
2925 {
2926 float v;
2927 if (!SWIG_AsVal_float(obj, &v)) {
2928 /*
2929 this is needed to make valgrind/purify happier.
2930 */
2931 memset((void*)&v, 0, sizeof(float));
2932 }
2933 return v;
2934 }
2935
2936
2937 SWIGINTERNSHORT int
2938 SWIG_Check_float(PyObject* obj)
2939 {
2940 return SWIG_AsVal_float(obj, (float*)0);
2941 }
2942
2943
2944 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2945 #define SWIG_From_float PyFloat_FromDouble
2946 /*@@*/
2947
2948 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2949 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2950 if (data) {
2951 Py_INCREF(data->m_obj);
2952 return data->m_obj;
2953 } else {
2954 Py_INCREF(Py_None);
2955 return Py_None;
2956 }
2957 }
2958
2959 // Figure out the type of the sizer item
2960
2961 struct wxPySizerItemInfo {
2962 wxPySizerItemInfo()
2963 : window(NULL), sizer(NULL), gotSize(false),
2964 size(wxDefaultSize), gotPos(false), pos(-1)
2965 {}
2966
2967 wxWindow* window;
2968 wxSizer* sizer;
2969 bool gotSize;
2970 wxSize size;
2971 bool gotPos;
2972 int pos;
2973 };
2974
2975 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2976
2977 wxPySizerItemInfo info;
2978 wxSize size;
2979 wxSize* sizePtr = &size;
2980
2981 // Find out what the type of the item is
2982 // try wxWindow
2983 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2984 PyErr_Clear();
2985 info.window = NULL;
2986
2987 // try wxSizer
2988 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2989 PyErr_Clear();
2990 info.sizer = NULL;
2991
2992 // try wxSize or (w,h)
2993 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2994 info.size = *sizePtr;
2995 info.gotSize = true;
2996 }
2997
2998 // or a single int
2999 if (checkIdx && PyInt_Check(item)) {
3000 info.pos = PyInt_AsLong(item);
3001 info.gotPos = true;
3002 }
3003 }
3004 }
3005
3006 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3007 // no expected type, figure out what kind of error message to generate
3008 if ( !checkSize && !checkIdx )
3009 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3010 else if ( checkSize && !checkIdx )
3011 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3012 else if ( !checkSize && checkIdx)
3013 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3014 else
3015 // can this one happen?
3016 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3017 }
3018
3019 return info;
3020 }
3021
3022 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3023 if (!self->GetClientObject())
3024 self->SetClientObject(new wxPyOORClientData(_self));
3025 }
3026 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3027
3028 wxPyUserData* data = NULL;
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3030 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3031 if ( userData && (info.window || info.sizer || info.gotSize) )
3032 data = new wxPyUserData(userData);
3033 wxPyEndBlockThreads(blocked);
3034
3035 // Now call the real Add method if a valid item type was found
3036 if ( info.window )
3037 return self->Add(info.window, proportion, flag, border, data);
3038 else if ( info.sizer )
3039 return self->Add(info.sizer, proportion, flag, border, data);
3040 else if (info.gotSize)
3041 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3042 proportion, flag, border, data);
3043 else
3044 return NULL;
3045 }
3046 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3047
3048 wxPyUserData* data = NULL;
3049 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3050 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3051 if ( userData && (info.window || info.sizer || info.gotSize) )
3052 data = new wxPyUserData(userData);
3053 wxPyEndBlockThreads(blocked);
3054
3055 // Now call the real Insert method if a valid item type was found
3056 if ( info.window )
3057 return self->Insert(before, info.window, proportion, flag, border, data);
3058 else if ( info.sizer )
3059 return self->Insert(before, info.sizer, proportion, flag, border, data);
3060 else if (info.gotSize)
3061 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3062 proportion, flag, border, data);
3063 else
3064 return NULL;
3065 }
3066 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3067
3068 wxPyUserData* data = NULL;
3069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3070 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3071 if ( userData && (info.window || info.sizer || info.gotSize) )
3072 data = new wxPyUserData(userData);
3073 wxPyEndBlockThreads(blocked);
3074
3075 // Now call the real Prepend method if a valid item type was found
3076 if ( info.window )
3077 return self->Prepend(info.window, proportion, flag, border, data);
3078 else if ( info.sizer )
3079 return self->Prepend(info.sizer, proportion, flag, border, data);
3080 else if (info.gotSize)
3081 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3082 proportion, flag, border, data);
3083 else
3084 return NULL;
3085 }
3086 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3087 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3089 wxPyEndBlockThreads(blocked);
3090 if ( info.window )
3091 return self->Remove(info.window);
3092 else if ( info.sizer )
3093 return self->Remove(info.sizer);
3094 else if ( info.gotPos )
3095 return self->Remove(info.pos);
3096 else
3097 return false;
3098 }
3099 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3100 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3101 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3102 wxPyEndBlockThreads(blocked);
3103 if ( info.window )
3104 return self->Detach(info.window);
3105 else if ( info.sizer )
3106 return self->Detach(info.sizer);
3107 else if ( info.gotPos )
3108 return self->Detach(info.pos);
3109 else
3110 return false;
3111 }
3112 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3114 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3115 wxPyEndBlockThreads(blocked);
3116 if ( info.window )
3117 return self->GetItem(info.window);
3118 else if ( info.sizer )
3119 return self->GetItem(info.sizer);
3120 else if ( info.gotPos )
3121 return self->GetItem(info.pos);
3122 else
3123 return NULL;
3124 }
3125 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3126 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3127 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3128 wxPyEndBlockThreads(blocked);
3129 if ( info.window )
3130 self->SetItemMinSize(info.window, size);
3131 else if ( info.sizer )
3132 self->SetItemMinSize(info.sizer, size);
3133 else if ( info.gotPos )
3134 self->SetItemMinSize(info.pos, size);
3135 }
3136 static PyObject *wxSizer_GetChildren(wxSizer *self){
3137 wxSizerItemList& list = self->GetChildren();
3138 return wxPy_ConvertList(&list);
3139 }
3140 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3143 wxPyEndBlockThreads(blocked);
3144 if ( info.window )
3145 return self->Show(info.window, show, recursive);
3146 else if ( info.sizer )
3147 return self->Show(info.sizer, show, recursive);
3148 else if ( info.gotPos )
3149 return self->Show(info.pos, show);
3150 else
3151 return false;
3152 }
3153 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3156 wxPyEndBlockThreads(blocked);
3157 if ( info.window )
3158 return self->IsShown(info.window);
3159 else if ( info.sizer )
3160 return self->IsShown(info.sizer);
3161 else if ( info.gotPos )
3162 return self->IsShown(info.pos);
3163 else
3164 return false;
3165 }
3166
3167 // See pyclasses.h
3168 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3169 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3170 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3171
3172
3173
3174
3175 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3176 {
3177 if (source == Py_None) {
3178 **obj = wxGBPosition(-1,-1);
3179 return true;
3180 }
3181 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3182 }
3183
3184 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3185 {
3186 if (source == Py_None) {
3187 **obj = wxGBSpan(-1,-1);
3188 return true;
3189 }
3190 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3191 }
3192
3193
3194 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3195 self->SetRow(row);
3196 self->SetCol(col);
3197 }
3198 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3199 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3200 PyObject* tup = PyTuple_New(2);
3201 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3202 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3203 wxPyEndBlockThreads(blocked);
3204 return tup;
3205 }
3206 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3207 self->SetRowspan(rowspan);
3208 self->SetColspan(colspan);
3209 }
3210 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3211 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3212 PyObject* tup = PyTuple_New(2);
3213 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3214 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3215 wxPyEndBlockThreads(blocked);
3216 return tup;
3217 }
3218 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3219 wxPyUserData* data = NULL;
3220 if ( userData ) {
3221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3222 data = new wxPyUserData(userData);
3223 wxPyEndBlockThreads(blocked);
3224 }
3225 return new wxGBSizerItem(window, pos, span, flag, border, data);
3226 }
3227 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3228 wxPyUserData* data = NULL;
3229 if ( userData ) {
3230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3231 data = new wxPyUserData(userData);
3232 wxPyEndBlockThreads(blocked);
3233 }
3234 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3235 }
3236 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3237 wxPyUserData* data = NULL;
3238 if ( userData ) {
3239 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3240 data = new wxPyUserData(userData);
3241 wxPyEndBlockThreads(blocked);
3242 }
3243 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3244 }
3245 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3246 int row, col;
3247 self->GetEndPos(row, col);
3248 return wxGBPosition(row, col);
3249 }
3250 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3251
3252 wxPyUserData* data = NULL;
3253 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3254 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3255 if ( userData && (info.window || info.sizer || info.gotSize) )
3256 data = new wxPyUserData(userData);
3257 wxPyEndBlockThreads(blocked);
3258
3259 // Now call the real Add method if a valid item type was found
3260 if ( info.window )
3261 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3262 else if ( info.sizer )
3263 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3264 else if (info.gotSize)
3265 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3266 pos, span, flag, border, data);
3267 return NULL;
3268 }
3269
3270
3271 #ifdef __cplusplus
3272 extern "C" {
3273 #endif
3274 static int _wrap_EmptyString_set(PyObject *) {
3275 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3276 return 1;
3277 }
3278
3279
3280 static PyObject *_wrap_EmptyString_get(void) {
3281 PyObject *pyobj;
3282
3283 {
3284 #if wxUSE_UNICODE
3285 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3286 #else
3287 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3288 #endif
3289 }
3290 return pyobj;
3291 }
3292
3293
3294 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3295 PyObject *resultobj;
3296 wxObject *arg1 = (wxObject *) 0 ;
3297 wxString result;
3298 PyObject * obj0 = 0 ;
3299 char *kwnames[] = {
3300 (char *) "self", NULL
3301 };
3302
3303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3305 if (SWIG_arg_fail(1)) SWIG_fail;
3306 {
3307 PyThreadState* __tstate = wxPyBeginAllowThreads();
3308 result = wxObject_GetClassName(arg1);
3309
3310 wxPyEndAllowThreads(__tstate);
3311 if (PyErr_Occurred()) SWIG_fail;
3312 }
3313 {
3314 #if wxUSE_UNICODE
3315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3316 #else
3317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3318 #endif
3319 }
3320 return resultobj;
3321 fail:
3322 return NULL;
3323 }
3324
3325
3326 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3327 PyObject *resultobj;
3328 wxObject *arg1 = (wxObject *) 0 ;
3329 PyObject * obj0 = 0 ;
3330 char *kwnames[] = {
3331 (char *) "self", NULL
3332 };
3333
3334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3336 if (SWIG_arg_fail(1)) SWIG_fail;
3337 {
3338 PyThreadState* __tstate = wxPyBeginAllowThreads();
3339 wxObject_Destroy(arg1);
3340
3341 wxPyEndAllowThreads(__tstate);
3342 if (PyErr_Occurred()) SWIG_fail;
3343 }
3344 Py_INCREF(Py_None); resultobj = Py_None;
3345 return resultobj;
3346 fail:
3347 return NULL;
3348 }
3349
3350
3351 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3352 PyObject *obj;
3353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3354 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3355 Py_INCREF(obj);
3356 return Py_BuildValue((char *)"");
3357 }
3358 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3359 PyObject *resultobj;
3360 wxSize *arg1 = (wxSize *) 0 ;
3361 int arg2 ;
3362 PyObject * obj0 = 0 ;
3363 PyObject * obj1 = 0 ;
3364 char *kwnames[] = {
3365 (char *) "self",(char *) "x", NULL
3366 };
3367
3368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3370 if (SWIG_arg_fail(1)) SWIG_fail;
3371 {
3372 arg2 = (int)(SWIG_As_int(obj1));
3373 if (SWIG_arg_fail(2)) SWIG_fail;
3374 }
3375 if (arg1) (arg1)->x = arg2;
3376
3377 Py_INCREF(Py_None); resultobj = Py_None;
3378 return resultobj;
3379 fail:
3380 return NULL;
3381 }
3382
3383
3384 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3385 PyObject *resultobj;
3386 wxSize *arg1 = (wxSize *) 0 ;
3387 int result;
3388 PyObject * obj0 = 0 ;
3389 char *kwnames[] = {
3390 (char *) "self", NULL
3391 };
3392
3393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3395 if (SWIG_arg_fail(1)) SWIG_fail;
3396 result = (int) ((arg1)->x);
3397
3398 {
3399 resultobj = SWIG_From_int((int)(result));
3400 }
3401 return resultobj;
3402 fail:
3403 return NULL;
3404 }
3405
3406
3407 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3408 PyObject *resultobj;
3409 wxSize *arg1 = (wxSize *) 0 ;
3410 int arg2 ;
3411 PyObject * obj0 = 0 ;
3412 PyObject * obj1 = 0 ;
3413 char *kwnames[] = {
3414 (char *) "self",(char *) "y", NULL
3415 };
3416
3417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3419 if (SWIG_arg_fail(1)) SWIG_fail;
3420 {
3421 arg2 = (int)(SWIG_As_int(obj1));
3422 if (SWIG_arg_fail(2)) SWIG_fail;
3423 }
3424 if (arg1) (arg1)->y = arg2;
3425
3426 Py_INCREF(Py_None); resultobj = Py_None;
3427 return resultobj;
3428 fail:
3429 return NULL;
3430 }
3431
3432
3433 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3434 PyObject *resultobj;
3435 wxSize *arg1 = (wxSize *) 0 ;
3436 int result;
3437 PyObject * obj0 = 0 ;
3438 char *kwnames[] = {
3439 (char *) "self", NULL
3440 };
3441
3442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3444 if (SWIG_arg_fail(1)) SWIG_fail;
3445 result = (int) ((arg1)->y);
3446
3447 {
3448 resultobj = SWIG_From_int((int)(result));
3449 }
3450 return resultobj;
3451 fail:
3452 return NULL;
3453 }
3454
3455
3456 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3457 PyObject *resultobj;
3458 int arg1 = (int) 0 ;
3459 int arg2 = (int) 0 ;
3460 wxSize *result;
3461 PyObject * obj0 = 0 ;
3462 PyObject * obj1 = 0 ;
3463 char *kwnames[] = {
3464 (char *) "w",(char *) "h", NULL
3465 };
3466
3467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3468 if (obj0) {
3469 {
3470 arg1 = (int)(SWIG_As_int(obj0));
3471 if (SWIG_arg_fail(1)) SWIG_fail;
3472 }
3473 }
3474 if (obj1) {
3475 {
3476 arg2 = (int)(SWIG_As_int(obj1));
3477 if (SWIG_arg_fail(2)) SWIG_fail;
3478 }
3479 }
3480 {
3481 PyThreadState* __tstate = wxPyBeginAllowThreads();
3482 result = (wxSize *)new wxSize(arg1,arg2);
3483
3484 wxPyEndAllowThreads(__tstate);
3485 if (PyErr_Occurred()) SWIG_fail;
3486 }
3487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3488 return resultobj;
3489 fail:
3490 return NULL;
3491 }
3492
3493
3494 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3495 PyObject *resultobj;
3496 wxSize *arg1 = (wxSize *) 0 ;
3497 PyObject * obj0 = 0 ;
3498 char *kwnames[] = {
3499 (char *) "self", NULL
3500 };
3501
3502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3504 if (SWIG_arg_fail(1)) SWIG_fail;
3505 {
3506 PyThreadState* __tstate = wxPyBeginAllowThreads();
3507 delete arg1;
3508
3509 wxPyEndAllowThreads(__tstate);
3510 if (PyErr_Occurred()) SWIG_fail;
3511 }
3512 Py_INCREF(Py_None); resultobj = Py_None;
3513 return resultobj;
3514 fail:
3515 return NULL;
3516 }
3517
3518
3519 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3520 PyObject *resultobj;
3521 wxSize *arg1 = (wxSize *) 0 ;
3522 wxSize *arg2 = 0 ;
3523 bool result;
3524 wxSize temp2 ;
3525 PyObject * obj0 = 0 ;
3526 PyObject * obj1 = 0 ;
3527 char *kwnames[] = {
3528 (char *) "self",(char *) "sz", NULL
3529 };
3530
3531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3533 if (SWIG_arg_fail(1)) SWIG_fail;
3534 {
3535 arg2 = &temp2;
3536 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3537 }
3538 {
3539 PyThreadState* __tstate = wxPyBeginAllowThreads();
3540 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3541
3542 wxPyEndAllowThreads(__tstate);
3543 if (PyErr_Occurred()) SWIG_fail;
3544 }
3545 {
3546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3547 }
3548 return resultobj;
3549 fail:
3550 return NULL;
3551 }
3552
3553
3554 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3555 PyObject *resultobj;
3556 wxSize *arg1 = (wxSize *) 0 ;
3557 wxSize *arg2 = 0 ;
3558 bool result;
3559 wxSize temp2 ;
3560 PyObject * obj0 = 0 ;
3561 PyObject * obj1 = 0 ;
3562 char *kwnames[] = {
3563 (char *) "self",(char *) "sz", NULL
3564 };
3565
3566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3568 if (SWIG_arg_fail(1)) SWIG_fail;
3569 {
3570 arg2 = &temp2;
3571 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3572 }
3573 {
3574 PyThreadState* __tstate = wxPyBeginAllowThreads();
3575 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3576
3577 wxPyEndAllowThreads(__tstate);
3578 if (PyErr_Occurred()) SWIG_fail;
3579 }
3580 {
3581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3582 }
3583 return resultobj;
3584 fail:
3585 return NULL;
3586 }
3587
3588
3589 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3590 PyObject *resultobj;
3591 wxSize *arg1 = (wxSize *) 0 ;
3592 wxSize *arg2 = 0 ;
3593 wxSize result;
3594 wxSize temp2 ;
3595 PyObject * obj0 = 0 ;
3596 PyObject * obj1 = 0 ;
3597 char *kwnames[] = {
3598 (char *) "self",(char *) "sz", NULL
3599 };
3600
3601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3603 if (SWIG_arg_fail(1)) SWIG_fail;
3604 {
3605 arg2 = &temp2;
3606 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3607 }
3608 {
3609 PyThreadState* __tstate = wxPyBeginAllowThreads();
3610 result = (arg1)->operator +((wxSize const &)*arg2);
3611
3612 wxPyEndAllowThreads(__tstate);
3613 if (PyErr_Occurred()) SWIG_fail;
3614 }
3615 {
3616 wxSize * resultptr;
3617 resultptr = new wxSize((wxSize &)(result));
3618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3619 }
3620 return resultobj;
3621 fail:
3622 return NULL;
3623 }
3624
3625
3626 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3627 PyObject *resultobj;
3628 wxSize *arg1 = (wxSize *) 0 ;
3629 wxSize *arg2 = 0 ;
3630 wxSize result;
3631 wxSize temp2 ;
3632 PyObject * obj0 = 0 ;
3633 PyObject * obj1 = 0 ;
3634 char *kwnames[] = {
3635 (char *) "self",(char *) "sz", NULL
3636 };
3637
3638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3640 if (SWIG_arg_fail(1)) SWIG_fail;
3641 {
3642 arg2 = &temp2;
3643 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3644 }
3645 {
3646 PyThreadState* __tstate = wxPyBeginAllowThreads();
3647 result = (arg1)->operator -((wxSize const &)*arg2);
3648
3649 wxPyEndAllowThreads(__tstate);
3650 if (PyErr_Occurred()) SWIG_fail;
3651 }
3652 {
3653 wxSize * resultptr;
3654 resultptr = new wxSize((wxSize &)(result));
3655 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3656 }
3657 return resultobj;
3658 fail:
3659 return NULL;
3660 }
3661
3662
3663 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3664 PyObject *resultobj;
3665 wxSize *arg1 = (wxSize *) 0 ;
3666 wxSize *arg2 = 0 ;
3667 wxSize temp2 ;
3668 PyObject * obj0 = 0 ;
3669 PyObject * obj1 = 0 ;
3670 char *kwnames[] = {
3671 (char *) "self",(char *) "sz", NULL
3672 };
3673
3674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3676 if (SWIG_arg_fail(1)) SWIG_fail;
3677 {
3678 arg2 = &temp2;
3679 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3680 }
3681 {
3682 PyThreadState* __tstate = wxPyBeginAllowThreads();
3683 (arg1)->IncTo((wxSize const &)*arg2);
3684
3685 wxPyEndAllowThreads(__tstate);
3686 if (PyErr_Occurred()) SWIG_fail;
3687 }
3688 Py_INCREF(Py_None); resultobj = Py_None;
3689 return resultobj;
3690 fail:
3691 return NULL;
3692 }
3693
3694
3695 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3696 PyObject *resultobj;
3697 wxSize *arg1 = (wxSize *) 0 ;
3698 wxSize *arg2 = 0 ;
3699 wxSize temp2 ;
3700 PyObject * obj0 = 0 ;
3701 PyObject * obj1 = 0 ;
3702 char *kwnames[] = {
3703 (char *) "self",(char *) "sz", NULL
3704 };
3705
3706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3708 if (SWIG_arg_fail(1)) SWIG_fail;
3709 {
3710 arg2 = &temp2;
3711 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3712 }
3713 {
3714 PyThreadState* __tstate = wxPyBeginAllowThreads();
3715 (arg1)->DecTo((wxSize const &)*arg2);
3716
3717 wxPyEndAllowThreads(__tstate);
3718 if (PyErr_Occurred()) SWIG_fail;
3719 }
3720 Py_INCREF(Py_None); resultobj = Py_None;
3721 return resultobj;
3722 fail:
3723 return NULL;
3724 }
3725
3726
3727 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3728 PyObject *resultobj;
3729 wxSize *arg1 = (wxSize *) 0 ;
3730 int arg2 ;
3731 int arg3 ;
3732 PyObject * obj0 = 0 ;
3733 PyObject * obj1 = 0 ;
3734 PyObject * obj2 = 0 ;
3735 char *kwnames[] = {
3736 (char *) "self",(char *) "w",(char *) "h", NULL
3737 };
3738
3739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3741 if (SWIG_arg_fail(1)) SWIG_fail;
3742 {
3743 arg2 = (int)(SWIG_As_int(obj1));
3744 if (SWIG_arg_fail(2)) SWIG_fail;
3745 }
3746 {
3747 arg3 = (int)(SWIG_As_int(obj2));
3748 if (SWIG_arg_fail(3)) SWIG_fail;
3749 }
3750 {
3751 PyThreadState* __tstate = wxPyBeginAllowThreads();
3752 (arg1)->Set(arg2,arg3);
3753
3754 wxPyEndAllowThreads(__tstate);
3755 if (PyErr_Occurred()) SWIG_fail;
3756 }
3757 Py_INCREF(Py_None); resultobj = Py_None;
3758 return resultobj;
3759 fail:
3760 return NULL;
3761 }
3762
3763
3764 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3765 PyObject *resultobj;
3766 wxSize *arg1 = (wxSize *) 0 ;
3767 int arg2 ;
3768 PyObject * obj0 = 0 ;
3769 PyObject * obj1 = 0 ;
3770 char *kwnames[] = {
3771 (char *) "self",(char *) "w", NULL
3772 };
3773
3774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3776 if (SWIG_arg_fail(1)) SWIG_fail;
3777 {
3778 arg2 = (int)(SWIG_As_int(obj1));
3779 if (SWIG_arg_fail(2)) SWIG_fail;
3780 }
3781 {
3782 PyThreadState* __tstate = wxPyBeginAllowThreads();
3783 (arg1)->SetWidth(arg2);
3784
3785 wxPyEndAllowThreads(__tstate);
3786 if (PyErr_Occurred()) SWIG_fail;
3787 }
3788 Py_INCREF(Py_None); resultobj = Py_None;
3789 return resultobj;
3790 fail:
3791 return NULL;
3792 }
3793
3794
3795 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3796 PyObject *resultobj;
3797 wxSize *arg1 = (wxSize *) 0 ;
3798 int arg2 ;
3799 PyObject * obj0 = 0 ;
3800 PyObject * obj1 = 0 ;
3801 char *kwnames[] = {
3802 (char *) "self",(char *) "h", NULL
3803 };
3804
3805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3807 if (SWIG_arg_fail(1)) SWIG_fail;
3808 {
3809 arg2 = (int)(SWIG_As_int(obj1));
3810 if (SWIG_arg_fail(2)) SWIG_fail;
3811 }
3812 {
3813 PyThreadState* __tstate = wxPyBeginAllowThreads();
3814 (arg1)->SetHeight(arg2);
3815
3816 wxPyEndAllowThreads(__tstate);
3817 if (PyErr_Occurred()) SWIG_fail;
3818 }
3819 Py_INCREF(Py_None); resultobj = Py_None;
3820 return resultobj;
3821 fail:
3822 return NULL;
3823 }
3824
3825
3826 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3827 PyObject *resultobj;
3828 wxSize *arg1 = (wxSize *) 0 ;
3829 int result;
3830 PyObject * obj0 = 0 ;
3831 char *kwnames[] = {
3832 (char *) "self", NULL
3833 };
3834
3835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3837 if (SWIG_arg_fail(1)) SWIG_fail;
3838 {
3839 PyThreadState* __tstate = wxPyBeginAllowThreads();
3840 result = (int)((wxSize const *)arg1)->GetWidth();
3841
3842 wxPyEndAllowThreads(__tstate);
3843 if (PyErr_Occurred()) SWIG_fail;
3844 }
3845 {
3846 resultobj = SWIG_From_int((int)(result));
3847 }
3848 return resultobj;
3849 fail:
3850 return NULL;
3851 }
3852
3853
3854 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3855 PyObject *resultobj;
3856 wxSize *arg1 = (wxSize *) 0 ;
3857 int result;
3858 PyObject * obj0 = 0 ;
3859 char *kwnames[] = {
3860 (char *) "self", NULL
3861 };
3862
3863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3865 if (SWIG_arg_fail(1)) SWIG_fail;
3866 {
3867 PyThreadState* __tstate = wxPyBeginAllowThreads();
3868 result = (int)((wxSize const *)arg1)->GetHeight();
3869
3870 wxPyEndAllowThreads(__tstate);
3871 if (PyErr_Occurred()) SWIG_fail;
3872 }
3873 {
3874 resultobj = SWIG_From_int((int)(result));
3875 }
3876 return resultobj;
3877 fail:
3878 return NULL;
3879 }
3880
3881
3882 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3883 PyObject *resultobj;
3884 wxSize *arg1 = (wxSize *) 0 ;
3885 bool result;
3886 PyObject * obj0 = 0 ;
3887 char *kwnames[] = {
3888 (char *) "self", NULL
3889 };
3890
3891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3893 if (SWIG_arg_fail(1)) SWIG_fail;
3894 {
3895 PyThreadState* __tstate = wxPyBeginAllowThreads();
3896 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3897
3898 wxPyEndAllowThreads(__tstate);
3899 if (PyErr_Occurred()) SWIG_fail;
3900 }
3901 {
3902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3903 }
3904 return resultobj;
3905 fail:
3906 return NULL;
3907 }
3908
3909
3910 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3911 PyObject *resultobj;
3912 wxSize *arg1 = (wxSize *) 0 ;
3913 wxSize *arg2 = 0 ;
3914 wxSize temp2 ;
3915 PyObject * obj0 = 0 ;
3916 PyObject * obj1 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "self",(char *) "size", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3923 if (SWIG_arg_fail(1)) SWIG_fail;
3924 {
3925 arg2 = &temp2;
3926 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3927 }
3928 {
3929 PyThreadState* __tstate = wxPyBeginAllowThreads();
3930 (arg1)->SetDefaults((wxSize const &)*arg2);
3931
3932 wxPyEndAllowThreads(__tstate);
3933 if (PyErr_Occurred()) SWIG_fail;
3934 }
3935 Py_INCREF(Py_None); resultobj = Py_None;
3936 return resultobj;
3937 fail:
3938 return NULL;
3939 }
3940
3941
3942 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3943 PyObject *resultobj;
3944 wxSize *arg1 = (wxSize *) 0 ;
3945 PyObject *result;
3946 PyObject * obj0 = 0 ;
3947 char *kwnames[] = {
3948 (char *) "self", NULL
3949 };
3950
3951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3953 if (SWIG_arg_fail(1)) SWIG_fail;
3954 {
3955 PyThreadState* __tstate = wxPyBeginAllowThreads();
3956 result = (PyObject *)wxSize_Get(arg1);
3957
3958 wxPyEndAllowThreads(__tstate);
3959 if (PyErr_Occurred()) SWIG_fail;
3960 }
3961 resultobj = result;
3962 return resultobj;
3963 fail:
3964 return NULL;
3965 }
3966
3967
3968 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3969 PyObject *obj;
3970 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3971 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3972 Py_INCREF(obj);
3973 return Py_BuildValue((char *)"");
3974 }
3975 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3976 PyObject *resultobj;
3977 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3978 double arg2 ;
3979 PyObject * obj0 = 0 ;
3980 PyObject * obj1 = 0 ;
3981 char *kwnames[] = {
3982 (char *) "self",(char *) "x", NULL
3983 };
3984
3985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3987 if (SWIG_arg_fail(1)) SWIG_fail;
3988 {
3989 arg2 = (double)(SWIG_As_double(obj1));
3990 if (SWIG_arg_fail(2)) SWIG_fail;
3991 }
3992 if (arg1) (arg1)->x = arg2;
3993
3994 Py_INCREF(Py_None); resultobj = Py_None;
3995 return resultobj;
3996 fail:
3997 return NULL;
3998 }
3999
4000
4001 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4002 PyObject *resultobj;
4003 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4004 double result;
4005 PyObject * obj0 = 0 ;
4006 char *kwnames[] = {
4007 (char *) "self", NULL
4008 };
4009
4010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4012 if (SWIG_arg_fail(1)) SWIG_fail;
4013 result = (double) ((arg1)->x);
4014
4015 {
4016 resultobj = SWIG_From_double((double)(result));
4017 }
4018 return resultobj;
4019 fail:
4020 return NULL;
4021 }
4022
4023
4024 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4025 PyObject *resultobj;
4026 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4027 double arg2 ;
4028 PyObject * obj0 = 0 ;
4029 PyObject * obj1 = 0 ;
4030 char *kwnames[] = {
4031 (char *) "self",(char *) "y", NULL
4032 };
4033
4034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4036 if (SWIG_arg_fail(1)) SWIG_fail;
4037 {
4038 arg2 = (double)(SWIG_As_double(obj1));
4039 if (SWIG_arg_fail(2)) SWIG_fail;
4040 }
4041 if (arg1) (arg1)->y = arg2;
4042
4043 Py_INCREF(Py_None); resultobj = Py_None;
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4053 double result;
4054 PyObject * obj0 = 0 ;
4055 char *kwnames[] = {
4056 (char *) "self", NULL
4057 };
4058
4059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4061 if (SWIG_arg_fail(1)) SWIG_fail;
4062 result = (double) ((arg1)->y);
4063
4064 {
4065 resultobj = SWIG_From_double((double)(result));
4066 }
4067 return resultobj;
4068 fail:
4069 return NULL;
4070 }
4071
4072
4073 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4074 PyObject *resultobj;
4075 double arg1 = (double) 0.0 ;
4076 double arg2 = (double) 0.0 ;
4077 wxRealPoint *result;
4078 PyObject * obj0 = 0 ;
4079 PyObject * obj1 = 0 ;
4080 char *kwnames[] = {
4081 (char *) "x",(char *) "y", NULL
4082 };
4083
4084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4085 if (obj0) {
4086 {
4087 arg1 = (double)(SWIG_As_double(obj0));
4088 if (SWIG_arg_fail(1)) SWIG_fail;
4089 }
4090 }
4091 if (obj1) {
4092 {
4093 arg2 = (double)(SWIG_As_double(obj1));
4094 if (SWIG_arg_fail(2)) SWIG_fail;
4095 }
4096 }
4097 {
4098 PyThreadState* __tstate = wxPyBeginAllowThreads();
4099 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4100
4101 wxPyEndAllowThreads(__tstate);
4102 if (PyErr_Occurred()) SWIG_fail;
4103 }
4104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4105 return resultobj;
4106 fail:
4107 return NULL;
4108 }
4109
4110
4111 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4112 PyObject *resultobj;
4113 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4114 PyObject * obj0 = 0 ;
4115 char *kwnames[] = {
4116 (char *) "self", NULL
4117 };
4118
4119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4121 if (SWIG_arg_fail(1)) SWIG_fail;
4122 {
4123 PyThreadState* __tstate = wxPyBeginAllowThreads();
4124 delete arg1;
4125
4126 wxPyEndAllowThreads(__tstate);
4127 if (PyErr_Occurred()) SWIG_fail;
4128 }
4129 Py_INCREF(Py_None); resultobj = Py_None;
4130 return resultobj;
4131 fail:
4132 return NULL;
4133 }
4134
4135
4136 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4137 PyObject *resultobj;
4138 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4139 wxRealPoint *arg2 = 0 ;
4140 bool result;
4141 wxRealPoint temp2 ;
4142 PyObject * obj0 = 0 ;
4143 PyObject * obj1 = 0 ;
4144 char *kwnames[] = {
4145 (char *) "self",(char *) "pt", NULL
4146 };
4147
4148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4150 if (SWIG_arg_fail(1)) SWIG_fail;
4151 {
4152 arg2 = &temp2;
4153 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4154 }
4155 {
4156 PyThreadState* __tstate = wxPyBeginAllowThreads();
4157 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4158
4159 wxPyEndAllowThreads(__tstate);
4160 if (PyErr_Occurred()) SWIG_fail;
4161 }
4162 {
4163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4164 }
4165 return resultobj;
4166 fail:
4167 return NULL;
4168 }
4169
4170
4171 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4172 PyObject *resultobj;
4173 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4174 wxRealPoint *arg2 = 0 ;
4175 bool result;
4176 wxRealPoint temp2 ;
4177 PyObject * obj0 = 0 ;
4178 PyObject * obj1 = 0 ;
4179 char *kwnames[] = {
4180 (char *) "self",(char *) "pt", NULL
4181 };
4182
4183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4185 if (SWIG_arg_fail(1)) SWIG_fail;
4186 {
4187 arg2 = &temp2;
4188 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4189 }
4190 {
4191 PyThreadState* __tstate = wxPyBeginAllowThreads();
4192 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4193
4194 wxPyEndAllowThreads(__tstate);
4195 if (PyErr_Occurred()) SWIG_fail;
4196 }
4197 {
4198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4199 }
4200 return resultobj;
4201 fail:
4202 return NULL;
4203 }
4204
4205
4206 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4207 PyObject *resultobj;
4208 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4209 wxRealPoint *arg2 = 0 ;
4210 wxRealPoint result;
4211 wxRealPoint temp2 ;
4212 PyObject * obj0 = 0 ;
4213 PyObject * obj1 = 0 ;
4214 char *kwnames[] = {
4215 (char *) "self",(char *) "pt", NULL
4216 };
4217
4218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4220 if (SWIG_arg_fail(1)) SWIG_fail;
4221 {
4222 arg2 = &temp2;
4223 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4224 }
4225 {
4226 PyThreadState* __tstate = wxPyBeginAllowThreads();
4227 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4228
4229 wxPyEndAllowThreads(__tstate);
4230 if (PyErr_Occurred()) SWIG_fail;
4231 }
4232 {
4233 wxRealPoint * resultptr;
4234 resultptr = new wxRealPoint((wxRealPoint &)(result));
4235 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4236 }
4237 return resultobj;
4238 fail:
4239 return NULL;
4240 }
4241
4242
4243 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4244 PyObject *resultobj;
4245 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4246 wxRealPoint *arg2 = 0 ;
4247 wxRealPoint result;
4248 wxRealPoint temp2 ;
4249 PyObject * obj0 = 0 ;
4250 PyObject * obj1 = 0 ;
4251 char *kwnames[] = {
4252 (char *) "self",(char *) "pt", NULL
4253 };
4254
4255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4257 if (SWIG_arg_fail(1)) SWIG_fail;
4258 {
4259 arg2 = &temp2;
4260 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4261 }
4262 {
4263 PyThreadState* __tstate = wxPyBeginAllowThreads();
4264 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4265
4266 wxPyEndAllowThreads(__tstate);
4267 if (PyErr_Occurred()) SWIG_fail;
4268 }
4269 {
4270 wxRealPoint * resultptr;
4271 resultptr = new wxRealPoint((wxRealPoint &)(result));
4272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4273 }
4274 return resultobj;
4275 fail:
4276 return NULL;
4277 }
4278
4279
4280 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4281 PyObject *resultobj;
4282 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4283 double arg2 ;
4284 double arg3 ;
4285 PyObject * obj0 = 0 ;
4286 PyObject * obj1 = 0 ;
4287 PyObject * obj2 = 0 ;
4288 char *kwnames[] = {
4289 (char *) "self",(char *) "x",(char *) "y", NULL
4290 };
4291
4292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4294 if (SWIG_arg_fail(1)) SWIG_fail;
4295 {
4296 arg2 = (double)(SWIG_As_double(obj1));
4297 if (SWIG_arg_fail(2)) SWIG_fail;
4298 }
4299 {
4300 arg3 = (double)(SWIG_As_double(obj2));
4301 if (SWIG_arg_fail(3)) SWIG_fail;
4302 }
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 wxRealPoint_Set(arg1,arg2,arg3);
4306
4307 wxPyEndAllowThreads(__tstate);
4308 if (PyErr_Occurred()) SWIG_fail;
4309 }
4310 Py_INCREF(Py_None); resultobj = Py_None;
4311 return resultobj;
4312 fail:
4313 return NULL;
4314 }
4315
4316
4317 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4318 PyObject *resultobj;
4319 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4320 PyObject *result;
4321 PyObject * obj0 = 0 ;
4322 char *kwnames[] = {
4323 (char *) "self", NULL
4324 };
4325
4326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4328 if (SWIG_arg_fail(1)) SWIG_fail;
4329 {
4330 PyThreadState* __tstate = wxPyBeginAllowThreads();
4331 result = (PyObject *)wxRealPoint_Get(arg1);
4332
4333 wxPyEndAllowThreads(__tstate);
4334 if (PyErr_Occurred()) SWIG_fail;
4335 }
4336 resultobj = result;
4337 return resultobj;
4338 fail:
4339 return NULL;
4340 }
4341
4342
4343 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4344 PyObject *obj;
4345 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4346 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4347 Py_INCREF(obj);
4348 return Py_BuildValue((char *)"");
4349 }
4350 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4351 PyObject *resultobj;
4352 wxPoint *arg1 = (wxPoint *) 0 ;
4353 int arg2 ;
4354 PyObject * obj0 = 0 ;
4355 PyObject * obj1 = 0 ;
4356 char *kwnames[] = {
4357 (char *) "self",(char *) "x", NULL
4358 };
4359
4360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4362 if (SWIG_arg_fail(1)) SWIG_fail;
4363 {
4364 arg2 = (int)(SWIG_As_int(obj1));
4365 if (SWIG_arg_fail(2)) SWIG_fail;
4366 }
4367 if (arg1) (arg1)->x = arg2;
4368
4369 Py_INCREF(Py_None); resultobj = Py_None;
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj;
4378 wxPoint *arg1 = (wxPoint *) 0 ;
4379 int result;
4380 PyObject * obj0 = 0 ;
4381 char *kwnames[] = {
4382 (char *) "self", NULL
4383 };
4384
4385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4387 if (SWIG_arg_fail(1)) SWIG_fail;
4388 result = (int) ((arg1)->x);
4389
4390 {
4391 resultobj = SWIG_From_int((int)(result));
4392 }
4393 return resultobj;
4394 fail:
4395 return NULL;
4396 }
4397
4398
4399 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4400 PyObject *resultobj;
4401 wxPoint *arg1 = (wxPoint *) 0 ;
4402 int arg2 ;
4403 PyObject * obj0 = 0 ;
4404 PyObject * obj1 = 0 ;
4405 char *kwnames[] = {
4406 (char *) "self",(char *) "y", NULL
4407 };
4408
4409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4411 if (SWIG_arg_fail(1)) SWIG_fail;
4412 {
4413 arg2 = (int)(SWIG_As_int(obj1));
4414 if (SWIG_arg_fail(2)) SWIG_fail;
4415 }
4416 if (arg1) (arg1)->y = arg2;
4417
4418 Py_INCREF(Py_None); resultobj = Py_None;
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4426 PyObject *resultobj;
4427 wxPoint *arg1 = (wxPoint *) 0 ;
4428 int result;
4429 PyObject * obj0 = 0 ;
4430 char *kwnames[] = {
4431 (char *) "self", NULL
4432 };
4433
4434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4436 if (SWIG_arg_fail(1)) SWIG_fail;
4437 result = (int) ((arg1)->y);
4438
4439 {
4440 resultobj = SWIG_From_int((int)(result));
4441 }
4442 return resultobj;
4443 fail:
4444 return NULL;
4445 }
4446
4447
4448 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4449 PyObject *resultobj;
4450 int arg1 = (int) 0 ;
4451 int arg2 = (int) 0 ;
4452 wxPoint *result;
4453 PyObject * obj0 = 0 ;
4454 PyObject * obj1 = 0 ;
4455 char *kwnames[] = {
4456 (char *) "x",(char *) "y", NULL
4457 };
4458
4459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4460 if (obj0) {
4461 {
4462 arg1 = (int)(SWIG_As_int(obj0));
4463 if (SWIG_arg_fail(1)) SWIG_fail;
4464 }
4465 }
4466 if (obj1) {
4467 {
4468 arg2 = (int)(SWIG_As_int(obj1));
4469 if (SWIG_arg_fail(2)) SWIG_fail;
4470 }
4471 }
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = (wxPoint *)new wxPoint(arg1,arg2);
4475
4476 wxPyEndAllowThreads(__tstate);
4477 if (PyErr_Occurred()) SWIG_fail;
4478 }
4479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4480 return resultobj;
4481 fail:
4482 return NULL;
4483 }
4484
4485
4486 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4487 PyObject *resultobj;
4488 wxPoint *arg1 = (wxPoint *) 0 ;
4489 PyObject * obj0 = 0 ;
4490 char *kwnames[] = {
4491 (char *) "self", NULL
4492 };
4493
4494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4496 if (SWIG_arg_fail(1)) SWIG_fail;
4497 {
4498 PyThreadState* __tstate = wxPyBeginAllowThreads();
4499 delete arg1;
4500
4501 wxPyEndAllowThreads(__tstate);
4502 if (PyErr_Occurred()) SWIG_fail;
4503 }
4504 Py_INCREF(Py_None); resultobj = Py_None;
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4512 PyObject *resultobj;
4513 wxPoint *arg1 = (wxPoint *) 0 ;
4514 wxPoint *arg2 = 0 ;
4515 bool result;
4516 wxPoint temp2 ;
4517 PyObject * obj0 = 0 ;
4518 PyObject * obj1 = 0 ;
4519 char *kwnames[] = {
4520 (char *) "self",(char *) "pt", NULL
4521 };
4522
4523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4525 if (SWIG_arg_fail(1)) SWIG_fail;
4526 {
4527 arg2 = &temp2;
4528 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4529 }
4530 {
4531 PyThreadState* __tstate = wxPyBeginAllowThreads();
4532 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4533
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 {
4538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4539 }
4540 return resultobj;
4541 fail:
4542 return NULL;
4543 }
4544
4545
4546 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4547 PyObject *resultobj;
4548 wxPoint *arg1 = (wxPoint *) 0 ;
4549 wxPoint *arg2 = 0 ;
4550 bool result;
4551 wxPoint temp2 ;
4552 PyObject * obj0 = 0 ;
4553 PyObject * obj1 = 0 ;
4554 char *kwnames[] = {
4555 (char *) "self",(char *) "pt", NULL
4556 };
4557
4558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4560 if (SWIG_arg_fail(1)) SWIG_fail;
4561 {
4562 arg2 = &temp2;
4563 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4564 }
4565 {
4566 PyThreadState* __tstate = wxPyBeginAllowThreads();
4567 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4568
4569 wxPyEndAllowThreads(__tstate);
4570 if (PyErr_Occurred()) SWIG_fail;
4571 }
4572 {
4573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4574 }
4575 return resultobj;
4576 fail:
4577 return NULL;
4578 }
4579
4580
4581 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4582 PyObject *resultobj;
4583 wxPoint *arg1 = (wxPoint *) 0 ;
4584 wxPoint *arg2 = 0 ;
4585 wxPoint result;
4586 wxPoint temp2 ;
4587 PyObject * obj0 = 0 ;
4588 PyObject * obj1 = 0 ;
4589 char *kwnames[] = {
4590 (char *) "self",(char *) "pt", NULL
4591 };
4592
4593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4595 if (SWIG_arg_fail(1)) SWIG_fail;
4596 {
4597 arg2 = &temp2;
4598 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4599 }
4600 {
4601 PyThreadState* __tstate = wxPyBeginAllowThreads();
4602 result = (arg1)->operator +((wxPoint const &)*arg2);
4603
4604 wxPyEndAllowThreads(__tstate);
4605 if (PyErr_Occurred()) SWIG_fail;
4606 }
4607 {
4608 wxPoint * resultptr;
4609 resultptr = new wxPoint((wxPoint &)(result));
4610 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4611 }
4612 return resultobj;
4613 fail:
4614 return NULL;
4615 }
4616
4617
4618 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4619 PyObject *resultobj;
4620 wxPoint *arg1 = (wxPoint *) 0 ;
4621 wxPoint *arg2 = 0 ;
4622 wxPoint result;
4623 wxPoint temp2 ;
4624 PyObject * obj0 = 0 ;
4625 PyObject * obj1 = 0 ;
4626 char *kwnames[] = {
4627 (char *) "self",(char *) "pt", NULL
4628 };
4629
4630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4632 if (SWIG_arg_fail(1)) SWIG_fail;
4633 {
4634 arg2 = &temp2;
4635 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4636 }
4637 {
4638 PyThreadState* __tstate = wxPyBeginAllowThreads();
4639 result = (arg1)->operator -((wxPoint const &)*arg2);
4640
4641 wxPyEndAllowThreads(__tstate);
4642 if (PyErr_Occurred()) SWIG_fail;
4643 }
4644 {
4645 wxPoint * resultptr;
4646 resultptr = new wxPoint((wxPoint &)(result));
4647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4648 }
4649 return resultobj;
4650 fail:
4651 return NULL;
4652 }
4653
4654
4655 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4656 PyObject *resultobj;
4657 wxPoint *arg1 = (wxPoint *) 0 ;
4658 wxPoint *arg2 = 0 ;
4659 wxPoint *result;
4660 wxPoint temp2 ;
4661 PyObject * obj0 = 0 ;
4662 PyObject * obj1 = 0 ;
4663 char *kwnames[] = {
4664 (char *) "self",(char *) "pt", NULL
4665 };
4666
4667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4669 if (SWIG_arg_fail(1)) SWIG_fail;
4670 {
4671 arg2 = &temp2;
4672 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4673 }
4674 {
4675 PyThreadState* __tstate = wxPyBeginAllowThreads();
4676 {
4677 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4678 result = (wxPoint *) &_result_ref;
4679 }
4680
4681 wxPyEndAllowThreads(__tstate);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj;
4693 wxPoint *arg1 = (wxPoint *) 0 ;
4694 wxPoint *arg2 = 0 ;
4695 wxPoint *result;
4696 wxPoint temp2 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char *kwnames[] = {
4700 (char *) "self",(char *) "pt", NULL
4701 };
4702
4703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4705 if (SWIG_arg_fail(1)) SWIG_fail;
4706 {
4707 arg2 = &temp2;
4708 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4709 }
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 {
4713 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4714 result = (wxPoint *) &_result_ref;
4715 }
4716
4717 wxPyEndAllowThreads(__tstate);
4718 if (PyErr_Occurred()) SWIG_fail;
4719 }
4720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4721 return resultobj;
4722 fail:
4723 return NULL;
4724 }
4725
4726
4727 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4728 PyObject *resultobj;
4729 wxPoint *arg1 = (wxPoint *) 0 ;
4730 long arg2 ;
4731 long arg3 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 PyObject * obj2 = 0 ;
4735 char *kwnames[] = {
4736 (char *) "self",(char *) "x",(char *) "y", NULL
4737 };
4738
4739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4741 if (SWIG_arg_fail(1)) SWIG_fail;
4742 {
4743 arg2 = (long)(SWIG_As_long(obj1));
4744 if (SWIG_arg_fail(2)) SWIG_fail;
4745 }
4746 {
4747 arg3 = (long)(SWIG_As_long(obj2));
4748 if (SWIG_arg_fail(3)) SWIG_fail;
4749 }
4750 {
4751 PyThreadState* __tstate = wxPyBeginAllowThreads();
4752 wxPoint_Set(arg1,arg2,arg3);
4753
4754 wxPyEndAllowThreads(__tstate);
4755 if (PyErr_Occurred()) SWIG_fail;
4756 }
4757 Py_INCREF(Py_None); resultobj = Py_None;
4758 return resultobj;
4759 fail:
4760 return NULL;
4761 }
4762
4763
4764 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4765 PyObject *resultobj;
4766 wxPoint *arg1 = (wxPoint *) 0 ;
4767 PyObject *result;
4768 PyObject * obj0 = 0 ;
4769 char *kwnames[] = {
4770 (char *) "self", NULL
4771 };
4772
4773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4775 if (SWIG_arg_fail(1)) SWIG_fail;
4776 {
4777 PyThreadState* __tstate = wxPyBeginAllowThreads();
4778 result = (PyObject *)wxPoint_Get(arg1);
4779
4780 wxPyEndAllowThreads(__tstate);
4781 if (PyErr_Occurred()) SWIG_fail;
4782 }
4783 resultobj = result;
4784 return resultobj;
4785 fail:
4786 return NULL;
4787 }
4788
4789
4790 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4791 PyObject *obj;
4792 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4793 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4794 Py_INCREF(obj);
4795 return Py_BuildValue((char *)"");
4796 }
4797 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj;
4799 int arg1 = (int) 0 ;
4800 int arg2 = (int) 0 ;
4801 int arg3 = (int) 0 ;
4802 int arg4 = (int) 0 ;
4803 wxRect *result;
4804 PyObject * obj0 = 0 ;
4805 PyObject * obj1 = 0 ;
4806 PyObject * obj2 = 0 ;
4807 PyObject * obj3 = 0 ;
4808 char *kwnames[] = {
4809 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4810 };
4811
4812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4813 if (obj0) {
4814 {
4815 arg1 = (int)(SWIG_As_int(obj0));
4816 if (SWIG_arg_fail(1)) SWIG_fail;
4817 }
4818 }
4819 if (obj1) {
4820 {
4821 arg2 = (int)(SWIG_As_int(obj1));
4822 if (SWIG_arg_fail(2)) SWIG_fail;
4823 }
4824 }
4825 if (obj2) {
4826 {
4827 arg3 = (int)(SWIG_As_int(obj2));
4828 if (SWIG_arg_fail(3)) SWIG_fail;
4829 }
4830 }
4831 if (obj3) {
4832 {
4833 arg4 = (int)(SWIG_As_int(obj3));
4834 if (SWIG_arg_fail(4)) SWIG_fail;
4835 }
4836 }
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4840
4841 wxPyEndAllowThreads(__tstate);
4842 if (PyErr_Occurred()) SWIG_fail;
4843 }
4844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4845 return resultobj;
4846 fail:
4847 return NULL;
4848 }
4849
4850
4851 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4852 PyObject *resultobj;
4853 wxPoint *arg1 = 0 ;
4854 wxPoint *arg2 = 0 ;
4855 wxRect *result;
4856 wxPoint temp1 ;
4857 wxPoint temp2 ;
4858 PyObject * obj0 = 0 ;
4859 PyObject * obj1 = 0 ;
4860 char *kwnames[] = {
4861 (char *) "topLeft",(char *) "bottomRight", NULL
4862 };
4863
4864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4865 {
4866 arg1 = &temp1;
4867 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4868 }
4869 {
4870 arg2 = &temp2;
4871 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4872 }
4873 {
4874 PyThreadState* __tstate = wxPyBeginAllowThreads();
4875 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4876
4877 wxPyEndAllowThreads(__tstate);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4881 return resultobj;
4882 fail:
4883 return NULL;
4884 }
4885
4886
4887 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4888 PyObject *resultobj;
4889 wxPoint *arg1 = 0 ;
4890 wxSize *arg2 = 0 ;
4891 wxRect *result;
4892 wxPoint temp1 ;
4893 wxSize temp2 ;
4894 PyObject * obj0 = 0 ;
4895 PyObject * obj1 = 0 ;
4896 char *kwnames[] = {
4897 (char *) "pos",(char *) "size", NULL
4898 };
4899
4900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4901 {
4902 arg1 = &temp1;
4903 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4904 }
4905 {
4906 arg2 = &temp2;
4907 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4908 }
4909 {
4910 PyThreadState* __tstate = wxPyBeginAllowThreads();
4911 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4912
4913 wxPyEndAllowThreads(__tstate);
4914 if (PyErr_Occurred()) SWIG_fail;
4915 }
4916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4917 return resultobj;
4918 fail:
4919 return NULL;
4920 }
4921
4922
4923 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4924 PyObject *resultobj;
4925 wxSize *arg1 = 0 ;
4926 wxRect *result;
4927 wxSize temp1 ;
4928 PyObject * obj0 = 0 ;
4929 char *kwnames[] = {
4930 (char *) "size", NULL
4931 };
4932
4933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4934 {
4935 arg1 = &temp1;
4936 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4937 }
4938 {
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4941
4942 wxPyEndAllowThreads(__tstate);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4946 return resultobj;
4947 fail:
4948 return NULL;
4949 }
4950
4951
4952 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4953 PyObject *resultobj;
4954 wxRect *arg1 = (wxRect *) 0 ;
4955 PyObject * obj0 = 0 ;
4956 char *kwnames[] = {
4957 (char *) "self", NULL
4958 };
4959
4960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4962 if (SWIG_arg_fail(1)) SWIG_fail;
4963 {
4964 PyThreadState* __tstate = wxPyBeginAllowThreads();
4965 delete arg1;
4966
4967 wxPyEndAllowThreads(__tstate);
4968 if (PyErr_Occurred()) SWIG_fail;
4969 }
4970 Py_INCREF(Py_None); resultobj = Py_None;
4971 return resultobj;
4972 fail:
4973 return NULL;
4974 }
4975
4976
4977 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4978 PyObject *resultobj;
4979 wxRect *arg1 = (wxRect *) 0 ;
4980 int result;
4981 PyObject * obj0 = 0 ;
4982 char *kwnames[] = {
4983 (char *) "self", NULL
4984 };
4985
4986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4988 if (SWIG_arg_fail(1)) SWIG_fail;
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 result = (int)((wxRect const *)arg1)->GetX();
4992
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 {
4997 resultobj = SWIG_From_int((int)(result));
4998 }
4999 return resultobj;
5000 fail:
5001 return NULL;
5002 }
5003
5004
5005 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5006 PyObject *resultobj;
5007 wxRect *arg1 = (wxRect *) 0 ;
5008 int arg2 ;
5009 PyObject * obj0 = 0 ;
5010 PyObject * obj1 = 0 ;
5011 char *kwnames[] = {
5012 (char *) "self",(char *) "x", NULL
5013 };
5014
5015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5017 if (SWIG_arg_fail(1)) SWIG_fail;
5018 {
5019 arg2 = (int)(SWIG_As_int(obj1));
5020 if (SWIG_arg_fail(2)) SWIG_fail;
5021 }
5022 {
5023 PyThreadState* __tstate = wxPyBeginAllowThreads();
5024 (arg1)->SetX(arg2);
5025
5026 wxPyEndAllowThreads(__tstate);
5027 if (PyErr_Occurred()) SWIG_fail;
5028 }
5029 Py_INCREF(Py_None); resultobj = Py_None;
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5037 PyObject *resultobj;
5038 wxRect *arg1 = (wxRect *) 0 ;
5039 int result;
5040 PyObject * obj0 = 0 ;
5041 char *kwnames[] = {
5042 (char *) "self", NULL
5043 };
5044
5045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5047 if (SWIG_arg_fail(1)) SWIG_fail;
5048 {
5049 PyThreadState* __tstate = wxPyBeginAllowThreads();
5050 result = (int)(arg1)->GetY();
5051
5052 wxPyEndAllowThreads(__tstate);
5053 if (PyErr_Occurred()) SWIG_fail;
5054 }
5055 {
5056 resultobj = SWIG_From_int((int)(result));
5057 }
5058 return resultobj;
5059 fail:
5060 return NULL;
5061 }
5062
5063
5064 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5065 PyObject *resultobj;
5066 wxRect *arg1 = (wxRect *) 0 ;
5067 int arg2 ;
5068 PyObject * obj0 = 0 ;
5069 PyObject * obj1 = 0 ;
5070 char *kwnames[] = {
5071 (char *) "self",(char *) "y", NULL
5072 };
5073
5074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5076 if (SWIG_arg_fail(1)) SWIG_fail;
5077 {
5078 arg2 = (int)(SWIG_As_int(obj1));
5079 if (SWIG_arg_fail(2)) SWIG_fail;
5080 }
5081 {
5082 PyThreadState* __tstate = wxPyBeginAllowThreads();
5083 (arg1)->SetY(arg2);
5084
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 Py_INCREF(Py_None); resultobj = Py_None;
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5096 PyObject *resultobj;
5097 wxRect *arg1 = (wxRect *) 0 ;
5098 int result;
5099 PyObject * obj0 = 0 ;
5100 char *kwnames[] = {
5101 (char *) "self", NULL
5102 };
5103
5104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5106 if (SWIG_arg_fail(1)) SWIG_fail;
5107 {
5108 PyThreadState* __tstate = wxPyBeginAllowThreads();
5109 result = (int)((wxRect const *)arg1)->GetWidth();
5110
5111 wxPyEndAllowThreads(__tstate);
5112 if (PyErr_Occurred()) SWIG_fail;
5113 }
5114 {
5115 resultobj = SWIG_From_int((int)(result));
5116 }
5117 return resultobj;
5118 fail:
5119 return NULL;
5120 }
5121
5122
5123 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5124 PyObject *resultobj;
5125 wxRect *arg1 = (wxRect *) 0 ;
5126 int arg2 ;
5127 PyObject * obj0 = 0 ;
5128 PyObject * obj1 = 0 ;
5129 char *kwnames[] = {
5130 (char *) "self",(char *) "w", NULL
5131 };
5132
5133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5135 if (SWIG_arg_fail(1)) SWIG_fail;
5136 {
5137 arg2 = (int)(SWIG_As_int(obj1));
5138 if (SWIG_arg_fail(2)) SWIG_fail;
5139 }
5140 {
5141 PyThreadState* __tstate = wxPyBeginAllowThreads();
5142 (arg1)->SetWidth(arg2);
5143
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 Py_INCREF(Py_None); resultobj = Py_None;
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
5154 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5155 PyObject *resultobj;
5156 wxRect *arg1 = (wxRect *) 0 ;
5157 int result;
5158 PyObject * obj0 = 0 ;
5159 char *kwnames[] = {
5160 (char *) "self", NULL
5161 };
5162
5163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5165 if (SWIG_arg_fail(1)) SWIG_fail;
5166 {
5167 PyThreadState* __tstate = wxPyBeginAllowThreads();
5168 result = (int)((wxRect const *)arg1)->GetHeight();
5169
5170 wxPyEndAllowThreads(__tstate);
5171 if (PyErr_Occurred()) SWIG_fail;
5172 }
5173 {
5174 resultobj = SWIG_From_int((int)(result));
5175 }
5176 return resultobj;
5177 fail:
5178 return NULL;
5179 }
5180
5181
5182 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5183 PyObject *resultobj;
5184 wxRect *arg1 = (wxRect *) 0 ;
5185 int arg2 ;
5186 PyObject * obj0 = 0 ;
5187 PyObject * obj1 = 0 ;
5188 char *kwnames[] = {
5189 (char *) "self",(char *) "h", NULL
5190 };
5191
5192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5194 if (SWIG_arg_fail(1)) SWIG_fail;
5195 {
5196 arg2 = (int)(SWIG_As_int(obj1));
5197 if (SWIG_arg_fail(2)) SWIG_fail;
5198 }
5199 {
5200 PyThreadState* __tstate = wxPyBeginAllowThreads();
5201 (arg1)->SetHeight(arg2);
5202
5203 wxPyEndAllowThreads(__tstate);
5204 if (PyErr_Occurred()) SWIG_fail;
5205 }
5206 Py_INCREF(Py_None); resultobj = Py_None;
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj;
5215 wxRect *arg1 = (wxRect *) 0 ;
5216 wxPoint result;
5217 PyObject * obj0 = 0 ;
5218 char *kwnames[] = {
5219 (char *) "self", NULL
5220 };
5221
5222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5224 if (SWIG_arg_fail(1)) SWIG_fail;
5225 {
5226 PyThreadState* __tstate = wxPyBeginAllowThreads();
5227 result = ((wxRect const *)arg1)->GetPosition();
5228
5229 wxPyEndAllowThreads(__tstate);
5230 if (PyErr_Occurred()) SWIG_fail;
5231 }
5232 {
5233 wxPoint * resultptr;
5234 resultptr = new wxPoint((wxPoint &)(result));
5235 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5236 }
5237 return resultobj;
5238 fail:
5239 return NULL;
5240 }
5241
5242
5243 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj;
5245 wxRect *arg1 = (wxRect *) 0 ;
5246 wxPoint *arg2 = 0 ;
5247 wxPoint temp2 ;
5248 PyObject * obj0 = 0 ;
5249 PyObject * obj1 = 0 ;
5250 char *kwnames[] = {
5251 (char *) "self",(char *) "p", NULL
5252 };
5253
5254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5256 if (SWIG_arg_fail(1)) SWIG_fail;
5257 {
5258 arg2 = &temp2;
5259 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5260 }
5261 {
5262 PyThreadState* __tstate = wxPyBeginAllowThreads();
5263 (arg1)->SetPosition((wxPoint const &)*arg2);
5264
5265 wxPyEndAllowThreads(__tstate);
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 Py_INCREF(Py_None); resultobj = Py_None;
5269 return resultobj;
5270 fail:
5271 return NULL;
5272 }
5273
5274
5275 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5276 PyObject *resultobj;
5277 wxRect *arg1 = (wxRect *) 0 ;
5278 wxSize result;
5279 PyObject * obj0 = 0 ;
5280 char *kwnames[] = {
5281 (char *) "self", NULL
5282 };
5283
5284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5286 if (SWIG_arg_fail(1)) SWIG_fail;
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 result = ((wxRect const *)arg1)->GetSize();
5290
5291 wxPyEndAllowThreads(__tstate);
5292 if (PyErr_Occurred()) SWIG_fail;
5293 }
5294 {
5295 wxSize * resultptr;
5296 resultptr = new wxSize((wxSize &)(result));
5297 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5298 }
5299 return resultobj;
5300 fail:
5301 return NULL;
5302 }
5303
5304
5305 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5306 PyObject *resultobj;
5307 wxRect *arg1 = (wxRect *) 0 ;
5308 wxSize *arg2 = 0 ;
5309 wxSize temp2 ;
5310 PyObject * obj0 = 0 ;
5311 PyObject * obj1 = 0 ;
5312 char *kwnames[] = {
5313 (char *) "self",(char *) "s", NULL
5314 };
5315
5316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5318 if (SWIG_arg_fail(1)) SWIG_fail;
5319 {
5320 arg2 = &temp2;
5321 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5322 }
5323 {
5324 PyThreadState* __tstate = wxPyBeginAllowThreads();
5325 (arg1)->SetSize((wxSize const &)*arg2);
5326
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 Py_INCREF(Py_None); resultobj = Py_None;
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5338 PyObject *resultobj;
5339 wxRect *arg1 = (wxRect *) 0 ;
5340 bool result;
5341 PyObject * obj0 = 0 ;
5342 char *kwnames[] = {
5343 (char *) "self", NULL
5344 };
5345
5346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5348 if (SWIG_arg_fail(1)) SWIG_fail;
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 result = (bool)((wxRect const *)arg1)->IsEmpty();
5352
5353 wxPyEndAllowThreads(__tstate);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 {
5357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5358 }
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5366 PyObject *resultobj;
5367 wxRect *arg1 = (wxRect *) 0 ;
5368 wxPoint result;
5369 PyObject * obj0 = 0 ;
5370 char *kwnames[] = {
5371 (char *) "self", NULL
5372 };
5373
5374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5376 if (SWIG_arg_fail(1)) SWIG_fail;
5377 {
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 result = ((wxRect const *)arg1)->GetTopLeft();
5380
5381 wxPyEndAllowThreads(__tstate);
5382 if (PyErr_Occurred()) SWIG_fail;
5383 }
5384 {
5385 wxPoint * resultptr;
5386 resultptr = new wxPoint((wxPoint &)(result));
5387 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5388 }
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5396 PyObject *resultobj;
5397 wxRect *arg1 = (wxRect *) 0 ;
5398 wxPoint *arg2 = 0 ;
5399 wxPoint temp2 ;
5400 PyObject * obj0 = 0 ;
5401 PyObject * obj1 = 0 ;
5402 char *kwnames[] = {
5403 (char *) "self",(char *) "p", NULL
5404 };
5405
5406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5408 if (SWIG_arg_fail(1)) SWIG_fail;
5409 {
5410 arg2 = &temp2;
5411 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5412 }
5413 {
5414 PyThreadState* __tstate = wxPyBeginAllowThreads();
5415 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5416
5417 wxPyEndAllowThreads(__tstate);
5418 if (PyErr_Occurred()) SWIG_fail;
5419 }
5420 Py_INCREF(Py_None); resultobj = Py_None;
5421 return resultobj;
5422 fail:
5423 return NULL;
5424 }
5425
5426
5427 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5428 PyObject *resultobj;
5429 wxRect *arg1 = (wxRect *) 0 ;
5430 wxPoint result;
5431 PyObject * obj0 = 0 ;
5432 char *kwnames[] = {
5433 (char *) "self", NULL
5434 };
5435
5436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5438 if (SWIG_arg_fail(1)) SWIG_fail;
5439 {
5440 PyThreadState* __tstate = wxPyBeginAllowThreads();
5441 result = ((wxRect const *)arg1)->GetBottomRight();
5442
5443 wxPyEndAllowThreads(__tstate);
5444 if (PyErr_Occurred()) SWIG_fail;
5445 }
5446 {
5447 wxPoint * resultptr;
5448 resultptr = new wxPoint((wxPoint &)(result));
5449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5450 }
5451 return resultobj;
5452 fail:
5453 return NULL;
5454 }
5455
5456
5457 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5458 PyObject *resultobj;
5459 wxRect *arg1 = (wxRect *) 0 ;
5460 wxPoint *arg2 = 0 ;
5461 wxPoint temp2 ;
5462 PyObject * obj0 = 0 ;
5463 PyObject * obj1 = 0 ;
5464 char *kwnames[] = {
5465 (char *) "self",(char *) "p", NULL
5466 };
5467
5468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5470 if (SWIG_arg_fail(1)) SWIG_fail;
5471 {
5472 arg2 = &temp2;
5473 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5474 }
5475 {
5476 PyThreadState* __tstate = wxPyBeginAllowThreads();
5477 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5478
5479 wxPyEndAllowThreads(__tstate);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 Py_INCREF(Py_None); resultobj = Py_None;
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5490 PyObject *resultobj;
5491 wxRect *arg1 = (wxRect *) 0 ;
5492 int result;
5493 PyObject * obj0 = 0 ;
5494 char *kwnames[] = {
5495 (char *) "self", NULL
5496 };
5497
5498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5500 if (SWIG_arg_fail(1)) SWIG_fail;
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = (int)((wxRect const *)arg1)->GetLeft();
5504
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 {
5509 resultobj = SWIG_From_int((int)(result));
5510 }
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj;
5519 wxRect *arg1 = (wxRect *) 0 ;
5520 int result;
5521 PyObject * obj0 = 0 ;
5522 char *kwnames[] = {
5523 (char *) "self", NULL
5524 };
5525
5526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5528 if (SWIG_arg_fail(1)) SWIG_fail;
5529 {
5530 PyThreadState* __tstate = wxPyBeginAllowThreads();
5531 result = (int)((wxRect const *)arg1)->GetTop();
5532
5533 wxPyEndAllowThreads(__tstate);
5534 if (PyErr_Occurred()) SWIG_fail;
5535 }
5536 {
5537 resultobj = SWIG_From_int((int)(result));
5538 }
5539 return resultobj;
5540 fail:
5541 return NULL;
5542 }
5543
5544
5545 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5546 PyObject *resultobj;
5547 wxRect *arg1 = (wxRect *) 0 ;
5548 int result;
5549 PyObject * obj0 = 0 ;
5550 char *kwnames[] = {
5551 (char *) "self", NULL
5552 };
5553
5554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5556 if (SWIG_arg_fail(1)) SWIG_fail;
5557 {
5558 PyThreadState* __tstate = wxPyBeginAllowThreads();
5559 result = (int)((wxRect const *)arg1)->GetBottom();
5560
5561 wxPyEndAllowThreads(__tstate);
5562 if (PyErr_Occurred()) SWIG_fail;
5563 }
5564 {
5565 resultobj = SWIG_From_int((int)(result));
5566 }
5567 return resultobj;
5568 fail:
5569 return NULL;
5570 }
5571
5572
5573 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5574 PyObject *resultobj;
5575 wxRect *arg1 = (wxRect *) 0 ;
5576 int result;
5577 PyObject * obj0 = 0 ;
5578 char *kwnames[] = {
5579 (char *) "self", NULL
5580 };
5581
5582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5584 if (SWIG_arg_fail(1)) SWIG_fail;
5585 {
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 result = (int)((wxRect const *)arg1)->GetRight();
5588
5589 wxPyEndAllowThreads(__tstate);
5590 if (PyErr_Occurred()) SWIG_fail;
5591 }
5592 {
5593 resultobj = SWIG_From_int((int)(result));
5594 }
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj;
5603 wxRect *arg1 = (wxRect *) 0 ;
5604 int arg2 ;
5605 PyObject * obj0 = 0 ;
5606 PyObject * obj1 = 0 ;
5607 char *kwnames[] = {
5608 (char *) "self",(char *) "left", NULL
5609 };
5610
5611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5613 if (SWIG_arg_fail(1)) SWIG_fail;
5614 {
5615 arg2 = (int)(SWIG_As_int(obj1));
5616 if (SWIG_arg_fail(2)) SWIG_fail;
5617 }
5618 {
5619 PyThreadState* __tstate = wxPyBeginAllowThreads();
5620 (arg1)->SetLeft(arg2);
5621
5622 wxPyEndAllowThreads(__tstate);
5623 if (PyErr_Occurred()) SWIG_fail;
5624 }
5625 Py_INCREF(Py_None); resultobj = Py_None;
5626 return resultobj;
5627 fail:
5628 return NULL;
5629 }
5630
5631
5632 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5633 PyObject *resultobj;
5634 wxRect *arg1 = (wxRect *) 0 ;
5635 int arg2 ;
5636 PyObject * obj0 = 0 ;
5637 PyObject * obj1 = 0 ;
5638 char *kwnames[] = {
5639 (char *) "self",(char *) "right", NULL
5640 };
5641
5642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5644 if (SWIG_arg_fail(1)) SWIG_fail;
5645 {
5646 arg2 = (int)(SWIG_As_int(obj1));
5647 if (SWIG_arg_fail(2)) SWIG_fail;
5648 }
5649 {
5650 PyThreadState* __tstate = wxPyBeginAllowThreads();
5651 (arg1)->SetRight(arg2);
5652
5653 wxPyEndAllowThreads(__tstate);
5654 if (PyErr_Occurred()) SWIG_fail;
5655 }
5656 Py_INCREF(Py_None); resultobj = Py_None;
5657 return resultobj;
5658 fail:
5659 return NULL;
5660 }
5661
5662
5663 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5664 PyObject *resultobj;
5665 wxRect *arg1 = (wxRect *) 0 ;
5666 int arg2 ;
5667 PyObject * obj0 = 0 ;
5668 PyObject * obj1 = 0 ;
5669 char *kwnames[] = {
5670 (char *) "self",(char *) "top", NULL
5671 };
5672
5673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5675 if (SWIG_arg_fail(1)) SWIG_fail;
5676 {
5677 arg2 = (int)(SWIG_As_int(obj1));
5678 if (SWIG_arg_fail(2)) SWIG_fail;
5679 }
5680 {
5681 PyThreadState* __tstate = wxPyBeginAllowThreads();
5682 (arg1)->SetTop(arg2);
5683
5684 wxPyEndAllowThreads(__tstate);
5685 if (PyErr_Occurred()) SWIG_fail;
5686 }
5687 Py_INCREF(Py_None); resultobj = Py_None;
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj;
5696 wxRect *arg1 = (wxRect *) 0 ;
5697 int arg2 ;
5698 PyObject * obj0 = 0 ;
5699 PyObject * obj1 = 0 ;
5700 char *kwnames[] = {
5701 (char *) "self",(char *) "bottom", NULL
5702 };
5703
5704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5706 if (SWIG_arg_fail(1)) SWIG_fail;
5707 {
5708 arg2 = (int)(SWIG_As_int(obj1));
5709 if (SWIG_arg_fail(2)) SWIG_fail;
5710 }
5711 {
5712 PyThreadState* __tstate = wxPyBeginAllowThreads();
5713 (arg1)->SetBottom(arg2);
5714
5715 wxPyEndAllowThreads(__tstate);
5716 if (PyErr_Occurred()) SWIG_fail;
5717 }
5718 Py_INCREF(Py_None); resultobj = Py_None;
5719 return resultobj;
5720 fail:
5721 return NULL;
5722 }
5723
5724
5725 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5726 PyObject *resultobj;
5727 wxRect *arg1 = (wxRect *) 0 ;
5728 int arg2 ;
5729 int arg3 ;
5730 wxRect *result;
5731 PyObject * obj0 = 0 ;
5732 PyObject * obj1 = 0 ;
5733 PyObject * obj2 = 0 ;
5734 char *kwnames[] = {
5735 (char *) "self",(char *) "dx",(char *) "dy", NULL
5736 };
5737
5738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5740 if (SWIG_arg_fail(1)) SWIG_fail;
5741 {
5742 arg2 = (int)(SWIG_As_int(obj1));
5743 if (SWIG_arg_fail(2)) SWIG_fail;
5744 }
5745 {
5746 arg3 = (int)(SWIG_As_int(obj2));
5747 if (SWIG_arg_fail(3)) SWIG_fail;
5748 }
5749 {
5750 PyThreadState* __tstate = wxPyBeginAllowThreads();
5751 {
5752 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5753 result = (wxRect *) &_result_ref;
5754 }
5755
5756 wxPyEndAllowThreads(__tstate);
5757 if (PyErr_Occurred()) SWIG_fail;
5758 }
5759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5760 return resultobj;
5761 fail:
5762 return NULL;
5763 }
5764
5765
5766 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5767 PyObject *resultobj;
5768 wxRect *arg1 = (wxRect *) 0 ;
5769 int arg2 ;
5770 int arg3 ;
5771 wxRect *result;
5772 PyObject * obj0 = 0 ;
5773 PyObject * obj1 = 0 ;
5774 PyObject * obj2 = 0 ;
5775 char *kwnames[] = {
5776 (char *) "self",(char *) "dx",(char *) "dy", NULL
5777 };
5778
5779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5781 if (SWIG_arg_fail(1)) SWIG_fail;
5782 {
5783 arg2 = (int)(SWIG_As_int(obj1));
5784 if (SWIG_arg_fail(2)) SWIG_fail;
5785 }
5786 {
5787 arg3 = (int)(SWIG_As_int(obj2));
5788 if (SWIG_arg_fail(3)) SWIG_fail;
5789 }
5790 {
5791 PyThreadState* __tstate = wxPyBeginAllowThreads();
5792 {
5793 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5794 result = (wxRect *) &_result_ref;
5795 }
5796
5797 wxPyEndAllowThreads(__tstate);
5798 if (PyErr_Occurred()) SWIG_fail;
5799 }
5800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5808 PyObject *resultobj;
5809 wxRect *arg1 = (wxRect *) 0 ;
5810 int arg2 ;
5811 int arg3 ;
5812 PyObject * obj0 = 0 ;
5813 PyObject * obj1 = 0 ;
5814 PyObject * obj2 = 0 ;
5815 char *kwnames[] = {
5816 (char *) "self",(char *) "dx",(char *) "dy", NULL
5817 };
5818
5819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5821 if (SWIG_arg_fail(1)) SWIG_fail;
5822 {
5823 arg2 = (int)(SWIG_As_int(obj1));
5824 if (SWIG_arg_fail(2)) SWIG_fail;
5825 }
5826 {
5827 arg3 = (int)(SWIG_As_int(obj2));
5828 if (SWIG_arg_fail(3)) SWIG_fail;
5829 }
5830 {
5831 PyThreadState* __tstate = wxPyBeginAllowThreads();
5832 (arg1)->Offset(arg2,arg3);
5833
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 Py_INCREF(Py_None); resultobj = Py_None;
5838 return resultobj;
5839 fail:
5840 return NULL;
5841 }
5842
5843
5844 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5845 PyObject *resultobj;
5846 wxRect *arg1 = (wxRect *) 0 ;
5847 wxPoint *arg2 = 0 ;
5848 wxPoint temp2 ;
5849 PyObject * obj0 = 0 ;
5850 PyObject * obj1 = 0 ;
5851 char *kwnames[] = {
5852 (char *) "self",(char *) "pt", NULL
5853 };
5854
5855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5857 if (SWIG_arg_fail(1)) SWIG_fail;
5858 {
5859 arg2 = &temp2;
5860 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5861 }
5862 {
5863 PyThreadState* __tstate = wxPyBeginAllowThreads();
5864 (arg1)->Offset((wxPoint const &)*arg2);
5865
5866 wxPyEndAllowThreads(__tstate);
5867 if (PyErr_Occurred()) SWIG_fail;
5868 }
5869 Py_INCREF(Py_None); resultobj = Py_None;
5870 return resultobj;
5871 fail:
5872 return NULL;
5873 }
5874
5875
5876 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5877 PyObject *resultobj;
5878 wxRect *arg1 = (wxRect *) 0 ;
5879 wxRect *arg2 = 0 ;
5880 wxRect result;
5881 wxRect temp2 ;
5882 PyObject * obj0 = 0 ;
5883 PyObject * obj1 = 0 ;
5884 char *kwnames[] = {
5885 (char *) "self",(char *) "rect", NULL
5886 };
5887
5888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5890 if (SWIG_arg_fail(1)) SWIG_fail;
5891 {
5892 arg2 = &temp2;
5893 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5894 }
5895 {
5896 PyThreadState* __tstate = wxPyBeginAllowThreads();
5897 result = (arg1)->Intersect((wxRect const &)*arg2);
5898
5899 wxPyEndAllowThreads(__tstate);
5900 if (PyErr_Occurred()) SWIG_fail;
5901 }
5902 {
5903 wxRect * resultptr;
5904 resultptr = new wxRect((wxRect &)(result));
5905 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5906 }
5907 return resultobj;
5908 fail:
5909 return NULL;
5910 }
5911
5912
5913 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5914 PyObject *resultobj;
5915 wxRect *arg1 = (wxRect *) 0 ;
5916 wxRect *arg2 = 0 ;
5917 wxRect result;
5918 wxRect temp2 ;
5919 PyObject * obj0 = 0 ;
5920 PyObject * obj1 = 0 ;
5921 char *kwnames[] = {
5922 (char *) "self",(char *) "rect", NULL
5923 };
5924
5925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5927 if (SWIG_arg_fail(1)) SWIG_fail;
5928 {
5929 arg2 = &temp2;
5930 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5931 }
5932 {
5933 PyThreadState* __tstate = wxPyBeginAllowThreads();
5934 result = (arg1)->Union((wxRect const &)*arg2);
5935
5936 wxPyEndAllowThreads(__tstate);
5937 if (PyErr_Occurred()) SWIG_fail;
5938 }
5939 {
5940 wxRect * resultptr;
5941 resultptr = new wxRect((wxRect &)(result));
5942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5943 }
5944 return resultobj;
5945 fail:
5946 return NULL;
5947 }
5948
5949
5950 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5951 PyObject *resultobj;
5952 wxRect *arg1 = (wxRect *) 0 ;
5953 wxRect *arg2 = 0 ;
5954 wxRect result;
5955 wxRect temp2 ;
5956 PyObject * obj0 = 0 ;
5957 PyObject * obj1 = 0 ;
5958 char *kwnames[] = {
5959 (char *) "self",(char *) "rect", NULL
5960 };
5961
5962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5964 if (SWIG_arg_fail(1)) SWIG_fail;
5965 {
5966 arg2 = &temp2;
5967 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5968 }
5969 {
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5972
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 {
5977 wxRect * resultptr;
5978 resultptr = new wxRect((wxRect &)(result));
5979 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5980 }
5981 return resultobj;
5982 fail:
5983 return NULL;
5984 }
5985
5986
5987 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5988 PyObject *resultobj;
5989 wxRect *arg1 = (wxRect *) 0 ;
5990 wxRect *arg2 = 0 ;
5991 wxRect *result;
5992 wxRect temp2 ;
5993 PyObject * obj0 = 0 ;
5994 PyObject * obj1 = 0 ;
5995 char *kwnames[] = {
5996 (char *) "self",(char *) "rect", NULL
5997 };
5998
5999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6001 if (SWIG_arg_fail(1)) SWIG_fail;
6002 {
6003 arg2 = &temp2;
6004 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6005 }
6006 {
6007 PyThreadState* __tstate = wxPyBeginAllowThreads();
6008 {
6009 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6010 result = (wxRect *) &_result_ref;
6011 }
6012
6013 wxPyEndAllowThreads(__tstate);
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj;
6025 wxRect *arg1 = (wxRect *) 0 ;
6026 wxRect *arg2 = 0 ;
6027 bool result;
6028 wxRect temp2 ;
6029 PyObject * obj0 = 0 ;
6030 PyObject * obj1 = 0 ;
6031 char *kwnames[] = {
6032 (char *) "self",(char *) "rect", NULL
6033 };
6034
6035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6037 if (SWIG_arg_fail(1)) SWIG_fail;
6038 {
6039 arg2 = &temp2;
6040 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6041 }
6042 {
6043 PyThreadState* __tstate = wxPyBeginAllowThreads();
6044 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6045
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 {
6050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6051 }
6052 return resultobj;
6053 fail:
6054 return NULL;
6055 }
6056
6057
6058 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6059 PyObject *resultobj;
6060 wxRect *arg1 = (wxRect *) 0 ;
6061 wxRect *arg2 = 0 ;
6062 bool result;
6063 wxRect temp2 ;
6064 PyObject * obj0 = 0 ;
6065 PyObject * obj1 = 0 ;
6066 char *kwnames[] = {
6067 (char *) "self",(char *) "rect", NULL
6068 };
6069
6070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6072 if (SWIG_arg_fail(1)) SWIG_fail;
6073 {
6074 arg2 = &temp2;
6075 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6076 }
6077 {
6078 PyThreadState* __tstate = wxPyBeginAllowThreads();
6079 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6080
6081 wxPyEndAllowThreads(__tstate);
6082 if (PyErr_Occurred()) SWIG_fail;
6083 }
6084 {
6085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6086 }
6087 return resultobj;
6088 fail:
6089 return NULL;
6090 }
6091
6092
6093 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6094 PyObject *resultobj;
6095 wxRect *arg1 = (wxRect *) 0 ;
6096 int arg2 ;
6097 int arg3 ;
6098 bool result;
6099 PyObject * obj0 = 0 ;
6100 PyObject * obj1 = 0 ;
6101 PyObject * obj2 = 0 ;
6102 char *kwnames[] = {
6103 (char *) "self",(char *) "x",(char *) "y", NULL
6104 };
6105
6106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6108 if (SWIG_arg_fail(1)) SWIG_fail;
6109 {
6110 arg2 = (int)(SWIG_As_int(obj1));
6111 if (SWIG_arg_fail(2)) SWIG_fail;
6112 }
6113 {
6114 arg3 = (int)(SWIG_As_int(obj2));
6115 if (SWIG_arg_fail(3)) SWIG_fail;
6116 }
6117 {
6118 PyThreadState* __tstate = wxPyBeginAllowThreads();
6119 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6120
6121 wxPyEndAllowThreads(__tstate);
6122 if (PyErr_Occurred()) SWIG_fail;
6123 }
6124 {
6125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6126 }
6127 return resultobj;
6128 fail:
6129 return NULL;
6130 }
6131
6132
6133 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6134 PyObject *resultobj;
6135 wxRect *arg1 = (wxRect *) 0 ;
6136 wxPoint *arg2 = 0 ;
6137 bool result;
6138 wxPoint temp2 ;
6139 PyObject * obj0 = 0 ;
6140 PyObject * obj1 = 0 ;
6141 char *kwnames[] = {
6142 (char *) "self",(char *) "pt", NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6147 if (SWIG_arg_fail(1)) SWIG_fail;
6148 {
6149 arg2 = &temp2;
6150 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6151 }
6152 {
6153 PyThreadState* __tstate = wxPyBeginAllowThreads();
6154 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6155
6156 wxPyEndAllowThreads(__tstate);
6157 if (PyErr_Occurred()) SWIG_fail;
6158 }
6159 {
6160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6161 }
6162 return resultobj;
6163 fail:
6164 return NULL;
6165 }
6166
6167
6168 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj;
6170 wxRect *arg1 = (wxRect *) 0 ;
6171 wxRect *arg2 = 0 ;
6172 bool result;
6173 wxRect temp2 ;
6174 PyObject * obj0 = 0 ;
6175 PyObject * obj1 = 0 ;
6176 char *kwnames[] = {
6177 (char *) "self",(char *) "rect", NULL
6178 };
6179
6180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6182 if (SWIG_arg_fail(1)) SWIG_fail;
6183 {
6184 arg2 = &temp2;
6185 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6186 }
6187 {
6188 PyThreadState* __tstate = wxPyBeginAllowThreads();
6189 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6190
6191 wxPyEndAllowThreads(__tstate);
6192 if (PyErr_Occurred()) SWIG_fail;
6193 }
6194 {
6195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6196 }
6197 return resultobj;
6198 fail:
6199 return NULL;
6200 }
6201
6202
6203 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj;
6205 wxRect *arg1 = (wxRect *) 0 ;
6206 int arg2 ;
6207 PyObject * obj0 = 0 ;
6208 PyObject * obj1 = 0 ;
6209 char *kwnames[] = {
6210 (char *) "self",(char *) "x", NULL
6211 };
6212
6213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6215 if (SWIG_arg_fail(1)) SWIG_fail;
6216 {
6217 arg2 = (int)(SWIG_As_int(obj1));
6218 if (SWIG_arg_fail(2)) SWIG_fail;
6219 }
6220 if (arg1) (arg1)->x = arg2;
6221
6222 Py_INCREF(Py_None); resultobj = Py_None;
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6230 PyObject *resultobj;
6231 wxRect *arg1 = (wxRect *) 0 ;
6232 int result;
6233 PyObject * obj0 = 0 ;
6234 char *kwnames[] = {
6235 (char *) "self", NULL
6236 };
6237
6238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6240 if (SWIG_arg_fail(1)) SWIG_fail;
6241 result = (int) ((arg1)->x);
6242
6243 {
6244 resultobj = SWIG_From_int((int)(result));
6245 }
6246 return resultobj;
6247 fail:
6248 return NULL;
6249 }
6250
6251
6252 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6253 PyObject *resultobj;
6254 wxRect *arg1 = (wxRect *) 0 ;
6255 int arg2 ;
6256 PyObject * obj0 = 0 ;
6257 PyObject * obj1 = 0 ;
6258 char *kwnames[] = {
6259 (char *) "self",(char *) "y", NULL
6260 };
6261
6262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6264 if (SWIG_arg_fail(1)) SWIG_fail;
6265 {
6266 arg2 = (int)(SWIG_As_int(obj1));
6267 if (SWIG_arg_fail(2)) SWIG_fail;
6268 }
6269 if (arg1) (arg1)->y = arg2;
6270
6271 Py_INCREF(Py_None); resultobj = Py_None;
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int result;
6282 PyObject * obj0 = 0 ;
6283 char *kwnames[] = {
6284 (char *) "self", NULL
6285 };
6286
6287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6289 if (SWIG_arg_fail(1)) SWIG_fail;
6290 result = (int) ((arg1)->y);
6291
6292 {
6293 resultobj = SWIG_From_int((int)(result));
6294 }
6295 return resultobj;
6296 fail:
6297 return NULL;
6298 }
6299
6300
6301 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6302 PyObject *resultobj;
6303 wxRect *arg1 = (wxRect *) 0 ;
6304 int arg2 ;
6305 PyObject * obj0 = 0 ;
6306 PyObject * obj1 = 0 ;
6307 char *kwnames[] = {
6308 (char *) "self",(char *) "width", NULL
6309 };
6310
6311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6313 if (SWIG_arg_fail(1)) SWIG_fail;
6314 {
6315 arg2 = (int)(SWIG_As_int(obj1));
6316 if (SWIG_arg_fail(2)) SWIG_fail;
6317 }
6318 if (arg1) (arg1)->width = arg2;
6319
6320 Py_INCREF(Py_None); resultobj = Py_None;
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6328 PyObject *resultobj;
6329 wxRect *arg1 = (wxRect *) 0 ;
6330 int result;
6331 PyObject * obj0 = 0 ;
6332 char *kwnames[] = {
6333 (char *) "self", NULL
6334 };
6335
6336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6338 if (SWIG_arg_fail(1)) SWIG_fail;
6339 result = (int) ((arg1)->width);
6340
6341 {
6342 resultobj = SWIG_From_int((int)(result));
6343 }
6344 return resultobj;
6345 fail:
6346 return NULL;
6347 }
6348
6349
6350 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6351 PyObject *resultobj;
6352 wxRect *arg1 = (wxRect *) 0 ;
6353 int arg2 ;
6354 PyObject * obj0 = 0 ;
6355 PyObject * obj1 = 0 ;
6356 char *kwnames[] = {
6357 (char *) "self",(char *) "height", NULL
6358 };
6359
6360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6362 if (SWIG_arg_fail(1)) SWIG_fail;
6363 {
6364 arg2 = (int)(SWIG_As_int(obj1));
6365 if (SWIG_arg_fail(2)) SWIG_fail;
6366 }
6367 if (arg1) (arg1)->height = arg2;
6368
6369 Py_INCREF(Py_None); resultobj = Py_None;
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxRect *arg1 = (wxRect *) 0 ;
6379 int result;
6380 PyObject * obj0 = 0 ;
6381 char *kwnames[] = {
6382 (char *) "self", NULL
6383 };
6384
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(1)) SWIG_fail;
6388 result = (int) ((arg1)->height);
6389
6390 {
6391 resultobj = SWIG_From_int((int)(result));
6392 }
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj;
6401 wxRect *arg1 = (wxRect *) 0 ;
6402 int arg2 = (int) 0 ;
6403 int arg3 = (int) 0 ;
6404 int arg4 = (int) 0 ;
6405 int arg5 = (int) 0 ;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 PyObject * obj2 = 0 ;
6409 PyObject * obj3 = 0 ;
6410 PyObject * obj4 = 0 ;
6411 char *kwnames[] = {
6412 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6413 };
6414
6415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6417 if (SWIG_arg_fail(1)) SWIG_fail;
6418 if (obj1) {
6419 {
6420 arg2 = (int)(SWIG_As_int(obj1));
6421 if (SWIG_arg_fail(2)) SWIG_fail;
6422 }
6423 }
6424 if (obj2) {
6425 {
6426 arg3 = (int)(SWIG_As_int(obj2));
6427 if (SWIG_arg_fail(3)) SWIG_fail;
6428 }
6429 }
6430 if (obj3) {
6431 {
6432 arg4 = (int)(SWIG_As_int(obj3));
6433 if (SWIG_arg_fail(4)) SWIG_fail;
6434 }
6435 }
6436 if (obj4) {
6437 {
6438 arg5 = (int)(SWIG_As_int(obj4));
6439 if (SWIG_arg_fail(5)) SWIG_fail;
6440 }
6441 }
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6445
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 Py_INCREF(Py_None); resultobj = Py_None;
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj;
6458 wxRect *arg1 = (wxRect *) 0 ;
6459 PyObject *result;
6460 PyObject * obj0 = 0 ;
6461 char *kwnames[] = {
6462 (char *) "self", NULL
6463 };
6464
6465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6467 if (SWIG_arg_fail(1)) SWIG_fail;
6468 {
6469 PyThreadState* __tstate = wxPyBeginAllowThreads();
6470 result = (PyObject *)wxRect_Get(arg1);
6471
6472 wxPyEndAllowThreads(__tstate);
6473 if (PyErr_Occurred()) SWIG_fail;
6474 }
6475 resultobj = result;
6476 return resultobj;
6477 fail:
6478 return NULL;
6479 }
6480
6481
6482 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6483 PyObject *obj;
6484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6485 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6486 Py_INCREF(obj);
6487 return Py_BuildValue((char *)"");
6488 }
6489 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6490 PyObject *resultobj;
6491 wxRect *arg1 = (wxRect *) 0 ;
6492 wxRect *arg2 = (wxRect *) 0 ;
6493 PyObject *result;
6494 PyObject * obj0 = 0 ;
6495 PyObject * obj1 = 0 ;
6496 char *kwnames[] = {
6497 (char *) "r1",(char *) "r2", NULL
6498 };
6499
6500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6502 if (SWIG_arg_fail(1)) SWIG_fail;
6503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6504 if (SWIG_arg_fail(2)) SWIG_fail;
6505 {
6506 if (!wxPyCheckForApp()) SWIG_fail;
6507 PyThreadState* __tstate = wxPyBeginAllowThreads();
6508 result = (PyObject *)wxIntersectRect(arg1,arg2);
6509
6510 wxPyEndAllowThreads(__tstate);
6511 if (PyErr_Occurred()) SWIG_fail;
6512 }
6513 resultobj = result;
6514 return resultobj;
6515 fail:
6516 return NULL;
6517 }
6518
6519
6520 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6521 PyObject *resultobj;
6522 double arg1 = (double) 0.0 ;
6523 double arg2 = (double) 0.0 ;
6524 wxPoint2D *result;
6525 PyObject * obj0 = 0 ;
6526 PyObject * obj1 = 0 ;
6527 char *kwnames[] = {
6528 (char *) "x",(char *) "y", NULL
6529 };
6530
6531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6532 if (obj0) {
6533 {
6534 arg1 = (double)(SWIG_As_double(obj0));
6535 if (SWIG_arg_fail(1)) SWIG_fail;
6536 }
6537 }
6538 if (obj1) {
6539 {
6540 arg2 = (double)(SWIG_As_double(obj1));
6541 if (SWIG_arg_fail(2)) SWIG_fail;
6542 }
6543 }
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6547
6548 wxPyEndAllowThreads(__tstate);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6559 PyObject *resultobj;
6560 wxPoint2D *arg1 = 0 ;
6561 wxPoint2D *result;
6562 wxPoint2D temp1 ;
6563 PyObject * obj0 = 0 ;
6564 char *kwnames[] = {
6565 (char *) "pt", NULL
6566 };
6567
6568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6569 {
6570 arg1 = &temp1;
6571 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6572 }
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6588 PyObject *resultobj;
6589 wxPoint *arg1 = 0 ;
6590 wxPoint2D *result;
6591 wxPoint temp1 ;
6592 PyObject * obj0 = 0 ;
6593 char *kwnames[] = {
6594 (char *) "pt", NULL
6595 };
6596
6597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6598 {
6599 arg1 = &temp1;
6600 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6601 }
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6605
6606 wxPyEndAllowThreads(__tstate);
6607 if (PyErr_Occurred()) SWIG_fail;
6608 }
6609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6610 return resultobj;
6611 fail:
6612 return NULL;
6613 }
6614
6615
6616 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6617 PyObject *resultobj;
6618 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6619 int *arg2 = (int *) 0 ;
6620 int *arg3 = (int *) 0 ;
6621 int temp2 ;
6622 int res2 = 0 ;
6623 int temp3 ;
6624 int res3 = 0 ;
6625 PyObject * obj0 = 0 ;
6626 char *kwnames[] = {
6627 (char *) "self", NULL
6628 };
6629
6630 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6631 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6634 if (SWIG_arg_fail(1)) SWIG_fail;
6635 {
6636 PyThreadState* __tstate = wxPyBeginAllowThreads();
6637 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6638
6639 wxPyEndAllowThreads(__tstate);
6640 if (PyErr_Occurred()) SWIG_fail;
6641 }
6642 Py_INCREF(Py_None); resultobj = Py_None;
6643 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6644 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6645 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6646 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6647 return resultobj;
6648 fail:
6649 return NULL;
6650 }
6651
6652
6653 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6654 PyObject *resultobj;
6655 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6656 int *arg2 = (int *) 0 ;
6657 int *arg3 = (int *) 0 ;
6658 int temp2 ;
6659 int res2 = 0 ;
6660 int temp3 ;
6661 int res3 = 0 ;
6662 PyObject * obj0 = 0 ;
6663 char *kwnames[] = {
6664 (char *) "self", NULL
6665 };
6666
6667 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6668 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6671 if (SWIG_arg_fail(1)) SWIG_fail;
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6675
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 Py_INCREF(Py_None); resultobj = Py_None;
6680 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6681 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6682 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6683 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6684 return resultobj;
6685 fail:
6686 return NULL;
6687 }
6688
6689
6690 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6691 PyObject *resultobj;
6692 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6693 double result;
6694 PyObject * obj0 = 0 ;
6695 char *kwnames[] = {
6696 (char *) "self", NULL
6697 };
6698
6699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6701 if (SWIG_arg_fail(1)) SWIG_fail;
6702 {
6703 PyThreadState* __tstate = wxPyBeginAllowThreads();
6704 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6705
6706 wxPyEndAllowThreads(__tstate);
6707 if (PyErr_Occurred()) SWIG_fail;
6708 }
6709 {
6710 resultobj = SWIG_From_double((double)(result));
6711 }
6712 return resultobj;
6713 fail:
6714 return NULL;
6715 }
6716
6717
6718 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6719 PyObject *resultobj;
6720 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6721 double result;
6722 PyObject * obj0 = 0 ;
6723 char *kwnames[] = {
6724 (char *) "self", NULL
6725 };
6726
6727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6729 if (SWIG_arg_fail(1)) SWIG_fail;
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6733
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 {
6738 resultobj = SWIG_From_double((double)(result));
6739 }
6740 return resultobj;
6741 fail:
6742 return NULL;
6743 }
6744
6745
6746 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6747 PyObject *resultobj;
6748 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6749 double arg2 ;
6750 PyObject * obj0 = 0 ;
6751 PyObject * obj1 = 0 ;
6752 char *kwnames[] = {
6753 (char *) "self",(char *) "length", NULL
6754 };
6755
6756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6758 if (SWIG_arg_fail(1)) SWIG_fail;
6759 {
6760 arg2 = (double)(SWIG_As_double(obj1));
6761 if (SWIG_arg_fail(2)) SWIG_fail;
6762 }
6763 {
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 (arg1)->SetVectorLength(arg2);
6766
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 Py_INCREF(Py_None); resultobj = Py_None;
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6778 PyObject *resultobj;
6779 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6780 double arg2 ;
6781 PyObject * obj0 = 0 ;
6782 PyObject * obj1 = 0 ;
6783 char *kwnames[] = {
6784 (char *) "self",(char *) "degrees", NULL
6785 };
6786
6787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6789 if (SWIG_arg_fail(1)) SWIG_fail;
6790 {
6791 arg2 = (double)(SWIG_As_double(obj1));
6792 if (SWIG_arg_fail(2)) SWIG_fail;
6793 }
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 (arg1)->SetVectorAngle(arg2);
6797
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 Py_INCREF(Py_None); resultobj = Py_None;
6802 return resultobj;
6803 fail:
6804 return NULL;
6805 }
6806
6807
6808 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6809 PyObject *resultobj;
6810 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6811 wxPoint2D *arg2 = 0 ;
6812 double result;
6813 wxPoint2D temp2 ;
6814 PyObject * obj0 = 0 ;
6815 PyObject * obj1 = 0 ;
6816 char *kwnames[] = {
6817 (char *) "self",(char *) "pt", NULL
6818 };
6819
6820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6822 if (SWIG_arg_fail(1)) SWIG_fail;
6823 {
6824 arg2 = &temp2;
6825 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6826 }
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6830
6831 wxPyEndAllowThreads(__tstate);
6832 if (PyErr_Occurred()) SWIG_fail;
6833 }
6834 {
6835 resultobj = SWIG_From_double((double)(result));
6836 }
6837 return resultobj;
6838 fail:
6839 return NULL;
6840 }
6841
6842
6843 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6844 PyObject *resultobj;
6845 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6846 wxPoint2D *arg2 = 0 ;
6847 double result;
6848 wxPoint2D temp2 ;
6849 PyObject * obj0 = 0 ;
6850 PyObject * obj1 = 0 ;
6851 char *kwnames[] = {
6852 (char *) "self",(char *) "pt", NULL
6853 };
6854
6855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6857 if (SWIG_arg_fail(1)) SWIG_fail;
6858 {
6859 arg2 = &temp2;
6860 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6861 }
6862 {
6863 PyThreadState* __tstate = wxPyBeginAllowThreads();
6864 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6865
6866 wxPyEndAllowThreads(__tstate);
6867 if (PyErr_Occurred()) SWIG_fail;
6868 }
6869 {
6870 resultobj = SWIG_From_double((double)(result));
6871 }
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6879 PyObject *resultobj;
6880 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6881 wxPoint2D *arg2 = 0 ;
6882 double result;
6883 wxPoint2D temp2 ;
6884 PyObject * obj0 = 0 ;
6885 PyObject * obj1 = 0 ;
6886 char *kwnames[] = {
6887 (char *) "self",(char *) "vec", NULL
6888 };
6889
6890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6892 if (SWIG_arg_fail(1)) SWIG_fail;
6893 {
6894 arg2 = &temp2;
6895 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6896 }
6897 {
6898 PyThreadState* __tstate = wxPyBeginAllowThreads();
6899 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6900
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 {
6905 resultobj = SWIG_From_double((double)(result));
6906 }
6907 return resultobj;
6908 fail:
6909 return NULL;
6910 }
6911
6912
6913 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6914 PyObject *resultobj;
6915 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6916 wxPoint2D *arg2 = 0 ;
6917 double result;
6918 wxPoint2D temp2 ;
6919 PyObject * obj0 = 0 ;
6920 PyObject * obj1 = 0 ;
6921 char *kwnames[] = {
6922 (char *) "self",(char *) "vec", NULL
6923 };
6924
6925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6927 if (SWIG_arg_fail(1)) SWIG_fail;
6928 {
6929 arg2 = &temp2;
6930 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6931 }
6932 {
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6935
6936 wxPyEndAllowThreads(__tstate);
6937 if (PyErr_Occurred()) SWIG_fail;
6938 }
6939 {
6940 resultobj = SWIG_From_double((double)(result));
6941 }
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj;
6950 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6951 wxPoint2D result;
6952 PyObject * obj0 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6959 if (SWIG_arg_fail(1)) SWIG_fail;
6960 {
6961 PyThreadState* __tstate = wxPyBeginAllowThreads();
6962 result = (arg1)->operator -();
6963
6964 wxPyEndAllowThreads(__tstate);
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 {
6968 wxPoint2D * resultptr;
6969 resultptr = new wxPoint2D((wxPoint2D &)(result));
6970 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6971 }
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj;
6980 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6981 wxPoint2D *arg2 = 0 ;
6982 wxPoint2D *result;
6983 wxPoint2D temp2 ;
6984 PyObject * obj0 = 0 ;
6985 PyObject * obj1 = 0 ;
6986 char *kwnames[] = {
6987 (char *) "self",(char *) "pt", NULL
6988 };
6989
6990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6992 if (SWIG_arg_fail(1)) SWIG_fail;
6993 {
6994 arg2 = &temp2;
6995 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6996 }
6997 {
6998 PyThreadState* __tstate = wxPyBeginAllowThreads();
6999 {
7000 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7001 result = (wxPoint2D *) &_result_ref;
7002 }
7003
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7008 return resultobj;
7009 fail:
7010 return NULL;
7011 }
7012
7013
7014 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7015 PyObject *resultobj;
7016 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7017 wxPoint2D *arg2 = 0 ;
7018 wxPoint2D *result;
7019 wxPoint2D temp2 ;
7020 PyObject * obj0 = 0 ;
7021 PyObject * obj1 = 0 ;
7022 char *kwnames[] = {
7023 (char *) "self",(char *) "pt", NULL
7024 };
7025
7026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7028 if (SWIG_arg_fail(1)) SWIG_fail;
7029 {
7030 arg2 = &temp2;
7031 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7032 }
7033 {
7034 PyThreadState* __tstate = wxPyBeginAllowThreads();
7035 {
7036 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7037 result = (wxPoint2D *) &_result_ref;
7038 }
7039
7040 wxPyEndAllowThreads(__tstate);
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7051 PyObject *resultobj;
7052 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7053 wxPoint2D *arg2 = 0 ;
7054 wxPoint2D *result;
7055 wxPoint2D temp2 ;
7056 PyObject * obj0 = 0 ;
7057 PyObject * obj1 = 0 ;
7058 char *kwnames[] = {
7059 (char *) "self",(char *) "pt", NULL
7060 };
7061
7062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7064 if (SWIG_arg_fail(1)) SWIG_fail;
7065 {
7066 arg2 = &temp2;
7067 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7068 }
7069 {
7070 PyThreadState* __tstate = wxPyBeginAllowThreads();
7071 {
7072 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7073 result = (wxPoint2D *) &_result_ref;
7074 }
7075
7076 wxPyEndAllowThreads(__tstate);
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7080 return resultobj;
7081 fail:
7082 return NULL;
7083 }
7084
7085
7086 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7087 PyObject *resultobj;
7088 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7089 wxPoint2D *arg2 = 0 ;
7090 wxPoint2D *result;
7091 wxPoint2D temp2 ;
7092 PyObject * obj0 = 0 ;
7093 PyObject * obj1 = 0 ;
7094 char *kwnames[] = {
7095 (char *) "self",(char *) "pt", NULL
7096 };
7097
7098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7100 if (SWIG_arg_fail(1)) SWIG_fail;
7101 {
7102 arg2 = &temp2;
7103 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7104 }
7105 {
7106 PyThreadState* __tstate = wxPyBeginAllowThreads();
7107 {
7108 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7109 result = (wxPoint2D *) &_result_ref;
7110 }
7111
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj;
7124 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7125 wxPoint2D *arg2 = 0 ;
7126 bool result;
7127 wxPoint2D temp2 ;
7128 PyObject * obj0 = 0 ;
7129 PyObject * obj1 = 0 ;
7130 char *kwnames[] = {
7131 (char *) "self",(char *) "pt", NULL
7132 };
7133
7134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7136 if (SWIG_arg_fail(1)) SWIG_fail;
7137 {
7138 arg2 = &temp2;
7139 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7140 }
7141 {
7142 PyThreadState* __tstate = wxPyBeginAllowThreads();
7143 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7144
7145 wxPyEndAllowThreads(__tstate);
7146 if (PyErr_Occurred()) SWIG_fail;
7147 }
7148 {
7149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7150 }
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj;
7159 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7160 wxPoint2D *arg2 = 0 ;
7161 bool result;
7162 wxPoint2D temp2 ;
7163 PyObject * obj0 = 0 ;
7164 PyObject * obj1 = 0 ;
7165 char *kwnames[] = {
7166 (char *) "self",(char *) "pt", NULL
7167 };
7168
7169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7171 if (SWIG_arg_fail(1)) SWIG_fail;
7172 {
7173 arg2 = &temp2;
7174 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7175 }
7176 {
7177 PyThreadState* __tstate = wxPyBeginAllowThreads();
7178 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7179
7180 wxPyEndAllowThreads(__tstate);
7181 if (PyErr_Occurred()) SWIG_fail;
7182 }
7183 {
7184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7185 }
7186 return resultobj;
7187 fail:
7188 return NULL;
7189 }
7190
7191
7192 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7193 PyObject *resultobj;
7194 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7195 double arg2 ;
7196 PyObject * obj0 = 0 ;
7197 PyObject * obj1 = 0 ;
7198 char *kwnames[] = {
7199 (char *) "self",(char *) "m_x", NULL
7200 };
7201
7202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7204 if (SWIG_arg_fail(1)) SWIG_fail;
7205 {
7206 arg2 = (double)(SWIG_As_double(obj1));
7207 if (SWIG_arg_fail(2)) SWIG_fail;
7208 }
7209 if (arg1) (arg1)->m_x = arg2;
7210
7211 Py_INCREF(Py_None); resultobj = Py_None;
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj;
7220 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7221 double result;
7222 PyObject * obj0 = 0 ;
7223 char *kwnames[] = {
7224 (char *) "self", NULL
7225 };
7226
7227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7229 if (SWIG_arg_fail(1)) SWIG_fail;
7230 result = (double) ((arg1)->m_x);
7231
7232 {
7233 resultobj = SWIG_From_double((double)(result));
7234 }
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7242 PyObject *resultobj;
7243 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7244 double arg2 ;
7245 PyObject * obj0 = 0 ;
7246 PyObject * obj1 = 0 ;
7247 char *kwnames[] = {
7248 (char *) "self",(char *) "m_y", NULL
7249 };
7250
7251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7253 if (SWIG_arg_fail(1)) SWIG_fail;
7254 {
7255 arg2 = (double)(SWIG_As_double(obj1));
7256 if (SWIG_arg_fail(2)) SWIG_fail;
7257 }
7258 if (arg1) (arg1)->m_y = arg2;
7259
7260 Py_INCREF(Py_None); resultobj = Py_None;
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7268 PyObject *resultobj;
7269 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7270 double result;
7271 PyObject * obj0 = 0 ;
7272 char *kwnames[] = {
7273 (char *) "self", NULL
7274 };
7275
7276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7278 if (SWIG_arg_fail(1)) SWIG_fail;
7279 result = (double) ((arg1)->m_y);
7280
7281 {
7282 resultobj = SWIG_From_double((double)(result));
7283 }
7284 return resultobj;
7285 fail:
7286 return NULL;
7287 }
7288
7289
7290 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7291 PyObject *resultobj;
7292 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7293 double arg2 = (double) 0 ;
7294 double arg3 = (double) 0 ;
7295 PyObject * obj0 = 0 ;
7296 PyObject * obj1 = 0 ;
7297 PyObject * obj2 = 0 ;
7298 char *kwnames[] = {
7299 (char *) "self",(char *) "x",(char *) "y", NULL
7300 };
7301
7302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7304 if (SWIG_arg_fail(1)) SWIG_fail;
7305 if (obj1) {
7306 {
7307 arg2 = (double)(SWIG_As_double(obj1));
7308 if (SWIG_arg_fail(2)) SWIG_fail;
7309 }
7310 }
7311 if (obj2) {
7312 {
7313 arg3 = (double)(SWIG_As_double(obj2));
7314 if (SWIG_arg_fail(3)) SWIG_fail;
7315 }
7316 }
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 wxPoint2D_Set(arg1,arg2,arg3);
7320
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 Py_INCREF(Py_None); resultobj = Py_None;
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj;
7333 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7334 PyObject *result;
7335 PyObject * obj0 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "self", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 {
7344 PyThreadState* __tstate = wxPyBeginAllowThreads();
7345 result = (PyObject *)wxPoint2D_Get(arg1);
7346
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 resultobj = result;
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7358 PyObject *obj;
7359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7360 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7361 Py_INCREF(obj);
7362 return Py_BuildValue((char *)"");
7363 }
7364 static int _wrap_DefaultPosition_set(PyObject *) {
7365 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7366 return 1;
7367 }
7368
7369
7370 static PyObject *_wrap_DefaultPosition_get(void) {
7371 PyObject *pyobj;
7372
7373 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7374 return pyobj;
7375 }
7376
7377
7378 static int _wrap_DefaultSize_set(PyObject *) {
7379 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7380 return 1;
7381 }
7382
7383
7384 static PyObject *_wrap_DefaultSize_get(void) {
7385 PyObject *pyobj;
7386
7387 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7388 return pyobj;
7389 }
7390
7391
7392 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj;
7394 PyObject *arg1 = (PyObject *) 0 ;
7395 wxPyInputStream *result;
7396 PyObject * obj0 = 0 ;
7397 char *kwnames[] = {
7398 (char *) "p", NULL
7399 };
7400
7401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7402 arg1 = obj0;
7403 {
7404 PyThreadState* __tstate = wxPyBeginAllowThreads();
7405 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7406
7407 wxPyEndAllowThreads(__tstate);
7408 if (PyErr_Occurred()) SWIG_fail;
7409 }
7410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7418 PyObject *resultobj;
7419 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7420 PyObject * obj0 = 0 ;
7421 char *kwnames[] = {
7422 (char *) "self", NULL
7423 };
7424
7425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7427 if (SWIG_arg_fail(1)) SWIG_fail;
7428 {
7429 PyThreadState* __tstate = wxPyBeginAllowThreads();
7430 delete arg1;
7431
7432 wxPyEndAllowThreads(__tstate);
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 Py_INCREF(Py_None); resultobj = Py_None;
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7443 PyObject *resultobj;
7444 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7445 PyObject * obj0 = 0 ;
7446 char *kwnames[] = {
7447 (char *) "self", NULL
7448 };
7449
7450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7452 if (SWIG_arg_fail(1)) SWIG_fail;
7453 {
7454 PyThreadState* __tstate = wxPyBeginAllowThreads();
7455 (arg1)->close();
7456
7457 wxPyEndAllowThreads(__tstate);
7458 if (PyErr_Occurred()) SWIG_fail;
7459 }
7460 Py_INCREF(Py_None); resultobj = Py_None;
7461 return resultobj;
7462 fail:
7463 return NULL;
7464 }
7465
7466
7467 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7468 PyObject *resultobj;
7469 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7470 PyObject * obj0 = 0 ;
7471 char *kwnames[] = {
7472 (char *) "self", NULL
7473 };
7474
7475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7477 if (SWIG_arg_fail(1)) SWIG_fail;
7478 {
7479 PyThreadState* __tstate = wxPyBeginAllowThreads();
7480 (arg1)->flush();
7481
7482 wxPyEndAllowThreads(__tstate);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 Py_INCREF(Py_None); resultobj = Py_None;
7486 return resultobj;
7487 fail:
7488 return NULL;
7489 }
7490
7491
7492 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7493 PyObject *resultobj;
7494 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7495 bool result;
7496 PyObject * obj0 = 0 ;
7497 char *kwnames[] = {
7498 (char *) "self", NULL
7499 };
7500
7501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7503 if (SWIG_arg_fail(1)) SWIG_fail;
7504 {
7505 PyThreadState* __tstate = wxPyBeginAllowThreads();
7506 result = (bool)(arg1)->eof();
7507
7508 wxPyEndAllowThreads(__tstate);
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 {
7512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7513 }
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj;
7522 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7523 int arg2 = (int) -1 ;
7524 PyObject *result;
7525 PyObject * obj0 = 0 ;
7526 PyObject * obj1 = 0 ;
7527 char *kwnames[] = {
7528 (char *) "self",(char *) "size", NULL
7529 };
7530
7531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7533 if (SWIG_arg_fail(1)) SWIG_fail;
7534 if (obj1) {
7535 {
7536 arg2 = (int)(SWIG_As_int(obj1));
7537 if (SWIG_arg_fail(2)) SWIG_fail;
7538 }
7539 }
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 result = (PyObject *)(arg1)->read(arg2);
7543
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = result;
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj;
7556 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7557 int arg2 = (int) -1 ;
7558 PyObject *result;
7559 PyObject * obj0 = 0 ;
7560 PyObject * obj1 = 0 ;
7561 char *kwnames[] = {
7562 (char *) "self",(char *) "size", NULL
7563 };
7564
7565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7567 if (SWIG_arg_fail(1)) SWIG_fail;
7568 if (obj1) {
7569 {
7570 arg2 = (int)(SWIG_As_int(obj1));
7571 if (SWIG_arg_fail(2)) SWIG_fail;
7572 }
7573 }
7574 {
7575 PyThreadState* __tstate = wxPyBeginAllowThreads();
7576 result = (PyObject *)(arg1)->readline(arg2);
7577
7578 wxPyEndAllowThreads(__tstate);
7579 if (PyErr_Occurred()) SWIG_fail;
7580 }
7581 resultobj = result;
7582 return resultobj;
7583 fail:
7584 return NULL;
7585 }
7586
7587
7588 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7589 PyObject *resultobj;
7590 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7591 int arg2 = (int) -1 ;
7592 PyObject *result;
7593 PyObject * obj0 = 0 ;
7594 PyObject * obj1 = 0 ;
7595 char *kwnames[] = {
7596 (char *) "self",(char *) "sizehint", NULL
7597 };
7598
7599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7601 if (SWIG_arg_fail(1)) SWIG_fail;
7602 if (obj1) {
7603 {
7604 arg2 = (int)(SWIG_As_int(obj1));
7605 if (SWIG_arg_fail(2)) SWIG_fail;
7606 }
7607 }
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 result = (PyObject *)(arg1)->readlines(arg2);
7611
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 resultobj = result;
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj;
7624 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7625 int arg2 ;
7626 int arg3 = (int) 0 ;
7627 PyObject * obj0 = 0 ;
7628 PyObject * obj1 = 0 ;
7629 PyObject * obj2 = 0 ;
7630 char *kwnames[] = {
7631 (char *) "self",(char *) "offset",(char *) "whence", NULL
7632 };
7633
7634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7636 if (SWIG_arg_fail(1)) SWIG_fail;
7637 {
7638 arg2 = (int)(SWIG_As_int(obj1));
7639 if (SWIG_arg_fail(2)) SWIG_fail;
7640 }
7641 if (obj2) {
7642 {
7643 arg3 = (int)(SWIG_As_int(obj2));
7644 if (SWIG_arg_fail(3)) SWIG_fail;
7645 }
7646 }
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 (arg1)->seek(arg2,arg3);
7650
7651 wxPyEndAllowThreads(__tstate);
7652 if (PyErr_Occurred()) SWIG_fail;
7653 }
7654 Py_INCREF(Py_None); resultobj = Py_None;
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj;
7663 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7664 int result;
7665 PyObject * obj0 = 0 ;
7666 char *kwnames[] = {
7667 (char *) "self", NULL
7668 };
7669
7670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7672 if (SWIG_arg_fail(1)) SWIG_fail;
7673 {
7674 PyThreadState* __tstate = wxPyBeginAllowThreads();
7675 result = (int)(arg1)->tell();
7676
7677 wxPyEndAllowThreads(__tstate);
7678 if (PyErr_Occurred()) SWIG_fail;
7679 }
7680 {
7681 resultobj = SWIG_From_int((int)(result));
7682 }
7683 return resultobj;
7684 fail:
7685 return NULL;
7686 }
7687
7688
7689 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7690 PyObject *resultobj;
7691 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7692 char result;
7693 PyObject * obj0 = 0 ;
7694 char *kwnames[] = {
7695 (char *) "self", NULL
7696 };
7697
7698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7700 if (SWIG_arg_fail(1)) SWIG_fail;
7701 {
7702 PyThreadState* __tstate = wxPyBeginAllowThreads();
7703 result = (char)(arg1)->Peek();
7704
7705 wxPyEndAllowThreads(__tstate);
7706 if (PyErr_Occurred()) SWIG_fail;
7707 }
7708 {
7709 resultobj = SWIG_From_char((char)(result));
7710 }
7711 return resultobj;
7712 fail:
7713 return NULL;
7714 }
7715
7716
7717 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7718 PyObject *resultobj;
7719 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7720 char result;
7721 PyObject * obj0 = 0 ;
7722 char *kwnames[] = {
7723 (char *) "self", NULL
7724 };
7725
7726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7728 if (SWIG_arg_fail(1)) SWIG_fail;
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 result = (char)(arg1)->GetC();
7732
7733 wxPyEndAllowThreads(__tstate);
7734 if (PyErr_Occurred()) SWIG_fail;
7735 }
7736 {
7737 resultobj = SWIG_From_char((char)(result));
7738 }
7739 return resultobj;
7740 fail:
7741 return NULL;
7742 }
7743
7744
7745 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7746 PyObject *resultobj;
7747 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7748 size_t result;
7749 PyObject * obj0 = 0 ;
7750 char *kwnames[] = {
7751 (char *) "self", NULL
7752 };
7753
7754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7756 if (SWIG_arg_fail(1)) SWIG_fail;
7757 {
7758 PyThreadState* __tstate = wxPyBeginAllowThreads();
7759 result = (size_t)(arg1)->LastRead();
7760
7761 wxPyEndAllowThreads(__tstate);
7762 if (PyErr_Occurred()) SWIG_fail;
7763 }
7764 {
7765 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7766 }
7767 return resultobj;
7768 fail:
7769 return NULL;
7770 }
7771
7772
7773 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7774 PyObject *resultobj;
7775 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7776 bool result;
7777 PyObject * obj0 = 0 ;
7778 char *kwnames[] = {
7779 (char *) "self", NULL
7780 };
7781
7782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7784 if (SWIG_arg_fail(1)) SWIG_fail;
7785 {
7786 PyThreadState* __tstate = wxPyBeginAllowThreads();
7787 result = (bool)(arg1)->CanRead();
7788
7789 wxPyEndAllowThreads(__tstate);
7790 if (PyErr_Occurred()) SWIG_fail;
7791 }
7792 {
7793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7794 }
7795 return resultobj;
7796 fail:
7797 return NULL;
7798 }
7799
7800
7801 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7802 PyObject *resultobj;
7803 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7804 bool result;
7805 PyObject * obj0 = 0 ;
7806 char *kwnames[] = {
7807 (char *) "self", NULL
7808 };
7809
7810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7812 if (SWIG_arg_fail(1)) SWIG_fail;
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 result = (bool)(arg1)->Eof();
7816
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 {
7821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7822 }
7823 return resultobj;
7824 fail:
7825 return NULL;
7826 }
7827
7828
7829 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7830 PyObject *resultobj;
7831 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7832 char arg2 ;
7833 bool result;
7834 PyObject * obj0 = 0 ;
7835 PyObject * obj1 = 0 ;
7836 char *kwnames[] = {
7837 (char *) "self",(char *) "c", NULL
7838 };
7839
7840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7842 if (SWIG_arg_fail(1)) SWIG_fail;
7843 {
7844 arg2 = (char)(SWIG_As_char(obj1));
7845 if (SWIG_arg_fail(2)) SWIG_fail;
7846 }
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (bool)(arg1)->Ungetch(arg2);
7850
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 {
7855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7856 }
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7864 PyObject *resultobj;
7865 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7866 long arg2 ;
7867 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7868 long result;
7869 PyObject * obj0 = 0 ;
7870 PyObject * obj1 = 0 ;
7871 PyObject * obj2 = 0 ;
7872 char *kwnames[] = {
7873 (char *) "self",(char *) "pos",(char *) "mode", NULL
7874 };
7875
7876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7878 if (SWIG_arg_fail(1)) SWIG_fail;
7879 {
7880 arg2 = (long)(SWIG_As_long(obj1));
7881 if (SWIG_arg_fail(2)) SWIG_fail;
7882 }
7883 if (obj2) {
7884 {
7885 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7886 if (SWIG_arg_fail(3)) SWIG_fail;
7887 }
7888 }
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7892
7893 wxPyEndAllowThreads(__tstate);
7894 if (PyErr_Occurred()) SWIG_fail;
7895 }
7896 {
7897 resultobj = SWIG_From_long((long)(result));
7898 }
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7906 PyObject *resultobj;
7907 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7908 long result;
7909 PyObject * obj0 = 0 ;
7910 char *kwnames[] = {
7911 (char *) "self", NULL
7912 };
7913
7914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7916 if (SWIG_arg_fail(1)) SWIG_fail;
7917 {
7918 PyThreadState* __tstate = wxPyBeginAllowThreads();
7919 result = (long)(arg1)->TellI();
7920
7921 wxPyEndAllowThreads(__tstate);
7922 if (PyErr_Occurred()) SWIG_fail;
7923 }
7924 {
7925 resultobj = SWIG_From_long((long)(result));
7926 }
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7934 PyObject *obj;
7935 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7936 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7937 Py_INCREF(obj);
7938 return Py_BuildValue((char *)"");
7939 }
7940 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7941 PyObject *resultobj;
7942 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7943 PyObject *arg2 = (PyObject *) 0 ;
7944 PyObject * obj0 = 0 ;
7945 PyObject * obj1 = 0 ;
7946 char *kwnames[] = {
7947 (char *) "self",(char *) "obj", NULL
7948 };
7949
7950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7952 if (SWIG_arg_fail(1)) SWIG_fail;
7953 arg2 = obj1;
7954 {
7955 PyThreadState* __tstate = wxPyBeginAllowThreads();
7956 wxOutputStream_write(arg1,arg2);
7957
7958 wxPyEndAllowThreads(__tstate);
7959 if (PyErr_Occurred()) SWIG_fail;
7960 }
7961 Py_INCREF(Py_None); resultobj = Py_None;
7962 return resultobj;
7963 fail:
7964 return NULL;
7965 }
7966
7967
7968 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7969 PyObject *obj;
7970 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7971 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7972 Py_INCREF(obj);
7973 return Py_BuildValue((char *)"");
7974 }
7975 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7976 PyObject *resultobj;
7977 wxInputStream *arg1 = (wxInputStream *) 0 ;
7978 wxString *arg2 = 0 ;
7979 wxString *arg3 = 0 ;
7980 wxString *arg4 = 0 ;
7981 wxDateTime arg5 ;
7982 wxFSFile *result;
7983 wxPyInputStream *temp1 ;
7984 bool temp2 = false ;
7985 bool temp3 = false ;
7986 bool temp4 = false ;
7987 PyObject * obj0 = 0 ;
7988 PyObject * obj1 = 0 ;
7989 PyObject * obj2 = 0 ;
7990 PyObject * obj3 = 0 ;
7991 PyObject * obj4 = 0 ;
7992 char *kwnames[] = {
7993 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7994 };
7995
7996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7997 {
7998 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7999 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8000 } else {
8001 PyErr_Clear(); // clear the failure of the wxPyConvert above
8002 arg1 = wxPyCBInputStream_create(obj0, true);
8003 if (arg1 == NULL) {
8004 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8005 SWIG_fail;
8006 }
8007 }
8008 }
8009 {
8010 arg2 = wxString_in_helper(obj1);
8011 if (arg2 == NULL) SWIG_fail;
8012 temp2 = true;
8013 }
8014 {
8015 arg3 = wxString_in_helper(obj2);
8016 if (arg3 == NULL) SWIG_fail;
8017 temp3 = true;
8018 }
8019 {
8020 arg4 = wxString_in_helper(obj3);
8021 if (arg4 == NULL) SWIG_fail;
8022 temp4 = true;
8023 }
8024 {
8025 wxDateTime * argp;
8026 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8027 if (SWIG_arg_fail(5)) SWIG_fail;
8028 if (argp == NULL) {
8029 SWIG_null_ref("wxDateTime");
8030 }
8031 if (SWIG_arg_fail(5)) SWIG_fail;
8032 arg5 = *argp;
8033 }
8034 {
8035 PyThreadState* __tstate = wxPyBeginAllowThreads();
8036 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8037
8038 wxPyEndAllowThreads(__tstate);
8039 if (PyErr_Occurred()) SWIG_fail;
8040 }
8041 {
8042 resultobj = wxPyMake_wxObject(result, 1);
8043 }
8044 {
8045 if (temp2)
8046 delete arg2;
8047 }
8048 {
8049 if (temp3)
8050 delete arg3;
8051 }
8052 {
8053 if (temp4)
8054 delete arg4;
8055 }
8056 return resultobj;
8057 fail:
8058 {
8059 if (temp2)
8060 delete arg2;
8061 }
8062 {
8063 if (temp3)
8064 delete arg3;
8065 }
8066 {
8067 if (temp4)
8068 delete arg4;
8069 }
8070 return NULL;
8071 }
8072
8073
8074 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8075 PyObject *resultobj;
8076 wxFSFile *arg1 = (wxFSFile *) 0 ;
8077 PyObject * obj0 = 0 ;
8078 char *kwnames[] = {
8079 (char *) "self", NULL
8080 };
8081
8082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8084 if (SWIG_arg_fail(1)) SWIG_fail;
8085 {
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 delete arg1;
8088
8089 wxPyEndAllowThreads(__tstate);
8090 if (PyErr_Occurred()) SWIG_fail;
8091 }
8092 Py_INCREF(Py_None); resultobj = Py_None;
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8100 PyObject *resultobj;
8101 wxFSFile *arg1 = (wxFSFile *) 0 ;
8102 wxInputStream *result;
8103 PyObject * obj0 = 0 ;
8104 char *kwnames[] = {
8105 (char *) "self", NULL
8106 };
8107
8108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8110 if (SWIG_arg_fail(1)) SWIG_fail;
8111 {
8112 PyThreadState* __tstate = wxPyBeginAllowThreads();
8113 result = (wxInputStream *)(arg1)->GetStream();
8114
8115 wxPyEndAllowThreads(__tstate);
8116 if (PyErr_Occurred()) SWIG_fail;
8117 }
8118 {
8119 wxPyInputStream * _ptr = NULL;
8120
8121 if (result) {
8122 _ptr = new wxPyInputStream(result);
8123 }
8124 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8125 }
8126 return resultobj;
8127 fail:
8128 return NULL;
8129 }
8130
8131
8132 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8133 PyObject *resultobj;
8134 wxFSFile *arg1 = (wxFSFile *) 0 ;
8135 wxString *result;
8136 PyObject * obj0 = 0 ;
8137 char *kwnames[] = {
8138 (char *) "self", NULL
8139 };
8140
8141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8143 if (SWIG_arg_fail(1)) SWIG_fail;
8144 {
8145 PyThreadState* __tstate = wxPyBeginAllowThreads();
8146 {
8147 wxString const &_result_ref = (arg1)->GetMimeType();
8148 result = (wxString *) &_result_ref;
8149 }
8150
8151 wxPyEndAllowThreads(__tstate);
8152 if (PyErr_Occurred()) SWIG_fail;
8153 }
8154 {
8155 #if wxUSE_UNICODE
8156 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8157 #else
8158 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8159 #endif
8160 }
8161 return resultobj;
8162 fail:
8163 return NULL;
8164 }
8165
8166
8167 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8168 PyObject *resultobj;
8169 wxFSFile *arg1 = (wxFSFile *) 0 ;
8170 wxString *result;
8171 PyObject * obj0 = 0 ;
8172 char *kwnames[] = {
8173 (char *) "self", NULL
8174 };
8175
8176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8178 if (SWIG_arg_fail(1)) SWIG_fail;
8179 {
8180 PyThreadState* __tstate = wxPyBeginAllowThreads();
8181 {
8182 wxString const &_result_ref = (arg1)->GetLocation();
8183 result = (wxString *) &_result_ref;
8184 }
8185
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 {
8190 #if wxUSE_UNICODE
8191 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8192 #else
8193 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8194 #endif
8195 }
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj;
8204 wxFSFile *arg1 = (wxFSFile *) 0 ;
8205 wxString *result;
8206 PyObject * obj0 = 0 ;
8207 char *kwnames[] = {
8208 (char *) "self", NULL
8209 };
8210
8211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8213 if (SWIG_arg_fail(1)) SWIG_fail;
8214 {
8215 PyThreadState* __tstate = wxPyBeginAllowThreads();
8216 {
8217 wxString const &_result_ref = (arg1)->GetAnchor();
8218 result = (wxString *) &_result_ref;
8219 }
8220
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 {
8225 #if wxUSE_UNICODE
8226 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8227 #else
8228 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8229 #endif
8230 }
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8238 PyObject *resultobj;
8239 wxFSFile *arg1 = (wxFSFile *) 0 ;
8240 wxDateTime result;
8241 PyObject * obj0 = 0 ;
8242 char *kwnames[] = {
8243 (char *) "self", NULL
8244 };
8245
8246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8248 if (SWIG_arg_fail(1)) SWIG_fail;
8249 {
8250 PyThreadState* __tstate = wxPyBeginAllowThreads();
8251 result = (arg1)->GetModificationTime();
8252
8253 wxPyEndAllowThreads(__tstate);
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 {
8257 wxDateTime * resultptr;
8258 resultptr = new wxDateTime((wxDateTime &)(result));
8259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8260 }
8261 return resultobj;
8262 fail:
8263 return NULL;
8264 }
8265
8266
8267 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8268 PyObject *obj;
8269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8270 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8271 Py_INCREF(obj);
8272 return Py_BuildValue((char *)"");
8273 }
8274 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8275 PyObject *obj;
8276 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8277 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8278 Py_INCREF(obj);
8279 return Py_BuildValue((char *)"");
8280 }
8281 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj;
8283 wxPyFileSystemHandler *result;
8284 char *kwnames[] = {
8285 NULL
8286 };
8287
8288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8289 {
8290 PyThreadState* __tstate = wxPyBeginAllowThreads();
8291 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8292
8293 wxPyEndAllowThreads(__tstate);
8294 if (PyErr_Occurred()) SWIG_fail;
8295 }
8296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8297 return resultobj;
8298 fail:
8299 return NULL;
8300 }
8301
8302
8303 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8304 PyObject *resultobj;
8305 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8306 PyObject *arg2 = (PyObject *) 0 ;
8307 PyObject *arg3 = (PyObject *) 0 ;
8308 PyObject * obj0 = 0 ;
8309 PyObject * obj1 = 0 ;
8310 PyObject * obj2 = 0 ;
8311 char *kwnames[] = {
8312 (char *) "self",(char *) "self",(char *) "_class", NULL
8313 };
8314
8315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8317 if (SWIG_arg_fail(1)) SWIG_fail;
8318 arg2 = obj1;
8319 arg3 = obj2;
8320 {
8321 PyThreadState* __tstate = wxPyBeginAllowThreads();
8322 (arg1)->_setCallbackInfo(arg2,arg3);
8323
8324 wxPyEndAllowThreads(__tstate);
8325 if (PyErr_Occurred()) SWIG_fail;
8326 }
8327 Py_INCREF(Py_None); resultobj = Py_None;
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8335 PyObject *resultobj;
8336 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8337 wxString *arg2 = 0 ;
8338 bool result;
8339 bool temp2 = false ;
8340 PyObject * obj0 = 0 ;
8341 PyObject * obj1 = 0 ;
8342 char *kwnames[] = {
8343 (char *) "self",(char *) "location", NULL
8344 };
8345
8346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8348 if (SWIG_arg_fail(1)) SWIG_fail;
8349 {
8350 arg2 = wxString_in_helper(obj1);
8351 if (arg2 == NULL) SWIG_fail;
8352 temp2 = true;
8353 }
8354 {
8355 PyThreadState* __tstate = wxPyBeginAllowThreads();
8356 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8357
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 {
8362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8363 }
8364 {
8365 if (temp2)
8366 delete arg2;
8367 }
8368 return resultobj;
8369 fail:
8370 {
8371 if (temp2)
8372 delete arg2;
8373 }
8374 return NULL;
8375 }
8376
8377
8378 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj;
8380 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8381 wxFileSystem *arg2 = 0 ;
8382 wxString *arg3 = 0 ;
8383 wxFSFile *result;
8384 bool temp3 = false ;
8385 PyObject * obj0 = 0 ;
8386 PyObject * obj1 = 0 ;
8387 PyObject * obj2 = 0 ;
8388 char *kwnames[] = {
8389 (char *) "self",(char *) "fs",(char *) "location", NULL
8390 };
8391
8392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8394 if (SWIG_arg_fail(1)) SWIG_fail;
8395 {
8396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8397 if (SWIG_arg_fail(2)) SWIG_fail;
8398 if (arg2 == NULL) {
8399 SWIG_null_ref("wxFileSystem");
8400 }
8401 if (SWIG_arg_fail(2)) SWIG_fail;
8402 }
8403 {
8404 arg3 = wxString_in_helper(obj2);
8405 if (arg3 == NULL) SWIG_fail;
8406 temp3 = true;
8407 }
8408 {
8409 PyThreadState* __tstate = wxPyBeginAllowThreads();
8410 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8411
8412 wxPyEndAllowThreads(__tstate);
8413 if (PyErr_Occurred()) SWIG_fail;
8414 }
8415 {
8416 resultobj = wxPyMake_wxObject(result, 1);
8417 }
8418 {
8419 if (temp3)
8420 delete arg3;
8421 }
8422 return resultobj;
8423 fail:
8424 {
8425 if (temp3)
8426 delete arg3;
8427 }
8428 return NULL;
8429 }
8430
8431
8432 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8433 PyObject *resultobj;
8434 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8435 wxString *arg2 = 0 ;
8436 int arg3 = (int) 0 ;
8437 wxString result;
8438 bool temp2 = false ;
8439 PyObject * obj0 = 0 ;
8440 PyObject * obj1 = 0 ;
8441 PyObject * obj2 = 0 ;
8442 char *kwnames[] = {
8443 (char *) "self",(char *) "spec",(char *) "flags", NULL
8444 };
8445
8446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8448 if (SWIG_arg_fail(1)) SWIG_fail;
8449 {
8450 arg2 = wxString_in_helper(obj1);
8451 if (arg2 == NULL) SWIG_fail;
8452 temp2 = true;
8453 }
8454 if (obj2) {
8455 {
8456 arg3 = (int)(SWIG_As_int(obj2));
8457 if (SWIG_arg_fail(3)) SWIG_fail;
8458 }
8459 }
8460 {
8461 PyThreadState* __tstate = wxPyBeginAllowThreads();
8462 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8463
8464 wxPyEndAllowThreads(__tstate);
8465 if (PyErr_Occurred()) SWIG_fail;
8466 }
8467 {
8468 #if wxUSE_UNICODE
8469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8470 #else
8471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8472 #endif
8473 }
8474 {
8475 if (temp2)
8476 delete arg2;
8477 }
8478 return resultobj;
8479 fail:
8480 {
8481 if (temp2)
8482 delete arg2;
8483 }
8484 return NULL;
8485 }
8486
8487
8488 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8489 PyObject *resultobj;
8490 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8491 wxString result;
8492 PyObject * obj0 = 0 ;
8493 char *kwnames[] = {
8494 (char *) "self", NULL
8495 };
8496
8497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8499 if (SWIG_arg_fail(1)) SWIG_fail;
8500 {
8501 PyThreadState* __tstate = wxPyBeginAllowThreads();
8502 result = (arg1)->FindNext();
8503
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 {
8508 #if wxUSE_UNICODE
8509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8510 #else
8511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8512 #endif
8513 }
8514 return resultobj;
8515 fail:
8516 return NULL;
8517 }
8518
8519
8520 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8521 PyObject *resultobj;
8522 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8523 wxString *arg2 = 0 ;
8524 wxString result;
8525 bool temp2 = false ;
8526 PyObject * obj0 = 0 ;
8527 PyObject * obj1 = 0 ;
8528 char *kwnames[] = {
8529 (char *) "self",(char *) "location", NULL
8530 };
8531
8532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8534 if (SWIG_arg_fail(1)) SWIG_fail;
8535 {
8536 arg2 = wxString_in_helper(obj1);
8537 if (arg2 == NULL) SWIG_fail;
8538 temp2 = true;
8539 }
8540 {
8541 PyThreadState* __tstate = wxPyBeginAllowThreads();
8542 result = (arg1)->GetProtocol((wxString const &)*arg2);
8543
8544 wxPyEndAllowThreads(__tstate);
8545 if (PyErr_Occurred()) SWIG_fail;
8546 }
8547 {
8548 #if wxUSE_UNICODE
8549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8550 #else
8551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8552 #endif
8553 }
8554 {
8555 if (temp2)
8556 delete arg2;
8557 }
8558 return resultobj;
8559 fail:
8560 {
8561 if (temp2)
8562 delete arg2;
8563 }
8564 return NULL;
8565 }
8566
8567
8568 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8569 PyObject *resultobj;
8570 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8571 wxString *arg2 = 0 ;
8572 wxString result;
8573 bool temp2 = false ;
8574 PyObject * obj0 = 0 ;
8575 PyObject * obj1 = 0 ;
8576 char *kwnames[] = {
8577 (char *) "self",(char *) "location", NULL
8578 };
8579
8580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8582 if (SWIG_arg_fail(1)) SWIG_fail;
8583 {
8584 arg2 = wxString_in_helper(obj1);
8585 if (arg2 == NULL) SWIG_fail;
8586 temp2 = true;
8587 }
8588 {
8589 PyThreadState* __tstate = wxPyBeginAllowThreads();
8590 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8591
8592 wxPyEndAllowThreads(__tstate);
8593 if (PyErr_Occurred()) SWIG_fail;
8594 }
8595 {
8596 #if wxUSE_UNICODE
8597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8598 #else
8599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8600 #endif
8601 }
8602 {
8603 if (temp2)
8604 delete arg2;
8605 }
8606 return resultobj;
8607 fail:
8608 {
8609 if (temp2)
8610 delete arg2;
8611 }
8612 return NULL;
8613 }
8614
8615
8616 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8617 PyObject *resultobj;
8618 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8619 wxString *arg2 = 0 ;
8620 wxString result;
8621 bool temp2 = false ;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 char *kwnames[] = {
8625 (char *) "self",(char *) "location", NULL
8626 };
8627
8628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8630 if (SWIG_arg_fail(1)) SWIG_fail;
8631 {
8632 arg2 = wxString_in_helper(obj1);
8633 if (arg2 == NULL) SWIG_fail;
8634 temp2 = true;
8635 }
8636 {
8637 PyThreadState* __tstate = wxPyBeginAllowThreads();
8638 result = (arg1)->GetAnchor((wxString const &)*arg2);
8639
8640 wxPyEndAllowThreads(__tstate);
8641 if (PyErr_Occurred()) SWIG_fail;
8642 }
8643 {
8644 #if wxUSE_UNICODE
8645 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8646 #else
8647 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8648 #endif
8649 }
8650 {
8651 if (temp2)
8652 delete arg2;
8653 }
8654 return resultobj;
8655 fail:
8656 {
8657 if (temp2)
8658 delete arg2;
8659 }
8660 return NULL;
8661 }
8662
8663
8664 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8665 PyObject *resultobj;
8666 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8667 wxString *arg2 = 0 ;
8668 wxString result;
8669 bool temp2 = false ;
8670 PyObject * obj0 = 0 ;
8671 PyObject * obj1 = 0 ;
8672 char *kwnames[] = {
8673 (char *) "self",(char *) "location", NULL
8674 };
8675
8676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8678 if (SWIG_arg_fail(1)) SWIG_fail;
8679 {
8680 arg2 = wxString_in_helper(obj1);
8681 if (arg2 == NULL) SWIG_fail;
8682 temp2 = true;
8683 }
8684 {
8685 PyThreadState* __tstate = wxPyBeginAllowThreads();
8686 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8687
8688 wxPyEndAllowThreads(__tstate);
8689 if (PyErr_Occurred()) SWIG_fail;
8690 }
8691 {
8692 #if wxUSE_UNICODE
8693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8694 #else
8695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8696 #endif
8697 }
8698 {
8699 if (temp2)
8700 delete arg2;
8701 }
8702 return resultobj;
8703 fail:
8704 {
8705 if (temp2)
8706 delete arg2;
8707 }
8708 return NULL;
8709 }
8710
8711
8712 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8713 PyObject *resultobj;
8714 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8715 wxString *arg2 = 0 ;
8716 wxString result;
8717 bool temp2 = false ;
8718 PyObject * obj0 = 0 ;
8719 PyObject * obj1 = 0 ;
8720 char *kwnames[] = {
8721 (char *) "self",(char *) "location", NULL
8722 };
8723
8724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8726 if (SWIG_arg_fail(1)) SWIG_fail;
8727 {
8728 arg2 = wxString_in_helper(obj1);
8729 if (arg2 == NULL) SWIG_fail;
8730 temp2 = true;
8731 }
8732 {
8733 PyThreadState* __tstate = wxPyBeginAllowThreads();
8734 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8735
8736 wxPyEndAllowThreads(__tstate);
8737 if (PyErr_Occurred()) SWIG_fail;
8738 }
8739 {
8740 #if wxUSE_UNICODE
8741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8742 #else
8743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8744 #endif
8745 }
8746 {
8747 if (temp2)
8748 delete arg2;
8749 }
8750 return resultobj;
8751 fail:
8752 {
8753 if (temp2)
8754 delete arg2;
8755 }
8756 return NULL;
8757 }
8758
8759
8760 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8761 PyObject *obj;
8762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8763 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8764 Py_INCREF(obj);
8765 return Py_BuildValue((char *)"");
8766 }
8767 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj;
8769 wxFileSystem *result;
8770 char *kwnames[] = {
8771 NULL
8772 };
8773
8774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8775 {
8776 PyThreadState* __tstate = wxPyBeginAllowThreads();
8777 result = (wxFileSystem *)new wxFileSystem();
8778
8779 wxPyEndAllowThreads(__tstate);
8780 if (PyErr_Occurred()) SWIG_fail;
8781 }
8782 {
8783 resultobj = wxPyMake_wxObject(result, 1);
8784 }
8785 return resultobj;
8786 fail:
8787 return NULL;
8788 }
8789
8790
8791 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8792 PyObject *resultobj;
8793 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8794 PyObject * obj0 = 0 ;
8795 char *kwnames[] = {
8796 (char *) "self", NULL
8797 };
8798
8799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8801 if (SWIG_arg_fail(1)) SWIG_fail;
8802 {
8803 PyThreadState* __tstate = wxPyBeginAllowThreads();
8804 delete arg1;
8805
8806 wxPyEndAllowThreads(__tstate);
8807 if (PyErr_Occurred()) SWIG_fail;
8808 }
8809 Py_INCREF(Py_None); resultobj = Py_None;
8810 return resultobj;
8811 fail:
8812 return NULL;
8813 }
8814
8815
8816 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8817 PyObject *resultobj;
8818 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8819 wxString *arg2 = 0 ;
8820 bool arg3 = (bool) false ;
8821 bool temp2 = false ;
8822 PyObject * obj0 = 0 ;
8823 PyObject * obj1 = 0 ;
8824 PyObject * obj2 = 0 ;
8825 char *kwnames[] = {
8826 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8827 };
8828
8829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8831 if (SWIG_arg_fail(1)) SWIG_fail;
8832 {
8833 arg2 = wxString_in_helper(obj1);
8834 if (arg2 == NULL) SWIG_fail;
8835 temp2 = true;
8836 }
8837 if (obj2) {
8838 {
8839 arg3 = (bool)(SWIG_As_bool(obj2));
8840 if (SWIG_arg_fail(3)) SWIG_fail;
8841 }
8842 }
8843 {
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8846
8847 wxPyEndAllowThreads(__tstate);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 Py_INCREF(Py_None); resultobj = Py_None;
8851 {
8852 if (temp2)
8853 delete arg2;
8854 }
8855 return resultobj;
8856 fail:
8857 {
8858 if (temp2)
8859 delete arg2;
8860 }
8861 return NULL;
8862 }
8863
8864
8865 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8866 PyObject *resultobj;
8867 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8868 wxString result;
8869 PyObject * obj0 = 0 ;
8870 char *kwnames[] = {
8871 (char *) "self", NULL
8872 };
8873
8874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8876 if (SWIG_arg_fail(1)) SWIG_fail;
8877 {
8878 PyThreadState* __tstate = wxPyBeginAllowThreads();
8879 result = (arg1)->GetPath();
8880
8881 wxPyEndAllowThreads(__tstate);
8882 if (PyErr_Occurred()) SWIG_fail;
8883 }
8884 {
8885 #if wxUSE_UNICODE
8886 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8887 #else
8888 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8889 #endif
8890 }
8891 return resultobj;
8892 fail:
8893 return NULL;
8894 }
8895
8896
8897 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8898 PyObject *resultobj;
8899 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8900 wxString *arg2 = 0 ;
8901 wxFSFile *result;
8902 bool temp2 = false ;
8903 PyObject * obj0 = 0 ;
8904 PyObject * obj1 = 0 ;
8905 char *kwnames[] = {
8906 (char *) "self",(char *) "location", NULL
8907 };
8908
8909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8911 if (SWIG_arg_fail(1)) SWIG_fail;
8912 {
8913 arg2 = wxString_in_helper(obj1);
8914 if (arg2 == NULL) SWIG_fail;
8915 temp2 = true;
8916 }
8917 {
8918 PyThreadState* __tstate = wxPyBeginAllowThreads();
8919 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8920
8921 wxPyEndAllowThreads(__tstate);
8922 if (PyErr_Occurred()) SWIG_fail;
8923 }
8924 {
8925 resultobj = wxPyMake_wxObject(result, 1);
8926 }
8927 {
8928 if (temp2)
8929 delete arg2;
8930 }
8931 return resultobj;
8932 fail:
8933 {
8934 if (temp2)
8935 delete arg2;
8936 }
8937 return NULL;
8938 }
8939
8940
8941 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8942 PyObject *resultobj;
8943 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8944 wxString *arg2 = 0 ;
8945 int arg3 = (int) 0 ;
8946 wxString result;
8947 bool temp2 = false ;
8948 PyObject * obj0 = 0 ;
8949 PyObject * obj1 = 0 ;
8950 PyObject * obj2 = 0 ;
8951 char *kwnames[] = {
8952 (char *) "self",(char *) "spec",(char *) "flags", NULL
8953 };
8954
8955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8957 if (SWIG_arg_fail(1)) SWIG_fail;
8958 {
8959 arg2 = wxString_in_helper(obj1);
8960 if (arg2 == NULL) SWIG_fail;
8961 temp2 = true;
8962 }
8963 if (obj2) {
8964 {
8965 arg3 = (int)(SWIG_As_int(obj2));
8966 if (SWIG_arg_fail(3)) SWIG_fail;
8967 }
8968 }
8969 {
8970 PyThreadState* __tstate = wxPyBeginAllowThreads();
8971 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8972
8973 wxPyEndAllowThreads(__tstate);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 {
8977 #if wxUSE_UNICODE
8978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8979 #else
8980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8981 #endif
8982 }
8983 {
8984 if (temp2)
8985 delete arg2;
8986 }
8987 return resultobj;
8988 fail:
8989 {
8990 if (temp2)
8991 delete arg2;
8992 }
8993 return NULL;
8994 }
8995
8996
8997 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8998 PyObject *resultobj;
8999 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9000 wxString result;
9001 PyObject * obj0 = 0 ;
9002 char *kwnames[] = {
9003 (char *) "self", NULL
9004 };
9005
9006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9008 if (SWIG_arg_fail(1)) SWIG_fail;
9009 {
9010 PyThreadState* __tstate = wxPyBeginAllowThreads();
9011 result = (arg1)->FindNext();
9012
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 {
9017 #if wxUSE_UNICODE
9018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9019 #else
9020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9021 #endif
9022 }
9023 return resultobj;
9024 fail:
9025 return NULL;
9026 }
9027
9028
9029 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9030 PyObject *resultobj;
9031 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9032 PyObject * obj0 = 0 ;
9033 char *kwnames[] = {
9034 (char *) "handler", NULL
9035 };
9036
9037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9039 if (SWIG_arg_fail(1)) SWIG_fail;
9040 {
9041 PyThreadState* __tstate = wxPyBeginAllowThreads();
9042 wxFileSystem::AddHandler(arg1);
9043
9044 wxPyEndAllowThreads(__tstate);
9045 if (PyErr_Occurred()) SWIG_fail;
9046 }
9047 Py_INCREF(Py_None); resultobj = Py_None;
9048 return resultobj;
9049 fail:
9050 return NULL;
9051 }
9052
9053
9054 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9055 PyObject *resultobj;
9056 char *kwnames[] = {
9057 NULL
9058 };
9059
9060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 wxFileSystem::CleanUpHandlers();
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 Py_INCREF(Py_None); resultobj = Py_None;
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9076 PyObject *resultobj;
9077 wxString *arg1 = 0 ;
9078 wxString result;
9079 bool temp1 = false ;
9080 PyObject * obj0 = 0 ;
9081 char *kwnames[] = {
9082 (char *) "filename", NULL
9083 };
9084
9085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9086 {
9087 arg1 = wxString_in_helper(obj0);
9088 if (arg1 == NULL) SWIG_fail;
9089 temp1 = true;
9090 }
9091 {
9092 PyThreadState* __tstate = wxPyBeginAllowThreads();
9093 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9094
9095 wxPyEndAllowThreads(__tstate);
9096 if (PyErr_Occurred()) SWIG_fail;
9097 }
9098 {
9099 #if wxUSE_UNICODE
9100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9101 #else
9102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9103 #endif
9104 }
9105 {
9106 if (temp1)
9107 delete arg1;
9108 }
9109 return resultobj;
9110 fail:
9111 {
9112 if (temp1)
9113 delete arg1;
9114 }
9115 return NULL;
9116 }
9117
9118
9119 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9120 PyObject *resultobj;
9121 wxString *arg1 = 0 ;
9122 wxString result;
9123 bool temp1 = false ;
9124 PyObject * obj0 = 0 ;
9125 char *kwnames[] = {
9126 (char *) "url", NULL
9127 };
9128
9129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9130 {
9131 arg1 = wxString_in_helper(obj0);
9132 if (arg1 == NULL) SWIG_fail;
9133 temp1 = true;
9134 }
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 result = FileSystem_URLToFileName((wxString const &)*arg1);
9138
9139 wxPyEndAllowThreads(__tstate);
9140 if (PyErr_Occurred()) SWIG_fail;
9141 }
9142 {
9143 #if wxUSE_UNICODE
9144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9145 #else
9146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9147 #endif
9148 }
9149 {
9150 if (temp1)
9151 delete arg1;
9152 }
9153 return resultobj;
9154 fail:
9155 {
9156 if (temp1)
9157 delete arg1;
9158 }
9159 return NULL;
9160 }
9161
9162
9163 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9164 PyObject *obj;
9165 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9166 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9167 Py_INCREF(obj);
9168 return Py_BuildValue((char *)"");
9169 }
9170 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9171 PyObject *resultobj;
9172 wxInternetFSHandler *result;
9173 char *kwnames[] = {
9174 NULL
9175 };
9176
9177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9181
9182 wxPyEndAllowThreads(__tstate);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9186 return resultobj;
9187 fail:
9188 return NULL;
9189 }
9190
9191
9192 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9193 PyObject *resultobj;
9194 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9195 wxString *arg2 = 0 ;
9196 bool result;
9197 bool temp2 = false ;
9198 PyObject * obj0 = 0 ;
9199 PyObject * obj1 = 0 ;
9200 char *kwnames[] = {
9201 (char *) "self",(char *) "location", NULL
9202 };
9203
9204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9206 if (SWIG_arg_fail(1)) SWIG_fail;
9207 {
9208 arg2 = wxString_in_helper(obj1);
9209 if (arg2 == NULL) SWIG_fail;
9210 temp2 = true;
9211 }
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9215
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 {
9220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9221 }
9222 {
9223 if (temp2)
9224 delete arg2;
9225 }
9226 return resultobj;
9227 fail:
9228 {
9229 if (temp2)
9230 delete arg2;
9231 }
9232 return NULL;
9233 }
9234
9235
9236 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9237 PyObject *resultobj;
9238 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9239 wxFileSystem *arg2 = 0 ;
9240 wxString *arg3 = 0 ;
9241 wxFSFile *result;
9242 bool temp3 = false ;
9243 PyObject * obj0 = 0 ;
9244 PyObject * obj1 = 0 ;
9245 PyObject * obj2 = 0 ;
9246 char *kwnames[] = {
9247 (char *) "self",(char *) "fs",(char *) "location", NULL
9248 };
9249
9250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9252 if (SWIG_arg_fail(1)) SWIG_fail;
9253 {
9254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9255 if (SWIG_arg_fail(2)) SWIG_fail;
9256 if (arg2 == NULL) {
9257 SWIG_null_ref("wxFileSystem");
9258 }
9259 if (SWIG_arg_fail(2)) SWIG_fail;
9260 }
9261 {
9262 arg3 = wxString_in_helper(obj2);
9263 if (arg3 == NULL) SWIG_fail;
9264 temp3 = true;
9265 }
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 {
9274 resultobj = wxPyMake_wxObject(result, 1);
9275 }
9276 {
9277 if (temp3)
9278 delete arg3;
9279 }
9280 return resultobj;
9281 fail:
9282 {
9283 if (temp3)
9284 delete arg3;
9285 }
9286 return NULL;
9287 }
9288
9289
9290 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9291 PyObject *obj;
9292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9293 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9294 Py_INCREF(obj);
9295 return Py_BuildValue((char *)"");
9296 }
9297 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9298 PyObject *resultobj;
9299 wxZipFSHandler *result;
9300 char *kwnames[] = {
9301 NULL
9302 };
9303
9304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (wxZipFSHandler *)new wxZipFSHandler();
9308
9309 wxPyEndAllowThreads(__tstate);
9310 if (PyErr_Occurred()) SWIG_fail;
9311 }
9312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9313 return resultobj;
9314 fail:
9315 return NULL;
9316 }
9317
9318
9319 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9320 PyObject *resultobj;
9321 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9322 wxString *arg2 = 0 ;
9323 bool result;
9324 bool temp2 = false ;
9325 PyObject * obj0 = 0 ;
9326 PyObject * obj1 = 0 ;
9327 char *kwnames[] = {
9328 (char *) "self",(char *) "location", NULL
9329 };
9330
9331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9333 if (SWIG_arg_fail(1)) SWIG_fail;
9334 {
9335 arg2 = wxString_in_helper(obj1);
9336 if (arg2 == NULL) SWIG_fail;
9337 temp2 = true;
9338 }
9339 {
9340 PyThreadState* __tstate = wxPyBeginAllowThreads();
9341 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9342
9343 wxPyEndAllowThreads(__tstate);
9344 if (PyErr_Occurred()) SWIG_fail;
9345 }
9346 {
9347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9348 }
9349 {
9350 if (temp2)
9351 delete arg2;
9352 }
9353 return resultobj;
9354 fail:
9355 {
9356 if (temp2)
9357 delete arg2;
9358 }
9359 return NULL;
9360 }
9361
9362
9363 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9364 PyObject *resultobj;
9365 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9366 wxFileSystem *arg2 = 0 ;
9367 wxString *arg3 = 0 ;
9368 wxFSFile *result;
9369 bool temp3 = false ;
9370 PyObject * obj0 = 0 ;
9371 PyObject * obj1 = 0 ;
9372 PyObject * obj2 = 0 ;
9373 char *kwnames[] = {
9374 (char *) "self",(char *) "fs",(char *) "location", NULL
9375 };
9376
9377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9379 if (SWIG_arg_fail(1)) SWIG_fail;
9380 {
9381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9382 if (SWIG_arg_fail(2)) SWIG_fail;
9383 if (arg2 == NULL) {
9384 SWIG_null_ref("wxFileSystem");
9385 }
9386 if (SWIG_arg_fail(2)) SWIG_fail;
9387 }
9388 {
9389 arg3 = wxString_in_helper(obj2);
9390 if (arg3 == NULL) SWIG_fail;
9391 temp3 = true;
9392 }
9393 {
9394 PyThreadState* __tstate = wxPyBeginAllowThreads();
9395 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9396
9397 wxPyEndAllowThreads(__tstate);
9398 if (PyErr_Occurred()) SWIG_fail;
9399 }
9400 {
9401 resultobj = wxPyMake_wxObject(result, 1);
9402 }
9403 {
9404 if (temp3)
9405 delete arg3;
9406 }
9407 return resultobj;
9408 fail:
9409 {
9410 if (temp3)
9411 delete arg3;
9412 }
9413 return NULL;
9414 }
9415
9416
9417 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9418 PyObject *resultobj;
9419 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9420 wxString *arg2 = 0 ;
9421 int arg3 = (int) 0 ;
9422 wxString result;
9423 bool temp2 = false ;
9424 PyObject * obj0 = 0 ;
9425 PyObject * obj1 = 0 ;
9426 PyObject * obj2 = 0 ;
9427 char *kwnames[] = {
9428 (char *) "self",(char *) "spec",(char *) "flags", NULL
9429 };
9430
9431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9433 if (SWIG_arg_fail(1)) SWIG_fail;
9434 {
9435 arg2 = wxString_in_helper(obj1);
9436 if (arg2 == NULL) SWIG_fail;
9437 temp2 = true;
9438 }
9439 if (obj2) {
9440 {
9441 arg3 = (int)(SWIG_As_int(obj2));
9442 if (SWIG_arg_fail(3)) SWIG_fail;
9443 }
9444 }
9445 {
9446 PyThreadState* __tstate = wxPyBeginAllowThreads();
9447 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9448
9449 wxPyEndAllowThreads(__tstate);
9450 if (PyErr_Occurred()) SWIG_fail;
9451 }
9452 {
9453 #if wxUSE_UNICODE
9454 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9455 #else
9456 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9457 #endif
9458 }
9459 {
9460 if (temp2)
9461 delete arg2;
9462 }
9463 return resultobj;
9464 fail:
9465 {
9466 if (temp2)
9467 delete arg2;
9468 }
9469 return NULL;
9470 }
9471
9472
9473 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9474 PyObject *resultobj;
9475 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9476 wxString result;
9477 PyObject * obj0 = 0 ;
9478 char *kwnames[] = {
9479 (char *) "self", NULL
9480 };
9481
9482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9484 if (SWIG_arg_fail(1)) SWIG_fail;
9485 {
9486 PyThreadState* __tstate = wxPyBeginAllowThreads();
9487 result = (arg1)->FindNext();
9488
9489 wxPyEndAllowThreads(__tstate);
9490 if (PyErr_Occurred()) SWIG_fail;
9491 }
9492 {
9493 #if wxUSE_UNICODE
9494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9495 #else
9496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9497 #endif
9498 }
9499 return resultobj;
9500 fail:
9501 return NULL;
9502 }
9503
9504
9505 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9506 PyObject *obj;
9507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9508 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9509 Py_INCREF(obj);
9510 return Py_BuildValue((char *)"");
9511 }
9512 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9513 PyObject *resultobj;
9514 wxString *arg1 = 0 ;
9515 wxImage *arg2 = 0 ;
9516 long arg3 ;
9517 bool temp1 = false ;
9518 PyObject * obj0 = 0 ;
9519 PyObject * obj1 = 0 ;
9520 PyObject * obj2 = 0 ;
9521 char *kwnames[] = {
9522 (char *) "filename",(char *) "image",(char *) "type", NULL
9523 };
9524
9525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9526 {
9527 arg1 = wxString_in_helper(obj0);
9528 if (arg1 == NULL) SWIG_fail;
9529 temp1 = true;
9530 }
9531 {
9532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9533 if (SWIG_arg_fail(2)) SWIG_fail;
9534 if (arg2 == NULL) {
9535 SWIG_null_ref("wxImage");
9536 }
9537 if (SWIG_arg_fail(2)) SWIG_fail;
9538 }
9539 {
9540 arg3 = (long)(SWIG_As_long(obj2));
9541 if (SWIG_arg_fail(3)) SWIG_fail;
9542 }
9543 {
9544 PyThreadState* __tstate = wxPyBeginAllowThreads();
9545 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9546
9547 wxPyEndAllowThreads(__tstate);
9548 if (PyErr_Occurred()) SWIG_fail;
9549 }
9550 Py_INCREF(Py_None); resultobj = Py_None;
9551 {
9552 if (temp1)
9553 delete arg1;
9554 }
9555 return resultobj;
9556 fail:
9557 {
9558 if (temp1)
9559 delete arg1;
9560 }
9561 return NULL;
9562 }
9563
9564
9565 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9566 PyObject *resultobj;
9567 wxString *arg1 = 0 ;
9568 wxBitmap *arg2 = 0 ;
9569 long arg3 ;
9570 bool temp1 = false ;
9571 PyObject * obj0 = 0 ;
9572 PyObject * obj1 = 0 ;
9573 PyObject * obj2 = 0 ;
9574 char *kwnames[] = {
9575 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9576 };
9577
9578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9579 {
9580 arg1 = wxString_in_helper(obj0);
9581 if (arg1 == NULL) SWIG_fail;
9582 temp1 = true;
9583 }
9584 {
9585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9586 if (SWIG_arg_fail(2)) SWIG_fail;
9587 if (arg2 == NULL) {
9588 SWIG_null_ref("wxBitmap");
9589 }
9590 if (SWIG_arg_fail(2)) SWIG_fail;
9591 }
9592 {
9593 arg3 = (long)(SWIG_As_long(obj2));
9594 if (SWIG_arg_fail(3)) SWIG_fail;
9595 }
9596 {
9597 PyThreadState* __tstate = wxPyBeginAllowThreads();
9598 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9599
9600 wxPyEndAllowThreads(__tstate);
9601 if (PyErr_Occurred()) SWIG_fail;
9602 }
9603 Py_INCREF(Py_None); resultobj = Py_None;
9604 {
9605 if (temp1)
9606 delete arg1;
9607 }
9608 return resultobj;
9609 fail:
9610 {
9611 if (temp1)
9612 delete arg1;
9613 }
9614 return NULL;
9615 }
9616
9617
9618 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9619 PyObject *resultobj;
9620 wxString *arg1 = 0 ;
9621 PyObject *arg2 = (PyObject *) 0 ;
9622 bool temp1 = false ;
9623 PyObject * obj0 = 0 ;
9624 PyObject * obj1 = 0 ;
9625 char *kwnames[] = {
9626 (char *) "filename",(char *) "data", NULL
9627 };
9628
9629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9630 {
9631 arg1 = wxString_in_helper(obj0);
9632 if (arg1 == NULL) SWIG_fail;
9633 temp1 = true;
9634 }
9635 arg2 = obj1;
9636 {
9637 PyThreadState* __tstate = wxPyBeginAllowThreads();
9638 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9639
9640 wxPyEndAllowThreads(__tstate);
9641 if (PyErr_Occurred()) SWIG_fail;
9642 }
9643 Py_INCREF(Py_None); resultobj = Py_None;
9644 {
9645 if (temp1)
9646 delete arg1;
9647 }
9648 return resultobj;
9649 fail:
9650 {
9651 if (temp1)
9652 delete arg1;
9653 }
9654 return NULL;
9655 }
9656
9657
9658 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9659 PyObject *resultobj;
9660 wxMemoryFSHandler *result;
9661 char *kwnames[] = {
9662 NULL
9663 };
9664
9665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9666 {
9667 PyThreadState* __tstate = wxPyBeginAllowThreads();
9668 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9669
9670 wxPyEndAllowThreads(__tstate);
9671 if (PyErr_Occurred()) SWIG_fail;
9672 }
9673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9674 return resultobj;
9675 fail:
9676 return NULL;
9677 }
9678
9679
9680 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9681 PyObject *resultobj;
9682 wxString *arg1 = 0 ;
9683 bool temp1 = false ;
9684 PyObject * obj0 = 0 ;
9685 char *kwnames[] = {
9686 (char *) "filename", NULL
9687 };
9688
9689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9690 {
9691 arg1 = wxString_in_helper(obj0);
9692 if (arg1 == NULL) SWIG_fail;
9693 temp1 = true;
9694 }
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9698
9699 wxPyEndAllowThreads(__tstate);
9700 if (PyErr_Occurred()) SWIG_fail;
9701 }
9702 Py_INCREF(Py_None); resultobj = Py_None;
9703 {
9704 if (temp1)
9705 delete arg1;
9706 }
9707 return resultobj;
9708 fail:
9709 {
9710 if (temp1)
9711 delete arg1;
9712 }
9713 return NULL;
9714 }
9715
9716
9717 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9718 PyObject *resultobj;
9719 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9720 wxString *arg2 = 0 ;
9721 bool result;
9722 bool temp2 = false ;
9723 PyObject * obj0 = 0 ;
9724 PyObject * obj1 = 0 ;
9725 char *kwnames[] = {
9726 (char *) "self",(char *) "location", NULL
9727 };
9728
9729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9731 if (SWIG_arg_fail(1)) SWIG_fail;
9732 {
9733 arg2 = wxString_in_helper(obj1);
9734 if (arg2 == NULL) SWIG_fail;
9735 temp2 = true;
9736 }
9737 {
9738 PyThreadState* __tstate = wxPyBeginAllowThreads();
9739 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9740
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 {
9745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9746 }
9747 {
9748 if (temp2)
9749 delete arg2;
9750 }
9751 return resultobj;
9752 fail:
9753 {
9754 if (temp2)
9755 delete arg2;
9756 }
9757 return NULL;
9758 }
9759
9760
9761 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9762 PyObject *resultobj;
9763 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9764 wxFileSystem *arg2 = 0 ;
9765 wxString *arg3 = 0 ;
9766 wxFSFile *result;
9767 bool temp3 = false ;
9768 PyObject * obj0 = 0 ;
9769 PyObject * obj1 = 0 ;
9770 PyObject * obj2 = 0 ;
9771 char *kwnames[] = {
9772 (char *) "self",(char *) "fs",(char *) "location", NULL
9773 };
9774
9775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9777 if (SWIG_arg_fail(1)) SWIG_fail;
9778 {
9779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9780 if (SWIG_arg_fail(2)) SWIG_fail;
9781 if (arg2 == NULL) {
9782 SWIG_null_ref("wxFileSystem");
9783 }
9784 if (SWIG_arg_fail(2)) SWIG_fail;
9785 }
9786 {
9787 arg3 = wxString_in_helper(obj2);
9788 if (arg3 == NULL) SWIG_fail;
9789 temp3 = true;
9790 }
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9794
9795 wxPyEndAllowThreads(__tstate);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 {
9799 resultobj = wxPyMake_wxObject(result, 1);
9800 }
9801 {
9802 if (temp3)
9803 delete arg3;
9804 }
9805 return resultobj;
9806 fail:
9807 {
9808 if (temp3)
9809 delete arg3;
9810 }
9811 return NULL;
9812 }
9813
9814
9815 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9816 PyObject *resultobj;
9817 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9818 wxString *arg2 = 0 ;
9819 int arg3 = (int) 0 ;
9820 wxString result;
9821 bool temp2 = false ;
9822 PyObject * obj0 = 0 ;
9823 PyObject * obj1 = 0 ;
9824 PyObject * obj2 = 0 ;
9825 char *kwnames[] = {
9826 (char *) "self",(char *) "spec",(char *) "flags", NULL
9827 };
9828
9829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9831 if (SWIG_arg_fail(1)) SWIG_fail;
9832 {
9833 arg2 = wxString_in_helper(obj1);
9834 if (arg2 == NULL) SWIG_fail;
9835 temp2 = true;
9836 }
9837 if (obj2) {
9838 {
9839 arg3 = (int)(SWIG_As_int(obj2));
9840 if (SWIG_arg_fail(3)) SWIG_fail;
9841 }
9842 }
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9846
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 {
9851 #if wxUSE_UNICODE
9852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9853 #else
9854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9855 #endif
9856 }
9857 {
9858 if (temp2)
9859 delete arg2;
9860 }
9861 return resultobj;
9862 fail:
9863 {
9864 if (temp2)
9865 delete arg2;
9866 }
9867 return NULL;
9868 }
9869
9870
9871 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9874 wxString result;
9875 PyObject * obj0 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "self", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9882 if (SWIG_arg_fail(1)) SWIG_fail;
9883 {
9884 PyThreadState* __tstate = wxPyBeginAllowThreads();
9885 result = (arg1)->FindNext();
9886
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 {
9891 #if wxUSE_UNICODE
9892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9893 #else
9894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9895 #endif
9896 }
9897 return resultobj;
9898 fail:
9899 return NULL;
9900 }
9901
9902
9903 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9904 PyObject *obj;
9905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9906 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9907 Py_INCREF(obj);
9908 return Py_BuildValue((char *)"");
9909 }
9910 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9911 PyObject *resultobj;
9912 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9913 wxString result;
9914 PyObject * obj0 = 0 ;
9915 char *kwnames[] = {
9916 (char *) "self", NULL
9917 };
9918
9919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9921 if (SWIG_arg_fail(1)) SWIG_fail;
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 result = (arg1)->GetName();
9925
9926 wxPyEndAllowThreads(__tstate);
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 {
9930 #if wxUSE_UNICODE
9931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9932 #else
9933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9934 #endif
9935 }
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9943 PyObject *resultobj;
9944 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9945 wxString result;
9946 PyObject * obj0 = 0 ;
9947 char *kwnames[] = {
9948 (char *) "self", NULL
9949 };
9950
9951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9953 if (SWIG_arg_fail(1)) SWIG_fail;
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 result = (arg1)->GetExtension();
9957
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 {
9962 #if wxUSE_UNICODE
9963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9964 #else
9965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9966 #endif
9967 }
9968 return resultobj;
9969 fail:
9970 return NULL;
9971 }
9972
9973
9974 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9975 PyObject *resultobj;
9976 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9977 long result;
9978 PyObject * obj0 = 0 ;
9979 char *kwnames[] = {
9980 (char *) "self", NULL
9981 };
9982
9983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9985 if (SWIG_arg_fail(1)) SWIG_fail;
9986 {
9987 PyThreadState* __tstate = wxPyBeginAllowThreads();
9988 result = (long)(arg1)->GetType();
9989
9990 wxPyEndAllowThreads(__tstate);
9991 if (PyErr_Occurred()) SWIG_fail;
9992 }
9993 {
9994 resultobj = SWIG_From_long((long)(result));
9995 }
9996 return resultobj;
9997 fail:
9998 return NULL;
9999 }
10000
10001
10002 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10003 PyObject *resultobj;
10004 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10005 wxString result;
10006 PyObject * obj0 = 0 ;
10007 char *kwnames[] = {
10008 (char *) "self", NULL
10009 };
10010
10011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10013 if (SWIG_arg_fail(1)) SWIG_fail;
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 result = (arg1)->GetMimeType();
10017
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 {
10022 #if wxUSE_UNICODE
10023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10024 #else
10025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10026 #endif
10027 }
10028 return resultobj;
10029 fail:
10030 return NULL;
10031 }
10032
10033
10034 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10035 PyObject *resultobj;
10036 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10037 wxString *arg2 = 0 ;
10038 bool result;
10039 bool temp2 = false ;
10040 PyObject * obj0 = 0 ;
10041 PyObject * obj1 = 0 ;
10042 char *kwnames[] = {
10043 (char *) "self",(char *) "name", NULL
10044 };
10045
10046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10048 if (SWIG_arg_fail(1)) SWIG_fail;
10049 {
10050 arg2 = wxString_in_helper(obj1);
10051 if (arg2 == NULL) SWIG_fail;
10052 temp2 = true;
10053 }
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10057
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 {
10062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10063 }
10064 {
10065 if (temp2)
10066 delete arg2;
10067 }
10068 return resultobj;
10069 fail:
10070 {
10071 if (temp2)
10072 delete arg2;
10073 }
10074 return NULL;
10075 }
10076
10077
10078 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10079 PyObject *resultobj;
10080 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10081 wxString *arg2 = 0 ;
10082 bool temp2 = false ;
10083 PyObject * obj0 = 0 ;
10084 PyObject * obj1 = 0 ;
10085 char *kwnames[] = {
10086 (char *) "self",(char *) "name", NULL
10087 };
10088
10089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10091 if (SWIG_arg_fail(1)) SWIG_fail;
10092 {
10093 arg2 = wxString_in_helper(obj1);
10094 if (arg2 == NULL) SWIG_fail;
10095 temp2 = true;
10096 }
10097 {
10098 PyThreadState* __tstate = wxPyBeginAllowThreads();
10099 (arg1)->SetName((wxString const &)*arg2);
10100
10101 wxPyEndAllowThreads(__tstate);
10102 if (PyErr_Occurred()) SWIG_fail;
10103 }
10104 Py_INCREF(Py_None); resultobj = Py_None;
10105 {
10106 if (temp2)
10107 delete arg2;
10108 }
10109 return resultobj;
10110 fail:
10111 {
10112 if (temp2)
10113 delete arg2;
10114 }
10115 return NULL;
10116 }
10117
10118
10119 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10120 PyObject *resultobj;
10121 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10122 wxString *arg2 = 0 ;
10123 bool temp2 = false ;
10124 PyObject * obj0 = 0 ;
10125 PyObject * obj1 = 0 ;
10126 char *kwnames[] = {
10127 (char *) "self",(char *) "extension", NULL
10128 };
10129
10130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10132 if (SWIG_arg_fail(1)) SWIG_fail;
10133 {
10134 arg2 = wxString_in_helper(obj1);
10135 if (arg2 == NULL) SWIG_fail;
10136 temp2 = true;
10137 }
10138 {
10139 PyThreadState* __tstate = wxPyBeginAllowThreads();
10140 (arg1)->SetExtension((wxString const &)*arg2);
10141
10142 wxPyEndAllowThreads(__tstate);
10143 if (PyErr_Occurred()) SWIG_fail;
10144 }
10145 Py_INCREF(Py_None); resultobj = Py_None;
10146 {
10147 if (temp2)
10148 delete arg2;
10149 }
10150 return resultobj;
10151 fail:
10152 {
10153 if (temp2)
10154 delete arg2;
10155 }
10156 return NULL;
10157 }
10158
10159
10160 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10161 PyObject *resultobj;
10162 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10163 long arg2 ;
10164 PyObject * obj0 = 0 ;
10165 PyObject * obj1 = 0 ;
10166 char *kwnames[] = {
10167 (char *) "self",(char *) "type", NULL
10168 };
10169
10170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10172 if (SWIG_arg_fail(1)) SWIG_fail;
10173 {
10174 arg2 = (long)(SWIG_As_long(obj1));
10175 if (SWIG_arg_fail(2)) SWIG_fail;
10176 }
10177 {
10178 PyThreadState* __tstate = wxPyBeginAllowThreads();
10179 (arg1)->SetType(arg2);
10180
10181 wxPyEndAllowThreads(__tstate);
10182 if (PyErr_Occurred()) SWIG_fail;
10183 }
10184 Py_INCREF(Py_None); resultobj = Py_None;
10185 return resultobj;
10186 fail:
10187 return NULL;
10188 }
10189
10190
10191 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10192 PyObject *resultobj;
10193 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10194 wxString *arg2 = 0 ;
10195 bool temp2 = false ;
10196 PyObject * obj0 = 0 ;
10197 PyObject * obj1 = 0 ;
10198 char *kwnames[] = {
10199 (char *) "self",(char *) "mimetype", NULL
10200 };
10201
10202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10204 if (SWIG_arg_fail(1)) SWIG_fail;
10205 {
10206 arg2 = wxString_in_helper(obj1);
10207 if (arg2 == NULL) SWIG_fail;
10208 temp2 = true;
10209 }
10210 {
10211 PyThreadState* __tstate = wxPyBeginAllowThreads();
10212 (arg1)->SetMimeType((wxString const &)*arg2);
10213
10214 wxPyEndAllowThreads(__tstate);
10215 if (PyErr_Occurred()) SWIG_fail;
10216 }
10217 Py_INCREF(Py_None); resultobj = Py_None;
10218 {
10219 if (temp2)
10220 delete arg2;
10221 }
10222 return resultobj;
10223 fail:
10224 {
10225 if (temp2)
10226 delete arg2;
10227 }
10228 return NULL;
10229 }
10230
10231
10232 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10233 PyObject *obj;
10234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10235 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10236 Py_INCREF(obj);
10237 return Py_BuildValue((char *)"");
10238 }
10239 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10240 PyObject *resultobj;
10241 wxPyImageHandler *result;
10242 char *kwnames[] = {
10243 NULL
10244 };
10245
10246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10247 {
10248 PyThreadState* __tstate = wxPyBeginAllowThreads();
10249 result = (wxPyImageHandler *)new wxPyImageHandler();
10250
10251 wxPyEndAllowThreads(__tstate);
10252 if (PyErr_Occurred()) SWIG_fail;
10253 }
10254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10255 return resultobj;
10256 fail:
10257 return NULL;
10258 }
10259
10260
10261 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10262 PyObject *resultobj;
10263 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10264 PyObject *arg2 = (PyObject *) 0 ;
10265 PyObject * obj0 = 0 ;
10266 PyObject * obj1 = 0 ;
10267 char *kwnames[] = {
10268 (char *) "self",(char *) "self", NULL
10269 };
10270
10271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10273 if (SWIG_arg_fail(1)) SWIG_fail;
10274 arg2 = obj1;
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 (arg1)->_SetSelf(arg2);
10278
10279 wxPyEndAllowThreads(__tstate);
10280 if (PyErr_Occurred()) SWIG_fail;
10281 }
10282 Py_INCREF(Py_None); resultobj = Py_None;
10283 return resultobj;
10284 fail:
10285 return NULL;
10286 }
10287
10288
10289 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10290 PyObject *obj;
10291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10292 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10293 Py_INCREF(obj);
10294 return Py_BuildValue((char *)"");
10295 }
10296 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10297 PyObject *resultobj;
10298 wxImageHistogram *result;
10299 char *kwnames[] = {
10300 NULL
10301 };
10302
10303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10304 {
10305 PyThreadState* __tstate = wxPyBeginAllowThreads();
10306 result = (wxImageHistogram *)new wxImageHistogram();
10307
10308 wxPyEndAllowThreads(__tstate);
10309 if (PyErr_Occurred()) SWIG_fail;
10310 }
10311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10312 return resultobj;
10313 fail:
10314 return NULL;
10315 }
10316
10317
10318 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10319 PyObject *resultobj;
10320 byte arg1 ;
10321 byte arg2 ;
10322 byte arg3 ;
10323 unsigned long result;
10324 PyObject * obj0 = 0 ;
10325 PyObject * obj1 = 0 ;
10326 PyObject * obj2 = 0 ;
10327 char *kwnames[] = {
10328 (char *) "r",(char *) "g",(char *) "b", NULL
10329 };
10330
10331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10332 {
10333 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10334 if (SWIG_arg_fail(1)) SWIG_fail;
10335 }
10336 {
10337 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10338 if (SWIG_arg_fail(2)) SWIG_fail;
10339 }
10340 {
10341 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10342 if (SWIG_arg_fail(3)) SWIG_fail;
10343 }
10344 {
10345 PyThreadState* __tstate = wxPyBeginAllowThreads();
10346 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10347
10348 wxPyEndAllowThreads(__tstate);
10349 if (PyErr_Occurred()) SWIG_fail;
10350 }
10351 {
10352 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10353 }
10354 return resultobj;
10355 fail:
10356 return NULL;
10357 }
10358
10359
10360 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj;
10362 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10363 byte *arg2 = (byte *) 0 ;
10364 byte *arg3 = (byte *) 0 ;
10365 byte *arg4 = (byte *) 0 ;
10366 byte arg5 = (byte) 1 ;
10367 byte arg6 = (byte) 0 ;
10368 byte arg7 = (byte) 0 ;
10369 bool result;
10370 byte temp2 ;
10371 int res2 = 0 ;
10372 byte temp3 ;
10373 int res3 = 0 ;
10374 byte temp4 ;
10375 int res4 = 0 ;
10376 PyObject * obj0 = 0 ;
10377 PyObject * obj1 = 0 ;
10378 PyObject * obj2 = 0 ;
10379 PyObject * obj3 = 0 ;
10380 char *kwnames[] = {
10381 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10382 };
10383
10384 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10385 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10386 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10389 if (SWIG_arg_fail(1)) SWIG_fail;
10390 if (obj1) {
10391 {
10392 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10393 if (SWIG_arg_fail(5)) SWIG_fail;
10394 }
10395 }
10396 if (obj2) {
10397 {
10398 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10399 if (SWIG_arg_fail(6)) SWIG_fail;
10400 }
10401 }
10402 if (obj3) {
10403 {
10404 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10405 if (SWIG_arg_fail(7)) SWIG_fail;
10406 }
10407 }
10408 {
10409 PyThreadState* __tstate = wxPyBeginAllowThreads();
10410 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10411
10412 wxPyEndAllowThreads(__tstate);
10413 if (PyErr_Occurred()) SWIG_fail;
10414 }
10415 {
10416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10417 }
10418 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10419 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10420 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10421 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10422 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10423 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10424 return resultobj;
10425 fail:
10426 return NULL;
10427 }
10428
10429
10430 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj;
10432 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10433 unsigned long arg2 ;
10434 unsigned long result;
10435 PyObject * obj0 = 0 ;
10436 PyObject * obj1 = 0 ;
10437 char *kwnames[] = {
10438 (char *) "self",(char *) "key", NULL
10439 };
10440
10441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10443 if (SWIG_arg_fail(1)) SWIG_fail;
10444 {
10445 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10446 if (SWIG_arg_fail(2)) SWIG_fail;
10447 }
10448 {
10449 PyThreadState* __tstate = wxPyBeginAllowThreads();
10450 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10451
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 {
10456 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10457 }
10458 return resultobj;
10459 fail:
10460 return NULL;
10461 }
10462
10463
10464 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10465 PyObject *resultobj;
10466 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10467 byte arg2 ;
10468 byte arg3 ;
10469 byte arg4 ;
10470 unsigned long result;
10471 PyObject * obj0 = 0 ;
10472 PyObject * obj1 = 0 ;
10473 PyObject * obj2 = 0 ;
10474 PyObject * obj3 = 0 ;
10475 char *kwnames[] = {
10476 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10477 };
10478
10479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10481 if (SWIG_arg_fail(1)) SWIG_fail;
10482 {
10483 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10484 if (SWIG_arg_fail(2)) SWIG_fail;
10485 }
10486 {
10487 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10488 if (SWIG_arg_fail(3)) SWIG_fail;
10489 }
10490 {
10491 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10492 if (SWIG_arg_fail(4)) SWIG_fail;
10493 }
10494 {
10495 PyThreadState* __tstate = wxPyBeginAllowThreads();
10496 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10497
10498 wxPyEndAllowThreads(__tstate);
10499 if (PyErr_Occurred()) SWIG_fail;
10500 }
10501 {
10502 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10503 }
10504 return resultobj;
10505 fail:
10506 return NULL;
10507 }
10508
10509
10510 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10511 PyObject *resultobj;
10512 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10513 wxColour *arg2 = 0 ;
10514 unsigned long result;
10515 wxColour temp2 ;
10516 PyObject * obj0 = 0 ;
10517 PyObject * obj1 = 0 ;
10518 char *kwnames[] = {
10519 (char *) "self",(char *) "colour", NULL
10520 };
10521
10522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10524 if (SWIG_arg_fail(1)) SWIG_fail;
10525 {
10526 arg2 = &temp2;
10527 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10528 }
10529 {
10530 PyThreadState* __tstate = wxPyBeginAllowThreads();
10531 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10532
10533 wxPyEndAllowThreads(__tstate);
10534 if (PyErr_Occurred()) SWIG_fail;
10535 }
10536 {
10537 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10538 }
10539 return resultobj;
10540 fail:
10541 return NULL;
10542 }
10543
10544
10545 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10546 PyObject *obj;
10547 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10548 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10549 Py_INCREF(obj);
10550 return Py_BuildValue((char *)"");
10551 }
10552 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj;
10554 byte arg1 = (byte) 0 ;
10555 byte arg2 = (byte) 0 ;
10556 byte arg3 = (byte) 0 ;
10557 wxImage_RGBValue *result;
10558 PyObject * obj0 = 0 ;
10559 PyObject * obj1 = 0 ;
10560 PyObject * obj2 = 0 ;
10561 char *kwnames[] = {
10562 (char *) "r",(char *) "g",(char *) "b", NULL
10563 };
10564
10565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10566 if (obj0) {
10567 {
10568 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10569 if (SWIG_arg_fail(1)) SWIG_fail;
10570 }
10571 }
10572 if (obj1) {
10573 {
10574 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10575 if (SWIG_arg_fail(2)) SWIG_fail;
10576 }
10577 }
10578 if (obj2) {
10579 {
10580 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10581 if (SWIG_arg_fail(3)) SWIG_fail;
10582 }
10583 }
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10587
10588 wxPyEndAllowThreads(__tstate);
10589 if (PyErr_Occurred()) SWIG_fail;
10590 }
10591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10599 PyObject *resultobj;
10600 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10601 byte arg2 ;
10602 PyObject * obj0 = 0 ;
10603 PyObject * obj1 = 0 ;
10604 char *kwnames[] = {
10605 (char *) "self",(char *) "red", NULL
10606 };
10607
10608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10610 if (SWIG_arg_fail(1)) SWIG_fail;
10611 {
10612 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10613 if (SWIG_arg_fail(2)) SWIG_fail;
10614 }
10615 if (arg1) (arg1)->red = arg2;
10616
10617 Py_INCREF(Py_None); resultobj = Py_None;
10618 return resultobj;
10619 fail:
10620 return NULL;
10621 }
10622
10623
10624 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10625 PyObject *resultobj;
10626 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10627 byte result;
10628 PyObject * obj0 = 0 ;
10629 char *kwnames[] = {
10630 (char *) "self", NULL
10631 };
10632
10633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10635 if (SWIG_arg_fail(1)) SWIG_fail;
10636 result = (byte) ((arg1)->red);
10637
10638 {
10639 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10640 }
10641 return resultobj;
10642 fail:
10643 return NULL;
10644 }
10645
10646
10647 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10648 PyObject *resultobj;
10649 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10650 byte arg2 ;
10651 PyObject * obj0 = 0 ;
10652 PyObject * obj1 = 0 ;
10653 char *kwnames[] = {
10654 (char *) "self",(char *) "green", NULL
10655 };
10656
10657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10659 if (SWIG_arg_fail(1)) SWIG_fail;
10660 {
10661 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10662 if (SWIG_arg_fail(2)) SWIG_fail;
10663 }
10664 if (arg1) (arg1)->green = arg2;
10665
10666 Py_INCREF(Py_None); resultobj = Py_None;
10667 return resultobj;
10668 fail:
10669 return NULL;
10670 }
10671
10672
10673 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10674 PyObject *resultobj;
10675 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10676 byte result;
10677 PyObject * obj0 = 0 ;
10678 char *kwnames[] = {
10679 (char *) "self", NULL
10680 };
10681
10682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10684 if (SWIG_arg_fail(1)) SWIG_fail;
10685 result = (byte) ((arg1)->green);
10686
10687 {
10688 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10689 }
10690 return resultobj;
10691 fail:
10692 return NULL;
10693 }
10694
10695
10696 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10697 PyObject *resultobj;
10698 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10699 byte arg2 ;
10700 PyObject * obj0 = 0 ;
10701 PyObject * obj1 = 0 ;
10702 char *kwnames[] = {
10703 (char *) "self",(char *) "blue", NULL
10704 };
10705
10706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10708 if (SWIG_arg_fail(1)) SWIG_fail;
10709 {
10710 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10711 if (SWIG_arg_fail(2)) SWIG_fail;
10712 }
10713 if (arg1) (arg1)->blue = arg2;
10714
10715 Py_INCREF(Py_None); resultobj = Py_None;
10716 return resultobj;
10717 fail:
10718 return NULL;
10719 }
10720
10721
10722 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10723 PyObject *resultobj;
10724 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10725 byte result;
10726 PyObject * obj0 = 0 ;
10727 char *kwnames[] = {
10728 (char *) "self", NULL
10729 };
10730
10731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10733 if (SWIG_arg_fail(1)) SWIG_fail;
10734 result = (byte) ((arg1)->blue);
10735
10736 {
10737 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10738 }
10739 return resultobj;
10740 fail:
10741 return NULL;
10742 }
10743
10744
10745 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10746 PyObject *obj;
10747 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10748 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10749 Py_INCREF(obj);
10750 return Py_BuildValue((char *)"");
10751 }
10752 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10753 PyObject *resultobj;
10754 double arg1 = (double) 0.0 ;
10755 double arg2 = (double) 0.0 ;
10756 double arg3 = (double) 0.0 ;
10757 wxImage_HSVValue *result;
10758 PyObject * obj0 = 0 ;
10759 PyObject * obj1 = 0 ;
10760 PyObject * obj2 = 0 ;
10761 char *kwnames[] = {
10762 (char *) "h",(char *) "s",(char *) "v", NULL
10763 };
10764
10765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10766 if (obj0) {
10767 {
10768 arg1 = (double)(SWIG_As_double(obj0));
10769 if (SWIG_arg_fail(1)) SWIG_fail;
10770 }
10771 }
10772 if (obj1) {
10773 {
10774 arg2 = (double)(SWIG_As_double(obj1));
10775 if (SWIG_arg_fail(2)) SWIG_fail;
10776 }
10777 }
10778 if (obj2) {
10779 {
10780 arg3 = (double)(SWIG_As_double(obj2));
10781 if (SWIG_arg_fail(3)) SWIG_fail;
10782 }
10783 }
10784 {
10785 PyThreadState* __tstate = wxPyBeginAllowThreads();
10786 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10787
10788 wxPyEndAllowThreads(__tstate);
10789 if (PyErr_Occurred()) SWIG_fail;
10790 }
10791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10792 return resultobj;
10793 fail:
10794 return NULL;
10795 }
10796
10797
10798 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10799 PyObject *resultobj;
10800 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10801 double arg2 ;
10802 PyObject * obj0 = 0 ;
10803 PyObject * obj1 = 0 ;
10804 char *kwnames[] = {
10805 (char *) "self",(char *) "hue", NULL
10806 };
10807
10808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10810 if (SWIG_arg_fail(1)) SWIG_fail;
10811 {
10812 arg2 = (double)(SWIG_As_double(obj1));
10813 if (SWIG_arg_fail(2)) SWIG_fail;
10814 }
10815 if (arg1) (arg1)->hue = arg2;
10816
10817 Py_INCREF(Py_None); resultobj = Py_None;
10818 return resultobj;
10819 fail:
10820 return NULL;
10821 }
10822
10823
10824 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10825 PyObject *resultobj;
10826 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10827 double result;
10828 PyObject * obj0 = 0 ;
10829 char *kwnames[] = {
10830 (char *) "self", NULL
10831 };
10832
10833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10835 if (SWIG_arg_fail(1)) SWIG_fail;
10836 result = (double) ((arg1)->hue);
10837
10838 {
10839 resultobj = SWIG_From_double((double)(result));
10840 }
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj;
10849 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10850 double arg2 ;
10851 PyObject * obj0 = 0 ;
10852 PyObject * obj1 = 0 ;
10853 char *kwnames[] = {
10854 (char *) "self",(char *) "saturation", NULL
10855 };
10856
10857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10859 if (SWIG_arg_fail(1)) SWIG_fail;
10860 {
10861 arg2 = (double)(SWIG_As_double(obj1));
10862 if (SWIG_arg_fail(2)) SWIG_fail;
10863 }
10864 if (arg1) (arg1)->saturation = arg2;
10865
10866 Py_INCREF(Py_None); resultobj = Py_None;
10867 return resultobj;
10868 fail:
10869 return NULL;
10870 }
10871
10872
10873 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
10874 PyObject *resultobj;
10875 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10876 double result;
10877 PyObject * obj0 = 0 ;
10878 char *kwnames[] = {
10879 (char *) "self", NULL
10880 };
10881
10882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
10883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10884 if (SWIG_arg_fail(1)) SWIG_fail;
10885 result = (double) ((arg1)->saturation);
10886
10887 {
10888 resultobj = SWIG_From_double((double)(result));
10889 }
10890 return resultobj;
10891 fail:
10892 return NULL;
10893 }
10894
10895
10896 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
10897 PyObject *resultobj;
10898 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10899 double arg2 ;
10900 PyObject * obj0 = 0 ;
10901 PyObject * obj1 = 0 ;
10902 char *kwnames[] = {
10903 (char *) "self",(char *) "value", NULL
10904 };
10905
10906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
10907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10908 if (SWIG_arg_fail(1)) SWIG_fail;
10909 {
10910 arg2 = (double)(SWIG_As_double(obj1));
10911 if (SWIG_arg_fail(2)) SWIG_fail;
10912 }
10913 if (arg1) (arg1)->value = arg2;
10914
10915 Py_INCREF(Py_None); resultobj = Py_None;
10916 return resultobj;
10917 fail:
10918 return NULL;
10919 }
10920
10921
10922 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
10923 PyObject *resultobj;
10924 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10925 double result;
10926 PyObject * obj0 = 0 ;
10927 char *kwnames[] = {
10928 (char *) "self", NULL
10929 };
10930
10931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
10932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10933 if (SWIG_arg_fail(1)) SWIG_fail;
10934 result = (double) ((arg1)->value);
10935
10936 {
10937 resultobj = SWIG_From_double((double)(result));
10938 }
10939 return resultobj;
10940 fail:
10941 return NULL;
10942 }
10943
10944
10945 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
10946 PyObject *obj;
10947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10948 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
10949 Py_INCREF(obj);
10950 return Py_BuildValue((char *)"");
10951 }
10952 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj;
10954 wxString *arg1 = 0 ;
10955 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10956 int arg3 = (int) -1 ;
10957 wxImage *result;
10958 bool temp1 = false ;
10959 PyObject * obj0 = 0 ;
10960 PyObject * obj1 = 0 ;
10961 PyObject * obj2 = 0 ;
10962 char *kwnames[] = {
10963 (char *) "name",(char *) "type",(char *) "index", NULL
10964 };
10965
10966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10967 {
10968 arg1 = wxString_in_helper(obj0);
10969 if (arg1 == NULL) SWIG_fail;
10970 temp1 = true;
10971 }
10972 if (obj1) {
10973 {
10974 arg2 = (long)(SWIG_As_long(obj1));
10975 if (SWIG_arg_fail(2)) SWIG_fail;
10976 }
10977 }
10978 if (obj2) {
10979 {
10980 arg3 = (int)(SWIG_As_int(obj2));
10981 if (SWIG_arg_fail(3)) SWIG_fail;
10982 }
10983 }
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10987
10988 wxPyEndAllowThreads(__tstate);
10989 if (PyErr_Occurred()) SWIG_fail;
10990 }
10991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10992 {
10993 if (temp1)
10994 delete arg1;
10995 }
10996 return resultobj;
10997 fail:
10998 {
10999 if (temp1)
11000 delete arg1;
11001 }
11002 return NULL;
11003 }
11004
11005
11006 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11007 PyObject *resultobj;
11008 wxImage *arg1 = (wxImage *) 0 ;
11009 PyObject * obj0 = 0 ;
11010 char *kwnames[] = {
11011 (char *) "self", NULL
11012 };
11013
11014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11016 if (SWIG_arg_fail(1)) SWIG_fail;
11017 {
11018 PyThreadState* __tstate = wxPyBeginAllowThreads();
11019 delete arg1;
11020
11021 wxPyEndAllowThreads(__tstate);
11022 if (PyErr_Occurred()) SWIG_fail;
11023 }
11024 Py_INCREF(Py_None); resultobj = Py_None;
11025 return resultobj;
11026 fail:
11027 return NULL;
11028 }
11029
11030
11031 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11032 PyObject *resultobj;
11033 wxString *arg1 = 0 ;
11034 wxString *arg2 = 0 ;
11035 int arg3 = (int) -1 ;
11036 wxImage *result;
11037 bool temp1 = false ;
11038 bool temp2 = false ;
11039 PyObject * obj0 = 0 ;
11040 PyObject * obj1 = 0 ;
11041 PyObject * obj2 = 0 ;
11042 char *kwnames[] = {
11043 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11044 };
11045
11046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11047 {
11048 arg1 = wxString_in_helper(obj0);
11049 if (arg1 == NULL) SWIG_fail;
11050 temp1 = true;
11051 }
11052 {
11053 arg2 = wxString_in_helper(obj1);
11054 if (arg2 == NULL) SWIG_fail;
11055 temp2 = true;
11056 }
11057 if (obj2) {
11058 {
11059 arg3 = (int)(SWIG_As_int(obj2));
11060 if (SWIG_arg_fail(3)) SWIG_fail;
11061 }
11062 }
11063 {
11064 PyThreadState* __tstate = wxPyBeginAllowThreads();
11065 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11066
11067 wxPyEndAllowThreads(__tstate);
11068 if (PyErr_Occurred()) SWIG_fail;
11069 }
11070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11071 {
11072 if (temp1)
11073 delete arg1;
11074 }
11075 {
11076 if (temp2)
11077 delete arg2;
11078 }
11079 return resultobj;
11080 fail:
11081 {
11082 if (temp1)
11083 delete arg1;
11084 }
11085 {
11086 if (temp2)
11087 delete arg2;
11088 }
11089 return NULL;
11090 }
11091
11092
11093 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11094 PyObject *resultobj;
11095 wxInputStream *arg1 = 0 ;
11096 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11097 int arg3 = (int) -1 ;
11098 wxImage *result;
11099 wxPyInputStream *temp1 ;
11100 bool created1 ;
11101 PyObject * obj0 = 0 ;
11102 PyObject * obj1 = 0 ;
11103 PyObject * obj2 = 0 ;
11104 char *kwnames[] = {
11105 (char *) "stream",(char *) "type",(char *) "index", NULL
11106 };
11107
11108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11109 {
11110 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11111 arg1 = temp1->m_wxis;
11112 created1 = false;
11113 } else {
11114 PyErr_Clear(); // clear the failure of the wxPyConvert above
11115 arg1 = wxPyCBInputStream_create(obj0, false);
11116 if (arg1 == NULL) {
11117 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11118 SWIG_fail;
11119 }
11120 created1 = true;
11121 }
11122 }
11123 if (obj1) {
11124 {
11125 arg2 = (long)(SWIG_As_long(obj1));
11126 if (SWIG_arg_fail(2)) SWIG_fail;
11127 }
11128 }
11129 if (obj2) {
11130 {
11131 arg3 = (int)(SWIG_As_int(obj2));
11132 if (SWIG_arg_fail(3)) SWIG_fail;
11133 }
11134 }
11135 {
11136 PyThreadState* __tstate = wxPyBeginAllowThreads();
11137 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11138
11139 wxPyEndAllowThreads(__tstate);
11140 if (PyErr_Occurred()) SWIG_fail;
11141 }
11142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11143 {
11144 if (created1) delete arg1;
11145 }
11146 return resultobj;
11147 fail:
11148 {
11149 if (created1) delete arg1;
11150 }
11151 return NULL;
11152 }
11153
11154
11155 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj;
11157 wxInputStream *arg1 = 0 ;
11158 wxString *arg2 = 0 ;
11159 int arg3 = (int) -1 ;
11160 wxImage *result;
11161 wxPyInputStream *temp1 ;
11162 bool created1 ;
11163 bool temp2 = false ;
11164 PyObject * obj0 = 0 ;
11165 PyObject * obj1 = 0 ;
11166 PyObject * obj2 = 0 ;
11167 char *kwnames[] = {
11168 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11169 };
11170
11171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11172 {
11173 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11174 arg1 = temp1->m_wxis;
11175 created1 = false;
11176 } else {
11177 PyErr_Clear(); // clear the failure of the wxPyConvert above
11178 arg1 = wxPyCBInputStream_create(obj0, false);
11179 if (arg1 == NULL) {
11180 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11181 SWIG_fail;
11182 }
11183 created1 = true;
11184 }
11185 }
11186 {
11187 arg2 = wxString_in_helper(obj1);
11188 if (arg2 == NULL) SWIG_fail;
11189 temp2 = true;
11190 }
11191 if (obj2) {
11192 {
11193 arg3 = (int)(SWIG_As_int(obj2));
11194 if (SWIG_arg_fail(3)) SWIG_fail;
11195 }
11196 }
11197 {
11198 PyThreadState* __tstate = wxPyBeginAllowThreads();
11199 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11200
11201 wxPyEndAllowThreads(__tstate);
11202 if (PyErr_Occurred()) SWIG_fail;
11203 }
11204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11205 {
11206 if (created1) delete arg1;
11207 }
11208 {
11209 if (temp2)
11210 delete arg2;
11211 }
11212 return resultobj;
11213 fail:
11214 {
11215 if (created1) delete arg1;
11216 }
11217 {
11218 if (temp2)
11219 delete arg2;
11220 }
11221 return NULL;
11222 }
11223
11224
11225 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11226 PyObject *resultobj;
11227 int arg1 = (int) 0 ;
11228 int arg2 = (int) 0 ;
11229 bool arg3 = (bool) true ;
11230 wxImage *result;
11231 PyObject * obj0 = 0 ;
11232 PyObject * obj1 = 0 ;
11233 PyObject * obj2 = 0 ;
11234 char *kwnames[] = {
11235 (char *) "width",(char *) "height",(char *) "clear", NULL
11236 };
11237
11238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11239 if (obj0) {
11240 {
11241 arg1 = (int)(SWIG_As_int(obj0));
11242 if (SWIG_arg_fail(1)) SWIG_fail;
11243 }
11244 }
11245 if (obj1) {
11246 {
11247 arg2 = (int)(SWIG_As_int(obj1));
11248 if (SWIG_arg_fail(2)) SWIG_fail;
11249 }
11250 }
11251 if (obj2) {
11252 {
11253 arg3 = (bool)(SWIG_As_bool(obj2));
11254 if (SWIG_arg_fail(3)) SWIG_fail;
11255 }
11256 }
11257 {
11258 PyThreadState* __tstate = wxPyBeginAllowThreads();
11259 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11260
11261 wxPyEndAllowThreads(__tstate);
11262 if (PyErr_Occurred()) SWIG_fail;
11263 }
11264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11265 return resultobj;
11266 fail:
11267 return NULL;
11268 }
11269
11270
11271 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11272 PyObject *resultobj;
11273 wxBitmap *arg1 = 0 ;
11274 wxImage *result;
11275 PyObject * obj0 = 0 ;
11276 char *kwnames[] = {
11277 (char *) "bitmap", NULL
11278 };
11279
11280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11281 {
11282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11283 if (SWIG_arg_fail(1)) SWIG_fail;
11284 if (arg1 == NULL) {
11285 SWIG_null_ref("wxBitmap");
11286 }
11287 if (SWIG_arg_fail(1)) SWIG_fail;
11288 }
11289 {
11290 if (!wxPyCheckForApp()) SWIG_fail;
11291 PyThreadState* __tstate = wxPyBeginAllowThreads();
11292 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11293
11294 wxPyEndAllowThreads(__tstate);
11295 if (PyErr_Occurred()) SWIG_fail;
11296 }
11297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11298 return resultobj;
11299 fail:
11300 return NULL;
11301 }
11302
11303
11304 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11305 PyObject *resultobj;
11306 int arg1 ;
11307 int arg2 ;
11308 buffer arg3 ;
11309 int arg4 ;
11310 wxImage *result;
11311 PyObject * obj0 = 0 ;
11312 PyObject * obj1 = 0 ;
11313 PyObject * obj2 = 0 ;
11314 char *kwnames[] = {
11315 (char *) "width",(char *) "height",(char *) "data", NULL
11316 };
11317
11318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11319 {
11320 arg1 = (int)(SWIG_As_int(obj0));
11321 if (SWIG_arg_fail(1)) SWIG_fail;
11322 }
11323 {
11324 arg2 = (int)(SWIG_As_int(obj1));
11325 if (SWIG_arg_fail(2)) SWIG_fail;
11326 }
11327 {
11328 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11329 }
11330 {
11331 PyThreadState* __tstate = wxPyBeginAllowThreads();
11332 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11333
11334 wxPyEndAllowThreads(__tstate);
11335 if (PyErr_Occurred()) SWIG_fail;
11336 }
11337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11338 return resultobj;
11339 fail:
11340 return NULL;
11341 }
11342
11343
11344 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11345 PyObject *resultobj;
11346 int arg1 ;
11347 int arg2 ;
11348 buffer arg3 ;
11349 int arg4 ;
11350 buffer arg5 ;
11351 int arg6 ;
11352 wxImage *result;
11353 PyObject * obj0 = 0 ;
11354 PyObject * obj1 = 0 ;
11355 PyObject * obj2 = 0 ;
11356 PyObject * obj3 = 0 ;
11357 char *kwnames[] = {
11358 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11359 };
11360
11361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11362 {
11363 arg1 = (int)(SWIG_As_int(obj0));
11364 if (SWIG_arg_fail(1)) SWIG_fail;
11365 }
11366 {
11367 arg2 = (int)(SWIG_As_int(obj1));
11368 if (SWIG_arg_fail(2)) SWIG_fail;
11369 }
11370 {
11371 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11372 }
11373 {
11374 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11375 }
11376 {
11377 PyThreadState* __tstate = wxPyBeginAllowThreads();
11378 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11379
11380 wxPyEndAllowThreads(__tstate);
11381 if (PyErr_Occurred()) SWIG_fail;
11382 }
11383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj;
11392 wxImage *arg1 = (wxImage *) 0 ;
11393 int arg2 ;
11394 int arg3 ;
11395 bool arg4 = (bool) true ;
11396 PyObject * obj0 = 0 ;
11397 PyObject * obj1 = 0 ;
11398 PyObject * obj2 = 0 ;
11399 PyObject * obj3 = 0 ;
11400 char *kwnames[] = {
11401 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11402 };
11403
11404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11406 if (SWIG_arg_fail(1)) SWIG_fail;
11407 {
11408 arg2 = (int)(SWIG_As_int(obj1));
11409 if (SWIG_arg_fail(2)) SWIG_fail;
11410 }
11411 {
11412 arg3 = (int)(SWIG_As_int(obj2));
11413 if (SWIG_arg_fail(3)) SWIG_fail;
11414 }
11415 if (obj3) {
11416 {
11417 arg4 = (bool)(SWIG_As_bool(obj3));
11418 if (SWIG_arg_fail(4)) SWIG_fail;
11419 }
11420 }
11421 {
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 (arg1)->Create(arg2,arg3,arg4);
11424
11425 wxPyEndAllowThreads(__tstate);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 Py_INCREF(Py_None); resultobj = Py_None;
11429 return resultobj;
11430 fail:
11431 return NULL;
11432 }
11433
11434
11435 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11436 PyObject *resultobj;
11437 wxImage *arg1 = (wxImage *) 0 ;
11438 PyObject * obj0 = 0 ;
11439 char *kwnames[] = {
11440 (char *) "self", NULL
11441 };
11442
11443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11445 if (SWIG_arg_fail(1)) SWIG_fail;
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 (arg1)->Destroy();
11449
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 Py_INCREF(Py_None); resultobj = Py_None;
11454 return resultobj;
11455 fail:
11456 return NULL;
11457 }
11458
11459
11460 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11461 PyObject *resultobj;
11462 wxImage *arg1 = (wxImage *) 0 ;
11463 int arg2 ;
11464 int arg3 ;
11465 SwigValueWrapper<wxImage > result;
11466 PyObject * obj0 = 0 ;
11467 PyObject * obj1 = 0 ;
11468 PyObject * obj2 = 0 ;
11469 char *kwnames[] = {
11470 (char *) "self",(char *) "width",(char *) "height", NULL
11471 };
11472
11473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11475 if (SWIG_arg_fail(1)) SWIG_fail;
11476 {
11477 arg2 = (int)(SWIG_As_int(obj1));
11478 if (SWIG_arg_fail(2)) SWIG_fail;
11479 }
11480 {
11481 arg3 = (int)(SWIG_As_int(obj2));
11482 if (SWIG_arg_fail(3)) SWIG_fail;
11483 }
11484 {
11485 PyThreadState* __tstate = wxPyBeginAllowThreads();
11486 result = (arg1)->Scale(arg2,arg3);
11487
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 {
11492 wxImage * resultptr;
11493 resultptr = new wxImage((wxImage &)(result));
11494 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11495 }
11496 return resultobj;
11497 fail:
11498 return NULL;
11499 }
11500
11501
11502 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11503 PyObject *resultobj;
11504 wxImage *arg1 = (wxImage *) 0 ;
11505 int arg2 ;
11506 int arg3 ;
11507 SwigValueWrapper<wxImage > result;
11508 PyObject * obj0 = 0 ;
11509 PyObject * obj1 = 0 ;
11510 PyObject * obj2 = 0 ;
11511 char *kwnames[] = {
11512 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11513 };
11514
11515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11517 if (SWIG_arg_fail(1)) SWIG_fail;
11518 {
11519 arg2 = (int)(SWIG_As_int(obj1));
11520 if (SWIG_arg_fail(2)) SWIG_fail;
11521 }
11522 {
11523 arg3 = (int)(SWIG_As_int(obj2));
11524 if (SWIG_arg_fail(3)) SWIG_fail;
11525 }
11526 {
11527 PyThreadState* __tstate = wxPyBeginAllowThreads();
11528 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11529
11530 wxPyEndAllowThreads(__tstate);
11531 if (PyErr_Occurred()) SWIG_fail;
11532 }
11533 {
11534 wxImage * resultptr;
11535 resultptr = new wxImage((wxImage &)(result));
11536 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11537 }
11538 return resultobj;
11539 fail:
11540 return NULL;
11541 }
11542
11543
11544 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11545 PyObject *resultobj;
11546 wxImage *arg1 = (wxImage *) 0 ;
11547 int arg2 ;
11548 int arg3 ;
11549 wxImage *result;
11550 PyObject * obj0 = 0 ;
11551 PyObject * obj1 = 0 ;
11552 PyObject * obj2 = 0 ;
11553 char *kwnames[] = {
11554 (char *) "self",(char *) "width",(char *) "height", NULL
11555 };
11556
11557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11559 if (SWIG_arg_fail(1)) SWIG_fail;
11560 {
11561 arg2 = (int)(SWIG_As_int(obj1));
11562 if (SWIG_arg_fail(2)) SWIG_fail;
11563 }
11564 {
11565 arg3 = (int)(SWIG_As_int(obj2));
11566 if (SWIG_arg_fail(3)) SWIG_fail;
11567 }
11568 {
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 {
11571 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11572 result = (wxImage *) &_result_ref;
11573 }
11574
11575 wxPyEndAllowThreads(__tstate);
11576 if (PyErr_Occurred()) SWIG_fail;
11577 }
11578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11579 return resultobj;
11580 fail:
11581 return NULL;
11582 }
11583
11584
11585 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11586 PyObject *resultobj;
11587 wxImage *arg1 = (wxImage *) 0 ;
11588 wxSize *arg2 = 0 ;
11589 wxPoint *arg3 = 0 ;
11590 int arg4 = (int) -1 ;
11591 int arg5 = (int) -1 ;
11592 int arg6 = (int) -1 ;
11593 wxImage *result;
11594 wxSize temp2 ;
11595 wxPoint temp3 ;
11596 PyObject * obj0 = 0 ;
11597 PyObject * obj1 = 0 ;
11598 PyObject * obj2 = 0 ;
11599 PyObject * obj3 = 0 ;
11600 PyObject * obj4 = 0 ;
11601 PyObject * obj5 = 0 ;
11602 char *kwnames[] = {
11603 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11604 };
11605
11606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11608 if (SWIG_arg_fail(1)) SWIG_fail;
11609 {
11610 arg2 = &temp2;
11611 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11612 }
11613 {
11614 arg3 = &temp3;
11615 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11616 }
11617 if (obj3) {
11618 {
11619 arg4 = (int)(SWIG_As_int(obj3));
11620 if (SWIG_arg_fail(4)) SWIG_fail;
11621 }
11622 }
11623 if (obj4) {
11624 {
11625 arg5 = (int)(SWIG_As_int(obj4));
11626 if (SWIG_arg_fail(5)) SWIG_fail;
11627 }
11628 }
11629 if (obj5) {
11630 {
11631 arg6 = (int)(SWIG_As_int(obj5));
11632 if (SWIG_arg_fail(6)) SWIG_fail;
11633 }
11634 }
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 {
11638 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11639 result = (wxImage *) &_result_ref;
11640 }
11641
11642 wxPyEndAllowThreads(__tstate);
11643 if (PyErr_Occurred()) SWIG_fail;
11644 }
11645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11646 return resultobj;
11647 fail:
11648 return NULL;
11649 }
11650
11651
11652 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11653 PyObject *resultobj;
11654 wxImage *arg1 = (wxImage *) 0 ;
11655 int arg2 ;
11656 int arg3 ;
11657 byte arg4 ;
11658 byte arg5 ;
11659 byte arg6 ;
11660 PyObject * obj0 = 0 ;
11661 PyObject * obj1 = 0 ;
11662 PyObject * obj2 = 0 ;
11663 PyObject * obj3 = 0 ;
11664 PyObject * obj4 = 0 ;
11665 PyObject * obj5 = 0 ;
11666 char *kwnames[] = {
11667 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11668 };
11669
11670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11672 if (SWIG_arg_fail(1)) SWIG_fail;
11673 {
11674 arg2 = (int)(SWIG_As_int(obj1));
11675 if (SWIG_arg_fail(2)) SWIG_fail;
11676 }
11677 {
11678 arg3 = (int)(SWIG_As_int(obj2));
11679 if (SWIG_arg_fail(3)) SWIG_fail;
11680 }
11681 {
11682 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11683 if (SWIG_arg_fail(4)) SWIG_fail;
11684 }
11685 {
11686 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11687 if (SWIG_arg_fail(5)) SWIG_fail;
11688 }
11689 {
11690 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11691 if (SWIG_arg_fail(6)) SWIG_fail;
11692 }
11693 {
11694 PyThreadState* __tstate = wxPyBeginAllowThreads();
11695 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11696
11697 wxPyEndAllowThreads(__tstate);
11698 if (PyErr_Occurred()) SWIG_fail;
11699 }
11700 Py_INCREF(Py_None); resultobj = Py_None;
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11708 PyObject *resultobj;
11709 wxImage *arg1 = (wxImage *) 0 ;
11710 wxRect *arg2 = 0 ;
11711 byte arg3 ;
11712 byte arg4 ;
11713 byte arg5 ;
11714 wxRect temp2 ;
11715 PyObject * obj0 = 0 ;
11716 PyObject * obj1 = 0 ;
11717 PyObject * obj2 = 0 ;
11718 PyObject * obj3 = 0 ;
11719 PyObject * obj4 = 0 ;
11720 char *kwnames[] = {
11721 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11722 };
11723
11724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11726 if (SWIG_arg_fail(1)) SWIG_fail;
11727 {
11728 arg2 = &temp2;
11729 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11730 }
11731 {
11732 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11733 if (SWIG_arg_fail(3)) SWIG_fail;
11734 }
11735 {
11736 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11737 if (SWIG_arg_fail(4)) SWIG_fail;
11738 }
11739 {
11740 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11741 if (SWIG_arg_fail(5)) SWIG_fail;
11742 }
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 Py_INCREF(Py_None); resultobj = Py_None;
11751 return resultobj;
11752 fail:
11753 return NULL;
11754 }
11755
11756
11757 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11758 PyObject *resultobj;
11759 wxImage *arg1 = (wxImage *) 0 ;
11760 int arg2 ;
11761 int arg3 ;
11762 byte result;
11763 PyObject * obj0 = 0 ;
11764 PyObject * obj1 = 0 ;
11765 PyObject * obj2 = 0 ;
11766 char *kwnames[] = {
11767 (char *) "self",(char *) "x",(char *) "y", NULL
11768 };
11769
11770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11772 if (SWIG_arg_fail(1)) SWIG_fail;
11773 {
11774 arg2 = (int)(SWIG_As_int(obj1));
11775 if (SWIG_arg_fail(2)) SWIG_fail;
11776 }
11777 {
11778 arg3 = (int)(SWIG_As_int(obj2));
11779 if (SWIG_arg_fail(3)) SWIG_fail;
11780 }
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = (byte)(arg1)->GetRed(arg2,arg3);
11784
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 {
11789 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11790 }
11791 return resultobj;
11792 fail:
11793 return NULL;
11794 }
11795
11796
11797 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11798 PyObject *resultobj;
11799 wxImage *arg1 = (wxImage *) 0 ;
11800 int arg2 ;
11801 int arg3 ;
11802 byte result;
11803 PyObject * obj0 = 0 ;
11804 PyObject * obj1 = 0 ;
11805 PyObject * obj2 = 0 ;
11806 char *kwnames[] = {
11807 (char *) "self",(char *) "x",(char *) "y", NULL
11808 };
11809
11810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11812 if (SWIG_arg_fail(1)) SWIG_fail;
11813 {
11814 arg2 = (int)(SWIG_As_int(obj1));
11815 if (SWIG_arg_fail(2)) SWIG_fail;
11816 }
11817 {
11818 arg3 = (int)(SWIG_As_int(obj2));
11819 if (SWIG_arg_fail(3)) SWIG_fail;
11820 }
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (byte)(arg1)->GetGreen(arg2,arg3);
11824
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 {
11829 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11830 }
11831 return resultobj;
11832 fail:
11833 return NULL;
11834 }
11835
11836
11837 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11838 PyObject *resultobj;
11839 wxImage *arg1 = (wxImage *) 0 ;
11840 int arg2 ;
11841 int arg3 ;
11842 byte result;
11843 PyObject * obj0 = 0 ;
11844 PyObject * obj1 = 0 ;
11845 PyObject * obj2 = 0 ;
11846 char *kwnames[] = {
11847 (char *) "self",(char *) "x",(char *) "y", NULL
11848 };
11849
11850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11852 if (SWIG_arg_fail(1)) SWIG_fail;
11853 {
11854 arg2 = (int)(SWIG_As_int(obj1));
11855 if (SWIG_arg_fail(2)) SWIG_fail;
11856 }
11857 {
11858 arg3 = (int)(SWIG_As_int(obj2));
11859 if (SWIG_arg_fail(3)) SWIG_fail;
11860 }
11861 {
11862 PyThreadState* __tstate = wxPyBeginAllowThreads();
11863 result = (byte)(arg1)->GetBlue(arg2,arg3);
11864
11865 wxPyEndAllowThreads(__tstate);
11866 if (PyErr_Occurred()) SWIG_fail;
11867 }
11868 {
11869 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11870 }
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11878 PyObject *resultobj;
11879 wxImage *arg1 = (wxImage *) 0 ;
11880 int arg2 ;
11881 int arg3 ;
11882 byte arg4 ;
11883 PyObject * obj0 = 0 ;
11884 PyObject * obj1 = 0 ;
11885 PyObject * obj2 = 0 ;
11886 PyObject * obj3 = 0 ;
11887 char *kwnames[] = {
11888 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11889 };
11890
11891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11893 if (SWIG_arg_fail(1)) SWIG_fail;
11894 {
11895 arg2 = (int)(SWIG_As_int(obj1));
11896 if (SWIG_arg_fail(2)) SWIG_fail;
11897 }
11898 {
11899 arg3 = (int)(SWIG_As_int(obj2));
11900 if (SWIG_arg_fail(3)) SWIG_fail;
11901 }
11902 {
11903 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11904 if (SWIG_arg_fail(4)) SWIG_fail;
11905 }
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 (arg1)->SetAlpha(arg2,arg3,arg4);
11909
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 Py_INCREF(Py_None); resultobj = Py_None;
11914 return resultobj;
11915 fail:
11916 return NULL;
11917 }
11918
11919
11920 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11921 PyObject *resultobj;
11922 wxImage *arg1 = (wxImage *) 0 ;
11923 int arg2 ;
11924 int arg3 ;
11925 byte result;
11926 PyObject * obj0 = 0 ;
11927 PyObject * obj1 = 0 ;
11928 PyObject * obj2 = 0 ;
11929 char *kwnames[] = {
11930 (char *) "self",(char *) "x",(char *) "y", NULL
11931 };
11932
11933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11935 if (SWIG_arg_fail(1)) SWIG_fail;
11936 {
11937 arg2 = (int)(SWIG_As_int(obj1));
11938 if (SWIG_arg_fail(2)) SWIG_fail;
11939 }
11940 {
11941 arg3 = (int)(SWIG_As_int(obj2));
11942 if (SWIG_arg_fail(3)) SWIG_fail;
11943 }
11944 {
11945 PyThreadState* __tstate = wxPyBeginAllowThreads();
11946 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11947
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 {
11952 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11953 }
11954 return resultobj;
11955 fail:
11956 return NULL;
11957 }
11958
11959
11960 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11961 PyObject *resultobj;
11962 wxImage *arg1 = (wxImage *) 0 ;
11963 bool result;
11964 PyObject * obj0 = 0 ;
11965 char *kwnames[] = {
11966 (char *) "self", NULL
11967 };
11968
11969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11971 if (SWIG_arg_fail(1)) SWIG_fail;
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 result = (bool)(arg1)->HasAlpha();
11975
11976 wxPyEndAllowThreads(__tstate);
11977 if (PyErr_Occurred()) SWIG_fail;
11978 }
11979 {
11980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11981 }
11982 return resultobj;
11983 fail:
11984 return NULL;
11985 }
11986
11987
11988 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11989 PyObject *resultobj;
11990 wxImage *arg1 = (wxImage *) 0 ;
11991 PyObject * obj0 = 0 ;
11992 char *kwnames[] = {
11993 (char *) "self", NULL
11994 };
11995
11996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11998 if (SWIG_arg_fail(1)) SWIG_fail;
11999 {
12000 PyThreadState* __tstate = wxPyBeginAllowThreads();
12001 (arg1)->InitAlpha();
12002
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 Py_INCREF(Py_None); resultobj = Py_None;
12007 return resultobj;
12008 fail:
12009 return NULL;
12010 }
12011
12012
12013 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12014 PyObject *resultobj;
12015 wxImage *arg1 = (wxImage *) 0 ;
12016 int arg2 ;
12017 int arg3 ;
12018 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12019 bool result;
12020 PyObject * obj0 = 0 ;
12021 PyObject * obj1 = 0 ;
12022 PyObject * obj2 = 0 ;
12023 PyObject * obj3 = 0 ;
12024 char *kwnames[] = {
12025 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12026 };
12027
12028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12030 if (SWIG_arg_fail(1)) SWIG_fail;
12031 {
12032 arg2 = (int)(SWIG_As_int(obj1));
12033 if (SWIG_arg_fail(2)) SWIG_fail;
12034 }
12035 {
12036 arg3 = (int)(SWIG_As_int(obj2));
12037 if (SWIG_arg_fail(3)) SWIG_fail;
12038 }
12039 if (obj3) {
12040 {
12041 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12042 if (SWIG_arg_fail(4)) SWIG_fail;
12043 }
12044 }
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12048
12049 wxPyEndAllowThreads(__tstate);
12050 if (PyErr_Occurred()) SWIG_fail;
12051 }
12052 {
12053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12054 }
12055 return resultobj;
12056 fail:
12057 return NULL;
12058 }
12059
12060
12061 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12062 PyObject *resultobj;
12063 wxImage *arg1 = (wxImage *) 0 ;
12064 byte *arg2 = (byte *) 0 ;
12065 byte *arg3 = (byte *) 0 ;
12066 byte *arg4 = (byte *) 0 ;
12067 byte arg5 = (byte) 0 ;
12068 byte arg6 = (byte) 0 ;
12069 byte arg7 = (byte) 0 ;
12070 bool result;
12071 byte temp2 ;
12072 int res2 = 0 ;
12073 byte temp3 ;
12074 int res3 = 0 ;
12075 byte temp4 ;
12076 int res4 = 0 ;
12077 PyObject * obj0 = 0 ;
12078 PyObject * obj1 = 0 ;
12079 PyObject * obj2 = 0 ;
12080 PyObject * obj3 = 0 ;
12081 char *kwnames[] = {
12082 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12083 };
12084
12085 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12086 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12087 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12090 if (SWIG_arg_fail(1)) SWIG_fail;
12091 if (obj1) {
12092 {
12093 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12094 if (SWIG_arg_fail(5)) SWIG_fail;
12095 }
12096 }
12097 if (obj2) {
12098 {
12099 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12100 if (SWIG_arg_fail(6)) SWIG_fail;
12101 }
12102 }
12103 if (obj3) {
12104 {
12105 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12106 if (SWIG_arg_fail(7)) SWIG_fail;
12107 }
12108 }
12109 {
12110 PyThreadState* __tstate = wxPyBeginAllowThreads();
12111 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12112
12113 wxPyEndAllowThreads(__tstate);
12114 if (PyErr_Occurred()) SWIG_fail;
12115 }
12116 {
12117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12118 }
12119 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12120 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12121 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12122 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12123 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12124 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12125 return resultobj;
12126 fail:
12127 return NULL;
12128 }
12129
12130
12131 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12132 PyObject *resultobj;
12133 wxImage *arg1 = (wxImage *) 0 ;
12134 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12135 bool result;
12136 PyObject * obj0 = 0 ;
12137 PyObject * obj1 = 0 ;
12138 char *kwnames[] = {
12139 (char *) "self",(char *) "threshold", NULL
12140 };
12141
12142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12144 if (SWIG_arg_fail(1)) SWIG_fail;
12145 if (obj1) {
12146 {
12147 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12148 if (SWIG_arg_fail(2)) SWIG_fail;
12149 }
12150 }
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12154
12155 wxPyEndAllowThreads(__tstate);
12156 if (PyErr_Occurred()) SWIG_fail;
12157 }
12158 {
12159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12160 }
12161 return resultobj;
12162 fail:
12163 return NULL;
12164 }
12165
12166
12167 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12168 PyObject *resultobj;
12169 wxImage *arg1 = (wxImage *) 0 ;
12170 byte arg2 ;
12171 byte arg3 ;
12172 byte arg4 ;
12173 bool result;
12174 PyObject * obj0 = 0 ;
12175 PyObject * obj1 = 0 ;
12176 PyObject * obj2 = 0 ;
12177 PyObject * obj3 = 0 ;
12178 char *kwnames[] = {
12179 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12180 };
12181
12182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12184 if (SWIG_arg_fail(1)) SWIG_fail;
12185 {
12186 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12187 if (SWIG_arg_fail(2)) SWIG_fail;
12188 }
12189 {
12190 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12191 if (SWIG_arg_fail(3)) SWIG_fail;
12192 }
12193 {
12194 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12195 if (SWIG_arg_fail(4)) SWIG_fail;
12196 }
12197 {
12198 PyThreadState* __tstate = wxPyBeginAllowThreads();
12199 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12200
12201 wxPyEndAllowThreads(__tstate);
12202 if (PyErr_Occurred()) SWIG_fail;
12203 }
12204 {
12205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12206 }
12207 return resultobj;
12208 fail:
12209 return NULL;
12210 }
12211
12212
12213 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12214 PyObject *resultobj;
12215 wxImage *arg1 = (wxImage *) 0 ;
12216 wxImage *arg2 = 0 ;
12217 byte arg3 ;
12218 byte arg4 ;
12219 byte arg5 ;
12220 bool result;
12221 PyObject * obj0 = 0 ;
12222 PyObject * obj1 = 0 ;
12223 PyObject * obj2 = 0 ;
12224 PyObject * obj3 = 0 ;
12225 PyObject * obj4 = 0 ;
12226 char *kwnames[] = {
12227 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12228 };
12229
12230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12232 if (SWIG_arg_fail(1)) SWIG_fail;
12233 {
12234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12235 if (SWIG_arg_fail(2)) SWIG_fail;
12236 if (arg2 == NULL) {
12237 SWIG_null_ref("wxImage");
12238 }
12239 if (SWIG_arg_fail(2)) SWIG_fail;
12240 }
12241 {
12242 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12243 if (SWIG_arg_fail(3)) SWIG_fail;
12244 }
12245 {
12246 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12247 if (SWIG_arg_fail(4)) SWIG_fail;
12248 }
12249 {
12250 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
12251 if (SWIG_arg_fail(5)) SWIG_fail;
12252 }
12253 {
12254 PyThreadState* __tstate = wxPyBeginAllowThreads();
12255 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12256
12257 wxPyEndAllowThreads(__tstate);
12258 if (PyErr_Occurred()) SWIG_fail;
12259 }
12260 {
12261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12262 }
12263 return resultobj;
12264 fail:
12265 return NULL;
12266 }
12267
12268
12269 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12270 PyObject *resultobj;
12271 wxString *arg1 = 0 ;
12272 bool result;
12273 bool temp1 = false ;
12274 PyObject * obj0 = 0 ;
12275 char *kwnames[] = {
12276 (char *) "filename", NULL
12277 };
12278
12279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12280 {
12281 arg1 = wxString_in_helper(obj0);
12282 if (arg1 == NULL) SWIG_fail;
12283 temp1 = true;
12284 }
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12288
12289 wxPyEndAllowThreads(__tstate);
12290 if (PyErr_Occurred()) SWIG_fail;
12291 }
12292 {
12293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12294 }
12295 {
12296 if (temp1)
12297 delete arg1;
12298 }
12299 return resultobj;
12300 fail:
12301 {
12302 if (temp1)
12303 delete arg1;
12304 }
12305 return NULL;
12306 }
12307
12308
12309 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12310 PyObject *resultobj;
12311 wxString *arg1 = 0 ;
12312 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12313 int result;
12314 bool temp1 = false ;
12315 PyObject * obj0 = 0 ;
12316 PyObject * obj1 = 0 ;
12317 char *kwnames[] = {
12318 (char *) "filename",(char *) "type", NULL
12319 };
12320
12321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12322 {
12323 arg1 = wxString_in_helper(obj0);
12324 if (arg1 == NULL) SWIG_fail;
12325 temp1 = true;
12326 }
12327 if (obj1) {
12328 {
12329 arg2 = (long)(SWIG_As_long(obj1));
12330 if (SWIG_arg_fail(2)) SWIG_fail;
12331 }
12332 }
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12336
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 {
12341 resultobj = SWIG_From_int((int)(result));
12342 }
12343 {
12344 if (temp1)
12345 delete arg1;
12346 }
12347 return resultobj;
12348 fail:
12349 {
12350 if (temp1)
12351 delete arg1;
12352 }
12353 return NULL;
12354 }
12355
12356
12357 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12358 PyObject *resultobj;
12359 wxImage *arg1 = (wxImage *) 0 ;
12360 wxString *arg2 = 0 ;
12361 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12362 int arg4 = (int) -1 ;
12363 bool result;
12364 bool temp2 = false ;
12365 PyObject * obj0 = 0 ;
12366 PyObject * obj1 = 0 ;
12367 PyObject * obj2 = 0 ;
12368 PyObject * obj3 = 0 ;
12369 char *kwnames[] = {
12370 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12371 };
12372
12373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12375 if (SWIG_arg_fail(1)) SWIG_fail;
12376 {
12377 arg2 = wxString_in_helper(obj1);
12378 if (arg2 == NULL) SWIG_fail;
12379 temp2 = true;
12380 }
12381 if (obj2) {
12382 {
12383 arg3 = (long)(SWIG_As_long(obj2));
12384 if (SWIG_arg_fail(3)) SWIG_fail;
12385 }
12386 }
12387 if (obj3) {
12388 {
12389 arg4 = (int)(SWIG_As_int(obj3));
12390 if (SWIG_arg_fail(4)) SWIG_fail;
12391 }
12392 }
12393 {
12394 PyThreadState* __tstate = wxPyBeginAllowThreads();
12395 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12396
12397 wxPyEndAllowThreads(__tstate);
12398 if (PyErr_Occurred()) SWIG_fail;
12399 }
12400 {
12401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12402 }
12403 {
12404 if (temp2)
12405 delete arg2;
12406 }
12407 return resultobj;
12408 fail:
12409 {
12410 if (temp2)
12411 delete arg2;
12412 }
12413 return NULL;
12414 }
12415
12416
12417 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12418 PyObject *resultobj;
12419 wxImage *arg1 = (wxImage *) 0 ;
12420 wxString *arg2 = 0 ;
12421 wxString *arg3 = 0 ;
12422 int arg4 = (int) -1 ;
12423 bool result;
12424 bool temp2 = false ;
12425 bool temp3 = false ;
12426 PyObject * obj0 = 0 ;
12427 PyObject * obj1 = 0 ;
12428 PyObject * obj2 = 0 ;
12429 PyObject * obj3 = 0 ;
12430 char *kwnames[] = {
12431 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12432 };
12433
12434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12436 if (SWIG_arg_fail(1)) SWIG_fail;
12437 {
12438 arg2 = wxString_in_helper(obj1);
12439 if (arg2 == NULL) SWIG_fail;
12440 temp2 = true;
12441 }
12442 {
12443 arg3 = wxString_in_helper(obj2);
12444 if (arg3 == NULL) SWIG_fail;
12445 temp3 = true;
12446 }
12447 if (obj3) {
12448 {
12449 arg4 = (int)(SWIG_As_int(obj3));
12450 if (SWIG_arg_fail(4)) SWIG_fail;
12451 }
12452 }
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12456
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 {
12461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12462 }
12463 {
12464 if (temp2)
12465 delete arg2;
12466 }
12467 {
12468 if (temp3)
12469 delete arg3;
12470 }
12471 return resultobj;
12472 fail:
12473 {
12474 if (temp2)
12475 delete arg2;
12476 }
12477 {
12478 if (temp3)
12479 delete arg3;
12480 }
12481 return NULL;
12482 }
12483
12484
12485 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12486 PyObject *resultobj;
12487 wxImage *arg1 = (wxImage *) 0 ;
12488 wxString *arg2 = 0 ;
12489 int arg3 ;
12490 bool result;
12491 bool temp2 = false ;
12492 PyObject * obj0 = 0 ;
12493 PyObject * obj1 = 0 ;
12494 PyObject * obj2 = 0 ;
12495 char *kwnames[] = {
12496 (char *) "self",(char *) "name",(char *) "type", NULL
12497 };
12498
12499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12501 if (SWIG_arg_fail(1)) SWIG_fail;
12502 {
12503 arg2 = wxString_in_helper(obj1);
12504 if (arg2 == NULL) SWIG_fail;
12505 temp2 = true;
12506 }
12507 {
12508 arg3 = (int)(SWIG_As_int(obj2));
12509 if (SWIG_arg_fail(3)) SWIG_fail;
12510 }
12511 {
12512 PyThreadState* __tstate = wxPyBeginAllowThreads();
12513 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12514
12515 wxPyEndAllowThreads(__tstate);
12516 if (PyErr_Occurred()) SWIG_fail;
12517 }
12518 {
12519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12520 }
12521 {
12522 if (temp2)
12523 delete arg2;
12524 }
12525 return resultobj;
12526 fail:
12527 {
12528 if (temp2)
12529 delete arg2;
12530 }
12531 return NULL;
12532 }
12533
12534
12535 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj;
12537 wxImage *arg1 = (wxImage *) 0 ;
12538 wxString *arg2 = 0 ;
12539 wxString *arg3 = 0 ;
12540 bool result;
12541 bool temp2 = false ;
12542 bool temp3 = false ;
12543 PyObject * obj0 = 0 ;
12544 PyObject * obj1 = 0 ;
12545 PyObject * obj2 = 0 ;
12546 char *kwnames[] = {
12547 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12548 };
12549
12550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12552 if (SWIG_arg_fail(1)) SWIG_fail;
12553 {
12554 arg2 = wxString_in_helper(obj1);
12555 if (arg2 == NULL) SWIG_fail;
12556 temp2 = true;
12557 }
12558 {
12559 arg3 = wxString_in_helper(obj2);
12560 if (arg3 == NULL) SWIG_fail;
12561 temp3 = true;
12562 }
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12566
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 {
12571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12572 }
12573 {
12574 if (temp2)
12575 delete arg2;
12576 }
12577 {
12578 if (temp3)
12579 delete arg3;
12580 }
12581 return resultobj;
12582 fail:
12583 {
12584 if (temp2)
12585 delete arg2;
12586 }
12587 {
12588 if (temp3)
12589 delete arg3;
12590 }
12591 return NULL;
12592 }
12593
12594
12595 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12596 PyObject *resultobj;
12597 wxInputStream *arg1 = 0 ;
12598 bool result;
12599 wxPyInputStream *temp1 ;
12600 bool created1 ;
12601 PyObject * obj0 = 0 ;
12602 char *kwnames[] = {
12603 (char *) "stream", NULL
12604 };
12605
12606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12607 {
12608 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12609 arg1 = temp1->m_wxis;
12610 created1 = false;
12611 } else {
12612 PyErr_Clear(); // clear the failure of the wxPyConvert above
12613 arg1 = wxPyCBInputStream_create(obj0, false);
12614 if (arg1 == NULL) {
12615 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12616 SWIG_fail;
12617 }
12618 created1 = true;
12619 }
12620 }
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 result = (bool)wxImage::CanRead(*arg1);
12624
12625 wxPyEndAllowThreads(__tstate);
12626 if (PyErr_Occurred()) SWIG_fail;
12627 }
12628 {
12629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12630 }
12631 {
12632 if (created1) delete arg1;
12633 }
12634 return resultobj;
12635 fail:
12636 {
12637 if (created1) delete arg1;
12638 }
12639 return NULL;
12640 }
12641
12642
12643 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12644 PyObject *resultobj;
12645 wxImage *arg1 = (wxImage *) 0 ;
12646 wxInputStream *arg2 = 0 ;
12647 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12648 int arg4 = (int) -1 ;
12649 bool result;
12650 wxPyInputStream *temp2 ;
12651 bool created2 ;
12652 PyObject * obj0 = 0 ;
12653 PyObject * obj1 = 0 ;
12654 PyObject * obj2 = 0 ;
12655 PyObject * obj3 = 0 ;
12656 char *kwnames[] = {
12657 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12658 };
12659
12660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12662 if (SWIG_arg_fail(1)) SWIG_fail;
12663 {
12664 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12665 arg2 = temp2->m_wxis;
12666 created2 = false;
12667 } else {
12668 PyErr_Clear(); // clear the failure of the wxPyConvert above
12669 arg2 = wxPyCBInputStream_create(obj1, false);
12670 if (arg2 == NULL) {
12671 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12672 SWIG_fail;
12673 }
12674 created2 = true;
12675 }
12676 }
12677 if (obj2) {
12678 {
12679 arg3 = (long)(SWIG_As_long(obj2));
12680 if (SWIG_arg_fail(3)) SWIG_fail;
12681 }
12682 }
12683 if (obj3) {
12684 {
12685 arg4 = (int)(SWIG_As_int(obj3));
12686 if (SWIG_arg_fail(4)) SWIG_fail;
12687 }
12688 }
12689 {
12690 PyThreadState* __tstate = wxPyBeginAllowThreads();
12691 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12692
12693 wxPyEndAllowThreads(__tstate);
12694 if (PyErr_Occurred()) SWIG_fail;
12695 }
12696 {
12697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12698 }
12699 {
12700 if (created2) delete arg2;
12701 }
12702 return resultobj;
12703 fail:
12704 {
12705 if (created2) delete arg2;
12706 }
12707 return NULL;
12708 }
12709
12710
12711 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12712 PyObject *resultobj;
12713 wxImage *arg1 = (wxImage *) 0 ;
12714 wxInputStream *arg2 = 0 ;
12715 wxString *arg3 = 0 ;
12716 int arg4 = (int) -1 ;
12717 bool result;
12718 wxPyInputStream *temp2 ;
12719 bool created2 ;
12720 bool temp3 = false ;
12721 PyObject * obj0 = 0 ;
12722 PyObject * obj1 = 0 ;
12723 PyObject * obj2 = 0 ;
12724 PyObject * obj3 = 0 ;
12725 char *kwnames[] = {
12726 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12727 };
12728
12729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12731 if (SWIG_arg_fail(1)) SWIG_fail;
12732 {
12733 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12734 arg2 = temp2->m_wxis;
12735 created2 = false;
12736 } else {
12737 PyErr_Clear(); // clear the failure of the wxPyConvert above
12738 arg2 = wxPyCBInputStream_create(obj1, false);
12739 if (arg2 == NULL) {
12740 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12741 SWIG_fail;
12742 }
12743 created2 = true;
12744 }
12745 }
12746 {
12747 arg3 = wxString_in_helper(obj2);
12748 if (arg3 == NULL) SWIG_fail;
12749 temp3 = true;
12750 }
12751 if (obj3) {
12752 {
12753 arg4 = (int)(SWIG_As_int(obj3));
12754 if (SWIG_arg_fail(4)) SWIG_fail;
12755 }
12756 }
12757 {
12758 PyThreadState* __tstate = wxPyBeginAllowThreads();
12759 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12760
12761 wxPyEndAllowThreads(__tstate);
12762 if (PyErr_Occurred()) SWIG_fail;
12763 }
12764 {
12765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12766 }
12767 {
12768 if (created2) delete arg2;
12769 }
12770 {
12771 if (temp3)
12772 delete arg3;
12773 }
12774 return resultobj;
12775 fail:
12776 {
12777 if (created2) delete arg2;
12778 }
12779 {
12780 if (temp3)
12781 delete arg3;
12782 }
12783 return NULL;
12784 }
12785
12786
12787 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12788 PyObject *resultobj;
12789 wxImage *arg1 = (wxImage *) 0 ;
12790 bool result;
12791 PyObject * obj0 = 0 ;
12792 char *kwnames[] = {
12793 (char *) "self", NULL
12794 };
12795
12796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12798 if (SWIG_arg_fail(1)) SWIG_fail;
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 result = (bool)(arg1)->Ok();
12802
12803 wxPyEndAllowThreads(__tstate);
12804 if (PyErr_Occurred()) SWIG_fail;
12805 }
12806 {
12807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12808 }
12809 return resultobj;
12810 fail:
12811 return NULL;
12812 }
12813
12814
12815 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12816 PyObject *resultobj;
12817 wxImage *arg1 = (wxImage *) 0 ;
12818 int result;
12819 PyObject * obj0 = 0 ;
12820 char *kwnames[] = {
12821 (char *) "self", NULL
12822 };
12823
12824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12826 if (SWIG_arg_fail(1)) SWIG_fail;
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 result = (int)(arg1)->GetWidth();
12830
12831 wxPyEndAllowThreads(__tstate);
12832 if (PyErr_Occurred()) SWIG_fail;
12833 }
12834 {
12835 resultobj = SWIG_From_int((int)(result));
12836 }
12837 return resultobj;
12838 fail:
12839 return NULL;
12840 }
12841
12842
12843 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12844 PyObject *resultobj;
12845 wxImage *arg1 = (wxImage *) 0 ;
12846 int result;
12847 PyObject * obj0 = 0 ;
12848 char *kwnames[] = {
12849 (char *) "self", NULL
12850 };
12851
12852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12854 if (SWIG_arg_fail(1)) SWIG_fail;
12855 {
12856 PyThreadState* __tstate = wxPyBeginAllowThreads();
12857 result = (int)(arg1)->GetHeight();
12858
12859 wxPyEndAllowThreads(__tstate);
12860 if (PyErr_Occurred()) SWIG_fail;
12861 }
12862 {
12863 resultobj = SWIG_From_int((int)(result));
12864 }
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxImage *arg1 = (wxImage *) 0 ;
12874 wxSize result;
12875 PyObject * obj0 = 0 ;
12876 char *kwnames[] = {
12877 (char *) "self", NULL
12878 };
12879
12880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12882 if (SWIG_arg_fail(1)) SWIG_fail;
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 result = wxImage_GetSize(arg1);
12886
12887 wxPyEndAllowThreads(__tstate);
12888 if (PyErr_Occurred()) SWIG_fail;
12889 }
12890 {
12891 wxSize * resultptr;
12892 resultptr = new wxSize((wxSize &)(result));
12893 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12894 }
12895 return resultobj;
12896 fail:
12897 return NULL;
12898 }
12899
12900
12901 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12902 PyObject *resultobj;
12903 wxImage *arg1 = (wxImage *) 0 ;
12904 wxRect *arg2 = 0 ;
12905 SwigValueWrapper<wxImage > result;
12906 wxRect temp2 ;
12907 PyObject * obj0 = 0 ;
12908 PyObject * obj1 = 0 ;
12909 char *kwnames[] = {
12910 (char *) "self",(char *) "rect", NULL
12911 };
12912
12913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12915 if (SWIG_arg_fail(1)) SWIG_fail;
12916 {
12917 arg2 = &temp2;
12918 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12919 }
12920 {
12921 PyThreadState* __tstate = wxPyBeginAllowThreads();
12922 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12923
12924 wxPyEndAllowThreads(__tstate);
12925 if (PyErr_Occurred()) SWIG_fail;
12926 }
12927 {
12928 wxImage * resultptr;
12929 resultptr = new wxImage((wxImage &)(result));
12930 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12931 }
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12939 PyObject *resultobj;
12940 wxImage *arg1 = (wxImage *) 0 ;
12941 wxSize *arg2 = 0 ;
12942 wxPoint *arg3 = 0 ;
12943 int arg4 = (int) -1 ;
12944 int arg5 = (int) -1 ;
12945 int arg6 = (int) -1 ;
12946 SwigValueWrapper<wxImage > result;
12947 wxSize temp2 ;
12948 wxPoint temp3 ;
12949 PyObject * obj0 = 0 ;
12950 PyObject * obj1 = 0 ;
12951 PyObject * obj2 = 0 ;
12952 PyObject * obj3 = 0 ;
12953 PyObject * obj4 = 0 ;
12954 PyObject * obj5 = 0 ;
12955 char *kwnames[] = {
12956 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12957 };
12958
12959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12961 if (SWIG_arg_fail(1)) SWIG_fail;
12962 {
12963 arg2 = &temp2;
12964 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12965 }
12966 {
12967 arg3 = &temp3;
12968 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12969 }
12970 if (obj3) {
12971 {
12972 arg4 = (int)(SWIG_As_int(obj3));
12973 if (SWIG_arg_fail(4)) SWIG_fail;
12974 }
12975 }
12976 if (obj4) {
12977 {
12978 arg5 = (int)(SWIG_As_int(obj4));
12979 if (SWIG_arg_fail(5)) SWIG_fail;
12980 }
12981 }
12982 if (obj5) {
12983 {
12984 arg6 = (int)(SWIG_As_int(obj5));
12985 if (SWIG_arg_fail(6)) SWIG_fail;
12986 }
12987 }
12988 {
12989 PyThreadState* __tstate = wxPyBeginAllowThreads();
12990 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12991
12992 wxPyEndAllowThreads(__tstate);
12993 if (PyErr_Occurred()) SWIG_fail;
12994 }
12995 {
12996 wxImage * resultptr;
12997 resultptr = new wxImage((wxImage &)(result));
12998 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12999 }
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj;
13008 wxImage *arg1 = (wxImage *) 0 ;
13009 SwigValueWrapper<wxImage > result;
13010 PyObject * obj0 = 0 ;
13011 char *kwnames[] = {
13012 (char *) "self", NULL
13013 };
13014
13015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13017 if (SWIG_arg_fail(1)) SWIG_fail;
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 result = (arg1)->Copy();
13021
13022 wxPyEndAllowThreads(__tstate);
13023 if (PyErr_Occurred()) SWIG_fail;
13024 }
13025 {
13026 wxImage * resultptr;
13027 resultptr = new wxImage((wxImage &)(result));
13028 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13029 }
13030 return resultobj;
13031 fail:
13032 return NULL;
13033 }
13034
13035
13036 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13037 PyObject *resultobj;
13038 wxImage *arg1 = (wxImage *) 0 ;
13039 wxImage *arg2 = 0 ;
13040 int arg3 ;
13041 int arg4 ;
13042 PyObject * obj0 = 0 ;
13043 PyObject * obj1 = 0 ;
13044 PyObject * obj2 = 0 ;
13045 PyObject * obj3 = 0 ;
13046 char *kwnames[] = {
13047 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13048 };
13049
13050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13052 if (SWIG_arg_fail(1)) SWIG_fail;
13053 {
13054 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13055 if (SWIG_arg_fail(2)) SWIG_fail;
13056 if (arg2 == NULL) {
13057 SWIG_null_ref("wxImage");
13058 }
13059 if (SWIG_arg_fail(2)) SWIG_fail;
13060 }
13061 {
13062 arg3 = (int)(SWIG_As_int(obj2));
13063 if (SWIG_arg_fail(3)) SWIG_fail;
13064 }
13065 {
13066 arg4 = (int)(SWIG_As_int(obj3));
13067 if (SWIG_arg_fail(4)) SWIG_fail;
13068 }
13069 {
13070 PyThreadState* __tstate = wxPyBeginAllowThreads();
13071 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13072
13073 wxPyEndAllowThreads(__tstate);
13074 if (PyErr_Occurred()) SWIG_fail;
13075 }
13076 Py_INCREF(Py_None); resultobj = Py_None;
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj;
13085 wxImage *arg1 = (wxImage *) 0 ;
13086 PyObject *result;
13087 PyObject * obj0 = 0 ;
13088 char *kwnames[] = {
13089 (char *) "self", NULL
13090 };
13091
13092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13094 if (SWIG_arg_fail(1)) SWIG_fail;
13095 {
13096 PyThreadState* __tstate = wxPyBeginAllowThreads();
13097 result = (PyObject *)wxImage_GetData(arg1);
13098
13099 wxPyEndAllowThreads(__tstate);
13100 if (PyErr_Occurred()) SWIG_fail;
13101 }
13102 resultobj = result;
13103 return resultobj;
13104 fail:
13105 return NULL;
13106 }
13107
13108
13109 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13110 PyObject *resultobj;
13111 wxImage *arg1 = (wxImage *) 0 ;
13112 buffer arg2 ;
13113 int arg3 ;
13114 PyObject * obj0 = 0 ;
13115 PyObject * obj1 = 0 ;
13116 char *kwnames[] = {
13117 (char *) "self",(char *) "data", NULL
13118 };
13119
13120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13122 if (SWIG_arg_fail(1)) SWIG_fail;
13123 {
13124 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13125 }
13126 {
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 wxImage_SetData(arg1,arg2,arg3);
13129
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 Py_INCREF(Py_None); resultobj = Py_None;
13134 return resultobj;
13135 fail:
13136 return NULL;
13137 }
13138
13139
13140 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13141 PyObject *resultobj;
13142 wxImage *arg1 = (wxImage *) 0 ;
13143 PyObject *result;
13144 PyObject * obj0 = 0 ;
13145 char *kwnames[] = {
13146 (char *) "self", NULL
13147 };
13148
13149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13151 if (SWIG_arg_fail(1)) SWIG_fail;
13152 {
13153 PyThreadState* __tstate = wxPyBeginAllowThreads();
13154 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13155
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 resultobj = result;
13160 return resultobj;
13161 fail:
13162 return NULL;
13163 }
13164
13165
13166 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13167 PyObject *resultobj;
13168 wxImage *arg1 = (wxImage *) 0 ;
13169 buffer arg2 ;
13170 int arg3 ;
13171 PyObject * obj0 = 0 ;
13172 PyObject * obj1 = 0 ;
13173 char *kwnames[] = {
13174 (char *) "self",(char *) "data", NULL
13175 };
13176
13177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13179 if (SWIG_arg_fail(1)) SWIG_fail;
13180 {
13181 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13182 }
13183 {
13184 PyThreadState* __tstate = wxPyBeginAllowThreads();
13185 wxImage_SetDataBuffer(arg1,arg2,arg3);
13186
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 Py_INCREF(Py_None); resultobj = Py_None;
13191 return resultobj;
13192 fail:
13193 return NULL;
13194 }
13195
13196
13197 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13198 PyObject *resultobj;
13199 wxImage *arg1 = (wxImage *) 0 ;
13200 PyObject *result;
13201 PyObject * obj0 = 0 ;
13202 char *kwnames[] = {
13203 (char *) "self", NULL
13204 };
13205
13206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13208 if (SWIG_arg_fail(1)) SWIG_fail;
13209 {
13210 PyThreadState* __tstate = wxPyBeginAllowThreads();
13211 result = (PyObject *)wxImage_GetAlphaData(arg1);
13212
13213 wxPyEndAllowThreads(__tstate);
13214 if (PyErr_Occurred()) SWIG_fail;
13215 }
13216 resultobj = result;
13217 return resultobj;
13218 fail:
13219 return NULL;
13220 }
13221
13222
13223 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13224 PyObject *resultobj;
13225 wxImage *arg1 = (wxImage *) 0 ;
13226 buffer arg2 ;
13227 int arg3 ;
13228 PyObject * obj0 = 0 ;
13229 PyObject * obj1 = 0 ;
13230 char *kwnames[] = {
13231 (char *) "self",(char *) "alpha", NULL
13232 };
13233
13234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13236 if (SWIG_arg_fail(1)) SWIG_fail;
13237 {
13238 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13239 }
13240 {
13241 PyThreadState* __tstate = wxPyBeginAllowThreads();
13242 wxImage_SetAlphaData(arg1,arg2,arg3);
13243
13244 wxPyEndAllowThreads(__tstate);
13245 if (PyErr_Occurred()) SWIG_fail;
13246 }
13247 Py_INCREF(Py_None); resultobj = Py_None;
13248 return resultobj;
13249 fail:
13250 return NULL;
13251 }
13252
13253
13254 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13255 PyObject *resultobj;
13256 wxImage *arg1 = (wxImage *) 0 ;
13257 PyObject *result;
13258 PyObject * obj0 = 0 ;
13259 char *kwnames[] = {
13260 (char *) "self", NULL
13261 };
13262
13263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13265 if (SWIG_arg_fail(1)) SWIG_fail;
13266 {
13267 PyThreadState* __tstate = wxPyBeginAllowThreads();
13268 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13269
13270 wxPyEndAllowThreads(__tstate);
13271 if (PyErr_Occurred()) SWIG_fail;
13272 }
13273 resultobj = result;
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj;
13282 wxImage *arg1 = (wxImage *) 0 ;
13283 buffer arg2 ;
13284 int arg3 ;
13285 PyObject * obj0 = 0 ;
13286 PyObject * obj1 = 0 ;
13287 char *kwnames[] = {
13288 (char *) "self",(char *) "alpha", NULL
13289 };
13290
13291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13293 if (SWIG_arg_fail(1)) SWIG_fail;
13294 {
13295 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13296 }
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13300
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 Py_INCREF(Py_None); resultobj = Py_None;
13305 return resultobj;
13306 fail:
13307 return NULL;
13308 }
13309
13310
13311 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13312 PyObject *resultobj;
13313 wxImage *arg1 = (wxImage *) 0 ;
13314 byte arg2 ;
13315 byte arg3 ;
13316 byte arg4 ;
13317 PyObject * obj0 = 0 ;
13318 PyObject * obj1 = 0 ;
13319 PyObject * obj2 = 0 ;
13320 PyObject * obj3 = 0 ;
13321 char *kwnames[] = {
13322 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13323 };
13324
13325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13327 if (SWIG_arg_fail(1)) SWIG_fail;
13328 {
13329 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13330 if (SWIG_arg_fail(2)) SWIG_fail;
13331 }
13332 {
13333 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13334 if (SWIG_arg_fail(3)) SWIG_fail;
13335 }
13336 {
13337 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13338 if (SWIG_arg_fail(4)) SWIG_fail;
13339 }
13340 {
13341 PyThreadState* __tstate = wxPyBeginAllowThreads();
13342 (arg1)->SetMaskColour(arg2,arg3,arg4);
13343
13344 wxPyEndAllowThreads(__tstate);
13345 if (PyErr_Occurred()) SWIG_fail;
13346 }
13347 Py_INCREF(Py_None); resultobj = Py_None;
13348 return resultobj;
13349 fail:
13350 return NULL;
13351 }
13352
13353
13354 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13355 PyObject *resultobj;
13356 wxImage *arg1 = (wxImage *) 0 ;
13357 byte *arg2 = (byte *) 0 ;
13358 byte *arg3 = (byte *) 0 ;
13359 byte *arg4 = (byte *) 0 ;
13360 byte temp2 ;
13361 int res2 = 0 ;
13362 byte temp3 ;
13363 int res3 = 0 ;
13364 byte temp4 ;
13365 int res4 = 0 ;
13366 PyObject * obj0 = 0 ;
13367 char *kwnames[] = {
13368 (char *) "self", NULL
13369 };
13370
13371 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13372 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13373 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13376 if (SWIG_arg_fail(1)) SWIG_fail;
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13380
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 Py_INCREF(Py_None); resultobj = Py_None;
13385 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13386 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13387 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13388 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13389 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13390 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13391 return resultobj;
13392 fail:
13393 return NULL;
13394 }
13395
13396
13397 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13398 PyObject *resultobj;
13399 wxImage *arg1 = (wxImage *) 0 ;
13400 byte result;
13401 PyObject * obj0 = 0 ;
13402 char *kwnames[] = {
13403 (char *) "self", NULL
13404 };
13405
13406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13408 if (SWIG_arg_fail(1)) SWIG_fail;
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 result = (byte)(arg1)->GetMaskRed();
13412
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 {
13417 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13418 }
13419 return resultobj;
13420 fail:
13421 return NULL;
13422 }
13423
13424
13425 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13426 PyObject *resultobj;
13427 wxImage *arg1 = (wxImage *) 0 ;
13428 byte result;
13429 PyObject * obj0 = 0 ;
13430 char *kwnames[] = {
13431 (char *) "self", NULL
13432 };
13433
13434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13436 if (SWIG_arg_fail(1)) SWIG_fail;
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 result = (byte)(arg1)->GetMaskGreen();
13440
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 {
13445 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13446 }
13447 return resultobj;
13448 fail:
13449 return NULL;
13450 }
13451
13452
13453 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj;
13455 wxImage *arg1 = (wxImage *) 0 ;
13456 byte result;
13457 PyObject * obj0 = 0 ;
13458 char *kwnames[] = {
13459 (char *) "self", NULL
13460 };
13461
13462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13464 if (SWIG_arg_fail(1)) SWIG_fail;
13465 {
13466 PyThreadState* __tstate = wxPyBeginAllowThreads();
13467 result = (byte)(arg1)->GetMaskBlue();
13468
13469 wxPyEndAllowThreads(__tstate);
13470 if (PyErr_Occurred()) SWIG_fail;
13471 }
13472 {
13473 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13474 }
13475 return resultobj;
13476 fail:
13477 return NULL;
13478 }
13479
13480
13481 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj;
13483 wxImage *arg1 = (wxImage *) 0 ;
13484 bool arg2 = (bool) true ;
13485 PyObject * obj0 = 0 ;
13486 PyObject * obj1 = 0 ;
13487 char *kwnames[] = {
13488 (char *) "self",(char *) "mask", NULL
13489 };
13490
13491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13493 if (SWIG_arg_fail(1)) SWIG_fail;
13494 if (obj1) {
13495 {
13496 arg2 = (bool)(SWIG_As_bool(obj1));
13497 if (SWIG_arg_fail(2)) SWIG_fail;
13498 }
13499 }
13500 {
13501 PyThreadState* __tstate = wxPyBeginAllowThreads();
13502 (arg1)->SetMask(arg2);
13503
13504 wxPyEndAllowThreads(__tstate);
13505 if (PyErr_Occurred()) SWIG_fail;
13506 }
13507 Py_INCREF(Py_None); resultobj = Py_None;
13508 return resultobj;
13509 fail:
13510 return NULL;
13511 }
13512
13513
13514 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj;
13516 wxImage *arg1 = (wxImage *) 0 ;
13517 bool result;
13518 PyObject * obj0 = 0 ;
13519 char *kwnames[] = {
13520 (char *) "self", NULL
13521 };
13522
13523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13525 if (SWIG_arg_fail(1)) SWIG_fail;
13526 {
13527 PyThreadState* __tstate = wxPyBeginAllowThreads();
13528 result = (bool)(arg1)->HasMask();
13529
13530 wxPyEndAllowThreads(__tstate);
13531 if (PyErr_Occurred()) SWIG_fail;
13532 }
13533 {
13534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13535 }
13536 return resultobj;
13537 fail:
13538 return NULL;
13539 }
13540
13541
13542 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13543 PyObject *resultobj;
13544 wxImage *arg1 = (wxImage *) 0 ;
13545 double arg2 ;
13546 wxPoint *arg3 = 0 ;
13547 bool arg4 = (bool) true ;
13548 wxPoint *arg5 = (wxPoint *) NULL ;
13549 SwigValueWrapper<wxImage > result;
13550 wxPoint temp3 ;
13551 PyObject * obj0 = 0 ;
13552 PyObject * obj1 = 0 ;
13553 PyObject * obj2 = 0 ;
13554 PyObject * obj3 = 0 ;
13555 PyObject * obj4 = 0 ;
13556 char *kwnames[] = {
13557 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13558 };
13559
13560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13562 if (SWIG_arg_fail(1)) SWIG_fail;
13563 {
13564 arg2 = (double)(SWIG_As_double(obj1));
13565 if (SWIG_arg_fail(2)) SWIG_fail;
13566 }
13567 {
13568 arg3 = &temp3;
13569 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13570 }
13571 if (obj3) {
13572 {
13573 arg4 = (bool)(SWIG_As_bool(obj3));
13574 if (SWIG_arg_fail(4)) SWIG_fail;
13575 }
13576 }
13577 if (obj4) {
13578 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13579 if (SWIG_arg_fail(5)) SWIG_fail;
13580 }
13581 {
13582 PyThreadState* __tstate = wxPyBeginAllowThreads();
13583 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13584
13585 wxPyEndAllowThreads(__tstate);
13586 if (PyErr_Occurred()) SWIG_fail;
13587 }
13588 {
13589 wxImage * resultptr;
13590 resultptr = new wxImage((wxImage &)(result));
13591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13592 }
13593 return resultobj;
13594 fail:
13595 return NULL;
13596 }
13597
13598
13599 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13600 PyObject *resultobj;
13601 wxImage *arg1 = (wxImage *) 0 ;
13602 bool arg2 = (bool) true ;
13603 SwigValueWrapper<wxImage > result;
13604 PyObject * obj0 = 0 ;
13605 PyObject * obj1 = 0 ;
13606 char *kwnames[] = {
13607 (char *) "self",(char *) "clockwise", NULL
13608 };
13609
13610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13612 if (SWIG_arg_fail(1)) SWIG_fail;
13613 if (obj1) {
13614 {
13615 arg2 = (bool)(SWIG_As_bool(obj1));
13616 if (SWIG_arg_fail(2)) SWIG_fail;
13617 }
13618 }
13619 {
13620 PyThreadState* __tstate = wxPyBeginAllowThreads();
13621 result = (arg1)->Rotate90(arg2);
13622
13623 wxPyEndAllowThreads(__tstate);
13624 if (PyErr_Occurred()) SWIG_fail;
13625 }
13626 {
13627 wxImage * resultptr;
13628 resultptr = new wxImage((wxImage &)(result));
13629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13630 }
13631 return resultobj;
13632 fail:
13633 return NULL;
13634 }
13635
13636
13637 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13638 PyObject *resultobj;
13639 wxImage *arg1 = (wxImage *) 0 ;
13640 bool arg2 = (bool) true ;
13641 SwigValueWrapper<wxImage > result;
13642 PyObject * obj0 = 0 ;
13643 PyObject * obj1 = 0 ;
13644 char *kwnames[] = {
13645 (char *) "self",(char *) "horizontally", NULL
13646 };
13647
13648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13650 if (SWIG_arg_fail(1)) SWIG_fail;
13651 if (obj1) {
13652 {
13653 arg2 = (bool)(SWIG_As_bool(obj1));
13654 if (SWIG_arg_fail(2)) SWIG_fail;
13655 }
13656 }
13657 {
13658 PyThreadState* __tstate = wxPyBeginAllowThreads();
13659 result = (arg1)->Mirror(arg2);
13660
13661 wxPyEndAllowThreads(__tstate);
13662 if (PyErr_Occurred()) SWIG_fail;
13663 }
13664 {
13665 wxImage * resultptr;
13666 resultptr = new wxImage((wxImage &)(result));
13667 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13668 }
13669 return resultobj;
13670 fail:
13671 return NULL;
13672 }
13673
13674
13675 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13676 PyObject *resultobj;
13677 wxImage *arg1 = (wxImage *) 0 ;
13678 byte arg2 ;
13679 byte arg3 ;
13680 byte arg4 ;
13681 byte arg5 ;
13682 byte arg6 ;
13683 byte arg7 ;
13684 PyObject * obj0 = 0 ;
13685 PyObject * obj1 = 0 ;
13686 PyObject * obj2 = 0 ;
13687 PyObject * obj3 = 0 ;
13688 PyObject * obj4 = 0 ;
13689 PyObject * obj5 = 0 ;
13690 PyObject * obj6 = 0 ;
13691 char *kwnames[] = {
13692 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13693 };
13694
13695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13697 if (SWIG_arg_fail(1)) SWIG_fail;
13698 {
13699 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13700 if (SWIG_arg_fail(2)) SWIG_fail;
13701 }
13702 {
13703 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13704 if (SWIG_arg_fail(3)) SWIG_fail;
13705 }
13706 {
13707 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13708 if (SWIG_arg_fail(4)) SWIG_fail;
13709 }
13710 {
13711 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13712 if (SWIG_arg_fail(5)) SWIG_fail;
13713 }
13714 {
13715 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13716 if (SWIG_arg_fail(6)) SWIG_fail;
13717 }
13718 {
13719 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13720 if (SWIG_arg_fail(7)) SWIG_fail;
13721 }
13722 {
13723 PyThreadState* __tstate = wxPyBeginAllowThreads();
13724 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13725
13726 wxPyEndAllowThreads(__tstate);
13727 if (PyErr_Occurred()) SWIG_fail;
13728 }
13729 Py_INCREF(Py_None); resultobj = Py_None;
13730 return resultobj;
13731 fail:
13732 return NULL;
13733 }
13734
13735
13736 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13737 PyObject *resultobj;
13738 wxImage *arg1 = (wxImage *) 0 ;
13739 byte arg2 ;
13740 byte arg3 ;
13741 byte arg4 ;
13742 SwigValueWrapper<wxImage > result;
13743 PyObject * obj0 = 0 ;
13744 PyObject * obj1 = 0 ;
13745 PyObject * obj2 = 0 ;
13746 PyObject * obj3 = 0 ;
13747 char *kwnames[] = {
13748 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13749 };
13750
13751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13753 if (SWIG_arg_fail(1)) SWIG_fail;
13754 {
13755 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13756 if (SWIG_arg_fail(2)) SWIG_fail;
13757 }
13758 {
13759 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13760 if (SWIG_arg_fail(3)) SWIG_fail;
13761 }
13762 {
13763 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13764 if (SWIG_arg_fail(4)) SWIG_fail;
13765 }
13766 {
13767 PyThreadState* __tstate = wxPyBeginAllowThreads();
13768 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13769
13770 wxPyEndAllowThreads(__tstate);
13771 if (PyErr_Occurred()) SWIG_fail;
13772 }
13773 {
13774 wxImage * resultptr;
13775 resultptr = new wxImage((wxImage &)(result));
13776 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13777 }
13778 return resultobj;
13779 fail:
13780 return NULL;
13781 }
13782
13783
13784 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13785 PyObject *resultobj;
13786 wxImage *arg1 = (wxImage *) 0 ;
13787 wxString *arg2 = 0 ;
13788 wxString *arg3 = 0 ;
13789 bool temp2 = false ;
13790 bool temp3 = false ;
13791 PyObject * obj0 = 0 ;
13792 PyObject * obj1 = 0 ;
13793 PyObject * obj2 = 0 ;
13794 char *kwnames[] = {
13795 (char *) "self",(char *) "name",(char *) "value", NULL
13796 };
13797
13798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13800 if (SWIG_arg_fail(1)) SWIG_fail;
13801 {
13802 arg2 = wxString_in_helper(obj1);
13803 if (arg2 == NULL) SWIG_fail;
13804 temp2 = true;
13805 }
13806 {
13807 arg3 = wxString_in_helper(obj2);
13808 if (arg3 == NULL) SWIG_fail;
13809 temp3 = true;
13810 }
13811 {
13812 PyThreadState* __tstate = wxPyBeginAllowThreads();
13813 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13814
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 Py_INCREF(Py_None); resultobj = Py_None;
13819 {
13820 if (temp2)
13821 delete arg2;
13822 }
13823 {
13824 if (temp3)
13825 delete arg3;
13826 }
13827 return resultobj;
13828 fail:
13829 {
13830 if (temp2)
13831 delete arg2;
13832 }
13833 {
13834 if (temp3)
13835 delete arg3;
13836 }
13837 return NULL;
13838 }
13839
13840
13841 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13842 PyObject *resultobj;
13843 wxImage *arg1 = (wxImage *) 0 ;
13844 wxString *arg2 = 0 ;
13845 int arg3 ;
13846 bool temp2 = false ;
13847 PyObject * obj0 = 0 ;
13848 PyObject * obj1 = 0 ;
13849 PyObject * obj2 = 0 ;
13850 char *kwnames[] = {
13851 (char *) "self",(char *) "name",(char *) "value", NULL
13852 };
13853
13854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13856 if (SWIG_arg_fail(1)) SWIG_fail;
13857 {
13858 arg2 = wxString_in_helper(obj1);
13859 if (arg2 == NULL) SWIG_fail;
13860 temp2 = true;
13861 }
13862 {
13863 arg3 = (int)(SWIG_As_int(obj2));
13864 if (SWIG_arg_fail(3)) SWIG_fail;
13865 }
13866 {
13867 PyThreadState* __tstate = wxPyBeginAllowThreads();
13868 (arg1)->SetOption((wxString const &)*arg2,arg3);
13869
13870 wxPyEndAllowThreads(__tstate);
13871 if (PyErr_Occurred()) SWIG_fail;
13872 }
13873 Py_INCREF(Py_None); resultobj = Py_None;
13874 {
13875 if (temp2)
13876 delete arg2;
13877 }
13878 return resultobj;
13879 fail:
13880 {
13881 if (temp2)
13882 delete arg2;
13883 }
13884 return NULL;
13885 }
13886
13887
13888 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13889 PyObject *resultobj;
13890 wxImage *arg1 = (wxImage *) 0 ;
13891 wxString *arg2 = 0 ;
13892 wxString result;
13893 bool temp2 = false ;
13894 PyObject * obj0 = 0 ;
13895 PyObject * obj1 = 0 ;
13896 char *kwnames[] = {
13897 (char *) "self",(char *) "name", NULL
13898 };
13899
13900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13902 if (SWIG_arg_fail(1)) SWIG_fail;
13903 {
13904 arg2 = wxString_in_helper(obj1);
13905 if (arg2 == NULL) SWIG_fail;
13906 temp2 = true;
13907 }
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13911
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 {
13916 #if wxUSE_UNICODE
13917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13918 #else
13919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13920 #endif
13921 }
13922 {
13923 if (temp2)
13924 delete arg2;
13925 }
13926 return resultobj;
13927 fail:
13928 {
13929 if (temp2)
13930 delete arg2;
13931 }
13932 return NULL;
13933 }
13934
13935
13936 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13937 PyObject *resultobj;
13938 wxImage *arg1 = (wxImage *) 0 ;
13939 wxString *arg2 = 0 ;
13940 int result;
13941 bool temp2 = false ;
13942 PyObject * obj0 = 0 ;
13943 PyObject * obj1 = 0 ;
13944 char *kwnames[] = {
13945 (char *) "self",(char *) "name", NULL
13946 };
13947
13948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13950 if (SWIG_arg_fail(1)) SWIG_fail;
13951 {
13952 arg2 = wxString_in_helper(obj1);
13953 if (arg2 == NULL) SWIG_fail;
13954 temp2 = true;
13955 }
13956 {
13957 PyThreadState* __tstate = wxPyBeginAllowThreads();
13958 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13959
13960 wxPyEndAllowThreads(__tstate);
13961 if (PyErr_Occurred()) SWIG_fail;
13962 }
13963 {
13964 resultobj = SWIG_From_int((int)(result));
13965 }
13966 {
13967 if (temp2)
13968 delete arg2;
13969 }
13970 return resultobj;
13971 fail:
13972 {
13973 if (temp2)
13974 delete arg2;
13975 }
13976 return NULL;
13977 }
13978
13979
13980 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13981 PyObject *resultobj;
13982 wxImage *arg1 = (wxImage *) 0 ;
13983 wxString *arg2 = 0 ;
13984 bool result;
13985 bool temp2 = false ;
13986 PyObject * obj0 = 0 ;
13987 PyObject * obj1 = 0 ;
13988 char *kwnames[] = {
13989 (char *) "self",(char *) "name", NULL
13990 };
13991
13992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13994 if (SWIG_arg_fail(1)) SWIG_fail;
13995 {
13996 arg2 = wxString_in_helper(obj1);
13997 if (arg2 == NULL) SWIG_fail;
13998 temp2 = true;
13999 }
14000 {
14001 PyThreadState* __tstate = wxPyBeginAllowThreads();
14002 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14003
14004 wxPyEndAllowThreads(__tstate);
14005 if (PyErr_Occurred()) SWIG_fail;
14006 }
14007 {
14008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14009 }
14010 {
14011 if (temp2)
14012 delete arg2;
14013 }
14014 return resultobj;
14015 fail:
14016 {
14017 if (temp2)
14018 delete arg2;
14019 }
14020 return NULL;
14021 }
14022
14023
14024 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14025 PyObject *resultobj;
14026 wxImage *arg1 = (wxImage *) 0 ;
14027 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14028 unsigned long result;
14029 PyObject * obj0 = 0 ;
14030 PyObject * obj1 = 0 ;
14031 char *kwnames[] = {
14032 (char *) "self",(char *) "stopafter", NULL
14033 };
14034
14035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14037 if (SWIG_arg_fail(1)) SWIG_fail;
14038 if (obj1) {
14039 {
14040 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
14041 if (SWIG_arg_fail(2)) SWIG_fail;
14042 }
14043 }
14044 {
14045 PyThreadState* __tstate = wxPyBeginAllowThreads();
14046 result = (unsigned long)(arg1)->CountColours(arg2);
14047
14048 wxPyEndAllowThreads(__tstate);
14049 if (PyErr_Occurred()) SWIG_fail;
14050 }
14051 {
14052 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
14053 }
14054 return resultobj;
14055 fail:
14056 return NULL;
14057 }
14058
14059
14060 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14061 PyObject *resultobj;
14062 wxImage *arg1 = (wxImage *) 0 ;
14063 wxImageHistogram *arg2 = 0 ;
14064 unsigned long result;
14065 PyObject * obj0 = 0 ;
14066 PyObject * obj1 = 0 ;
14067 char *kwnames[] = {
14068 (char *) "self",(char *) "h", NULL
14069 };
14070
14071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14073 if (SWIG_arg_fail(1)) SWIG_fail;
14074 {
14075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14076 if (SWIG_arg_fail(2)) SWIG_fail;
14077 if (arg2 == NULL) {
14078 SWIG_null_ref("wxImageHistogram");
14079 }
14080 if (SWIG_arg_fail(2)) SWIG_fail;
14081 }
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14085
14086 wxPyEndAllowThreads(__tstate);
14087 if (PyErr_Occurred()) SWIG_fail;
14088 }
14089 {
14090 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
14091 }
14092 return resultobj;
14093 fail:
14094 return NULL;
14095 }
14096
14097
14098 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14099 PyObject *resultobj;
14100 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14101 PyObject * obj0 = 0 ;
14102 char *kwnames[] = {
14103 (char *) "handler", NULL
14104 };
14105
14106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14108 if (SWIG_arg_fail(1)) SWIG_fail;
14109 {
14110 PyThreadState* __tstate = wxPyBeginAllowThreads();
14111 wxImage::AddHandler(arg1);
14112
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 Py_INCREF(Py_None); resultobj = Py_None;
14117 return resultobj;
14118 fail:
14119 return NULL;
14120 }
14121
14122
14123 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14124 PyObject *resultobj;
14125 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14126 PyObject * obj0 = 0 ;
14127 char *kwnames[] = {
14128 (char *) "handler", NULL
14129 };
14130
14131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14133 if (SWIG_arg_fail(1)) SWIG_fail;
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 wxImage::InsertHandler(arg1);
14137
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 Py_INCREF(Py_None); resultobj = Py_None;
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14149 PyObject *resultobj;
14150 wxString *arg1 = 0 ;
14151 bool result;
14152 bool temp1 = false ;
14153 PyObject * obj0 = 0 ;
14154 char *kwnames[] = {
14155 (char *) "name", NULL
14156 };
14157
14158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14159 {
14160 arg1 = wxString_in_helper(obj0);
14161 if (arg1 == NULL) SWIG_fail;
14162 temp1 = true;
14163 }
14164 {
14165 PyThreadState* __tstate = wxPyBeginAllowThreads();
14166 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14167
14168 wxPyEndAllowThreads(__tstate);
14169 if (PyErr_Occurred()) SWIG_fail;
14170 }
14171 {
14172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14173 }
14174 {
14175 if (temp1)
14176 delete arg1;
14177 }
14178 return resultobj;
14179 fail:
14180 {
14181 if (temp1)
14182 delete arg1;
14183 }
14184 return NULL;
14185 }
14186
14187
14188 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14189 PyObject *resultobj;
14190 wxString result;
14191 char *kwnames[] = {
14192 NULL
14193 };
14194
14195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14196 {
14197 PyThreadState* __tstate = wxPyBeginAllowThreads();
14198 result = wxImage::GetImageExtWildcard();
14199
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 {
14204 #if wxUSE_UNICODE
14205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14206 #else
14207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14208 #endif
14209 }
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14217 PyObject *resultobj;
14218 wxImage *arg1 = (wxImage *) 0 ;
14219 int arg2 = (int) -1 ;
14220 wxBitmap result;
14221 PyObject * obj0 = 0 ;
14222 PyObject * obj1 = 0 ;
14223 char *kwnames[] = {
14224 (char *) "self",(char *) "depth", NULL
14225 };
14226
14227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14229 if (SWIG_arg_fail(1)) SWIG_fail;
14230 if (obj1) {
14231 {
14232 arg2 = (int)(SWIG_As_int(obj1));
14233 if (SWIG_arg_fail(2)) SWIG_fail;
14234 }
14235 }
14236 {
14237 if (!wxPyCheckForApp()) SWIG_fail;
14238 PyThreadState* __tstate = wxPyBeginAllowThreads();
14239 result = wxImage_ConvertToBitmap(arg1,arg2);
14240
14241 wxPyEndAllowThreads(__tstate);
14242 if (PyErr_Occurred()) SWIG_fail;
14243 }
14244 {
14245 wxBitmap * resultptr;
14246 resultptr = new wxBitmap((wxBitmap &)(result));
14247 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14248 }
14249 return resultobj;
14250 fail:
14251 return NULL;
14252 }
14253
14254
14255 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj;
14257 wxImage *arg1 = (wxImage *) 0 ;
14258 byte arg2 ;
14259 byte arg3 ;
14260 byte arg4 ;
14261 wxBitmap result;
14262 PyObject * obj0 = 0 ;
14263 PyObject * obj1 = 0 ;
14264 PyObject * obj2 = 0 ;
14265 PyObject * obj3 = 0 ;
14266 char *kwnames[] = {
14267 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14268 };
14269
14270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14272 if (SWIG_arg_fail(1)) SWIG_fail;
14273 {
14274 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
14275 if (SWIG_arg_fail(2)) SWIG_fail;
14276 }
14277 {
14278 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
14279 if (SWIG_arg_fail(3)) SWIG_fail;
14280 }
14281 {
14282 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
14283 if (SWIG_arg_fail(4)) SWIG_fail;
14284 }
14285 {
14286 if (!wxPyCheckForApp()) SWIG_fail;
14287 PyThreadState* __tstate = wxPyBeginAllowThreads();
14288 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14289
14290 wxPyEndAllowThreads(__tstate);
14291 if (PyErr_Occurred()) SWIG_fail;
14292 }
14293 {
14294 wxBitmap * resultptr;
14295 resultptr = new wxBitmap((wxBitmap &)(result));
14296 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14297 }
14298 return resultobj;
14299 fail:
14300 return NULL;
14301 }
14302
14303
14304 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14305 PyObject *resultobj;
14306 wxImage *arg1 = (wxImage *) 0 ;
14307 double arg2 ;
14308 PyObject * obj0 = 0 ;
14309 PyObject * obj1 = 0 ;
14310 char *kwnames[] = {
14311 (char *) "self",(char *) "angle", NULL
14312 };
14313
14314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14316 if (SWIG_arg_fail(1)) SWIG_fail;
14317 {
14318 arg2 = (double)(SWIG_As_double(obj1));
14319 if (SWIG_arg_fail(2)) SWIG_fail;
14320 }
14321 {
14322 PyThreadState* __tstate = wxPyBeginAllowThreads();
14323 (arg1)->RotateHue(arg2);
14324
14325 wxPyEndAllowThreads(__tstate);
14326 if (PyErr_Occurred()) SWIG_fail;
14327 }
14328 Py_INCREF(Py_None); resultobj = Py_None;
14329 return resultobj;
14330 fail:
14331 return NULL;
14332 }
14333
14334
14335 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14336 PyObject *resultobj;
14337 wxImage_RGBValue arg1 ;
14338 wxImage_HSVValue result;
14339 PyObject * obj0 = 0 ;
14340 char *kwnames[] = {
14341 (char *) "rgb", NULL
14342 };
14343
14344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14345 {
14346 wxImage_RGBValue * argp;
14347 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14348 if (SWIG_arg_fail(1)) SWIG_fail;
14349 if (argp == NULL) {
14350 SWIG_null_ref("wxImage_RGBValue");
14351 }
14352 if (SWIG_arg_fail(1)) SWIG_fail;
14353 arg1 = *argp;
14354 }
14355 {
14356 PyThreadState* __tstate = wxPyBeginAllowThreads();
14357 result = wxImage::RGBtoHSV(arg1);
14358
14359 wxPyEndAllowThreads(__tstate);
14360 if (PyErr_Occurred()) SWIG_fail;
14361 }
14362 {
14363 wxImage_HSVValue * resultptr;
14364 resultptr = new wxImage_HSVValue((wxImage_HSVValue &)(result));
14365 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14366 }
14367 return resultobj;
14368 fail:
14369 return NULL;
14370 }
14371
14372
14373 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14374 PyObject *resultobj;
14375 wxImage_HSVValue arg1 ;
14376 wxImage_RGBValue result;
14377 PyObject * obj0 = 0 ;
14378 char *kwnames[] = {
14379 (char *) "hsv", NULL
14380 };
14381
14382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14383 {
14384 wxImage_HSVValue * argp;
14385 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14386 if (SWIG_arg_fail(1)) SWIG_fail;
14387 if (argp == NULL) {
14388 SWIG_null_ref("wxImage_HSVValue");
14389 }
14390 if (SWIG_arg_fail(1)) SWIG_fail;
14391 arg1 = *argp;
14392 }
14393 {
14394 PyThreadState* __tstate = wxPyBeginAllowThreads();
14395 result = wxImage::HSVtoRGB(arg1);
14396
14397 wxPyEndAllowThreads(__tstate);
14398 if (PyErr_Occurred()) SWIG_fail;
14399 }
14400 {
14401 wxImage_RGBValue * resultptr;
14402 resultptr = new wxImage_RGBValue((wxImage_RGBValue &)(result));
14403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14404 }
14405 return resultobj;
14406 fail:
14407 return NULL;
14408 }
14409
14410
14411 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14412 PyObject *obj;
14413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14414 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14415 Py_INCREF(obj);
14416 return Py_BuildValue((char *)"");
14417 }
14418 static int _wrap_NullImage_set(PyObject *) {
14419 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14420 return 1;
14421 }
14422
14423
14424 static PyObject *_wrap_NullImage_get(void) {
14425 PyObject *pyobj;
14426
14427 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14428 return pyobj;
14429 }
14430
14431
14432 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14433 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14434 return 1;
14435 }
14436
14437
14438 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14439 PyObject *pyobj;
14440
14441 {
14442 #if wxUSE_UNICODE
14443 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14444 #else
14445 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14446 #endif
14447 }
14448 return pyobj;
14449 }
14450
14451
14452 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14453 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14454 return 1;
14455 }
14456
14457
14458 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14459 PyObject *pyobj;
14460
14461 {
14462 #if wxUSE_UNICODE
14463 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14464 #else
14465 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14466 #endif
14467 }
14468 return pyobj;
14469 }
14470
14471
14472 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14473 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14474 return 1;
14475 }
14476
14477
14478 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14479 PyObject *pyobj;
14480
14481 {
14482 #if wxUSE_UNICODE
14483 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14484 #else
14485 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14486 #endif
14487 }
14488 return pyobj;
14489 }
14490
14491
14492 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14493 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14494 return 1;
14495 }
14496
14497
14498 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14499 PyObject *pyobj;
14500
14501 {
14502 #if wxUSE_UNICODE
14503 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14504 #else
14505 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14506 #endif
14507 }
14508 return pyobj;
14509 }
14510
14511
14512 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14513 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14514 return 1;
14515 }
14516
14517
14518 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14519 PyObject *pyobj;
14520
14521 {
14522 #if wxUSE_UNICODE
14523 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14524 #else
14525 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14526 #endif
14527 }
14528 return pyobj;
14529 }
14530
14531
14532 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14533 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14534 return 1;
14535 }
14536
14537
14538 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14539 PyObject *pyobj;
14540
14541 {
14542 #if wxUSE_UNICODE
14543 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14544 #else
14545 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14546 #endif
14547 }
14548 return pyobj;
14549 }
14550
14551
14552 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14553 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14554 return 1;
14555 }
14556
14557
14558 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14559 PyObject *pyobj;
14560
14561 {
14562 #if wxUSE_UNICODE
14563 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14564 #else
14565 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14566 #endif
14567 }
14568 return pyobj;
14569 }
14570
14571
14572 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14573 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14574 return 1;
14575 }
14576
14577
14578 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14579 PyObject *pyobj;
14580
14581 {
14582 #if wxUSE_UNICODE
14583 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14584 #else
14585 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14586 #endif
14587 }
14588 return pyobj;
14589 }
14590
14591
14592 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14593 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14594 return 1;
14595 }
14596
14597
14598 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14599 PyObject *pyobj;
14600
14601 {
14602 #if wxUSE_UNICODE
14603 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14604 #else
14605 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14606 #endif
14607 }
14608 return pyobj;
14609 }
14610
14611
14612 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14613 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14614 return 1;
14615 }
14616
14617
14618 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14619 PyObject *pyobj;
14620
14621 {
14622 #if wxUSE_UNICODE
14623 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14624 #else
14625 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14626 #endif
14627 }
14628 return pyobj;
14629 }
14630
14631
14632 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14633 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14634 return 1;
14635 }
14636
14637
14638 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14639 PyObject *pyobj;
14640
14641 {
14642 #if wxUSE_UNICODE
14643 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14644 #else
14645 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14646 #endif
14647 }
14648 return pyobj;
14649 }
14650
14651
14652 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14653 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14654 return 1;
14655 }
14656
14657
14658 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14659 PyObject *pyobj;
14660
14661 {
14662 #if wxUSE_UNICODE
14663 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14664 #else
14665 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14666 #endif
14667 }
14668 return pyobj;
14669 }
14670
14671
14672 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14673 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14674 return 1;
14675 }
14676
14677
14678 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14679 PyObject *pyobj;
14680
14681 {
14682 #if wxUSE_UNICODE
14683 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14684 #else
14685 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14686 #endif
14687 }
14688 return pyobj;
14689 }
14690
14691
14692 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14693 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14694 return 1;
14695 }
14696
14697
14698 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14699 PyObject *pyobj;
14700
14701 {
14702 #if wxUSE_UNICODE
14703 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14704 #else
14705 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14706 #endif
14707 }
14708 return pyobj;
14709 }
14710
14711
14712 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14713 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14714 return 1;
14715 }
14716
14717
14718 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14719 PyObject *pyobj;
14720
14721 {
14722 #if wxUSE_UNICODE
14723 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14724 #else
14725 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14726 #endif
14727 }
14728 return pyobj;
14729 }
14730
14731
14732 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14733 PyObject *resultobj;
14734 wxBMPHandler *result;
14735 char *kwnames[] = {
14736 NULL
14737 };
14738
14739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14740 {
14741 PyThreadState* __tstate = wxPyBeginAllowThreads();
14742 result = (wxBMPHandler *)new wxBMPHandler();
14743
14744 wxPyEndAllowThreads(__tstate);
14745 if (PyErr_Occurred()) SWIG_fail;
14746 }
14747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14748 return resultobj;
14749 fail:
14750 return NULL;
14751 }
14752
14753
14754 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14755 PyObject *obj;
14756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14757 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14758 Py_INCREF(obj);
14759 return Py_BuildValue((char *)"");
14760 }
14761 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj;
14763 wxICOHandler *result;
14764 char *kwnames[] = {
14765 NULL
14766 };
14767
14768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14769 {
14770 PyThreadState* __tstate = wxPyBeginAllowThreads();
14771 result = (wxICOHandler *)new wxICOHandler();
14772
14773 wxPyEndAllowThreads(__tstate);
14774 if (PyErr_Occurred()) SWIG_fail;
14775 }
14776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14777 return resultobj;
14778 fail:
14779 return NULL;
14780 }
14781
14782
14783 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14784 PyObject *obj;
14785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14786 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14787 Py_INCREF(obj);
14788 return Py_BuildValue((char *)"");
14789 }
14790 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14791 PyObject *resultobj;
14792 wxCURHandler *result;
14793 char *kwnames[] = {
14794 NULL
14795 };
14796
14797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14798 {
14799 PyThreadState* __tstate = wxPyBeginAllowThreads();
14800 result = (wxCURHandler *)new wxCURHandler();
14801
14802 wxPyEndAllowThreads(__tstate);
14803 if (PyErr_Occurred()) SWIG_fail;
14804 }
14805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14806 return resultobj;
14807 fail:
14808 return NULL;
14809 }
14810
14811
14812 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14813 PyObject *obj;
14814 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14815 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14816 Py_INCREF(obj);
14817 return Py_BuildValue((char *)"");
14818 }
14819 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14820 PyObject *resultobj;
14821 wxANIHandler *result;
14822 char *kwnames[] = {
14823 NULL
14824 };
14825
14826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14827 {
14828 PyThreadState* __tstate = wxPyBeginAllowThreads();
14829 result = (wxANIHandler *)new wxANIHandler();
14830
14831 wxPyEndAllowThreads(__tstate);
14832 if (PyErr_Occurred()) SWIG_fail;
14833 }
14834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14835 return resultobj;
14836 fail:
14837 return NULL;
14838 }
14839
14840
14841 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14842 PyObject *obj;
14843 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14844 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14845 Py_INCREF(obj);
14846 return Py_BuildValue((char *)"");
14847 }
14848 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14849 PyObject *resultobj;
14850 wxPNGHandler *result;
14851 char *kwnames[] = {
14852 NULL
14853 };
14854
14855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14856 {
14857 PyThreadState* __tstate = wxPyBeginAllowThreads();
14858 result = (wxPNGHandler *)new wxPNGHandler();
14859
14860 wxPyEndAllowThreads(__tstate);
14861 if (PyErr_Occurred()) SWIG_fail;
14862 }
14863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14864 return resultobj;
14865 fail:
14866 return NULL;
14867 }
14868
14869
14870 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14871 PyObject *obj;
14872 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14873 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14874 Py_INCREF(obj);
14875 return Py_BuildValue((char *)"");
14876 }
14877 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14878 PyObject *resultobj;
14879 wxGIFHandler *result;
14880 char *kwnames[] = {
14881 NULL
14882 };
14883
14884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14885 {
14886 PyThreadState* __tstate = wxPyBeginAllowThreads();
14887 result = (wxGIFHandler *)new wxGIFHandler();
14888
14889 wxPyEndAllowThreads(__tstate);
14890 if (PyErr_Occurred()) SWIG_fail;
14891 }
14892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14893 return resultobj;
14894 fail:
14895 return NULL;
14896 }
14897
14898
14899 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14900 PyObject *obj;
14901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14902 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14903 Py_INCREF(obj);
14904 return Py_BuildValue((char *)"");
14905 }
14906 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14907 PyObject *resultobj;
14908 wxPCXHandler *result;
14909 char *kwnames[] = {
14910 NULL
14911 };
14912
14913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (wxPCXHandler *)new wxPCXHandler();
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14929 PyObject *obj;
14930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14931 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14932 Py_INCREF(obj);
14933 return Py_BuildValue((char *)"");
14934 }
14935 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14936 PyObject *resultobj;
14937 wxJPEGHandler *result;
14938 char *kwnames[] = {
14939 NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (wxJPEGHandler *)new wxJPEGHandler();
14946
14947 wxPyEndAllowThreads(__tstate);
14948 if (PyErr_Occurred()) SWIG_fail;
14949 }
14950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14951 return resultobj;
14952 fail:
14953 return NULL;
14954 }
14955
14956
14957 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14958 PyObject *obj;
14959 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14960 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14961 Py_INCREF(obj);
14962 return Py_BuildValue((char *)"");
14963 }
14964 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14965 PyObject *resultobj;
14966 wxPNMHandler *result;
14967 char *kwnames[] = {
14968 NULL
14969 };
14970
14971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14972 {
14973 PyThreadState* __tstate = wxPyBeginAllowThreads();
14974 result = (wxPNMHandler *)new wxPNMHandler();
14975
14976 wxPyEndAllowThreads(__tstate);
14977 if (PyErr_Occurred()) SWIG_fail;
14978 }
14979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14987 PyObject *obj;
14988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14989 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14990 Py_INCREF(obj);
14991 return Py_BuildValue((char *)"");
14992 }
14993 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14994 PyObject *resultobj;
14995 wxXPMHandler *result;
14996 char *kwnames[] = {
14997 NULL
14998 };
14999
15000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 result = (wxXPMHandler *)new wxXPMHandler();
15004
15005 wxPyEndAllowThreads(__tstate);
15006 if (PyErr_Occurred()) SWIG_fail;
15007 }
15008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15016 PyObject *obj;
15017 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15018 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15019 Py_INCREF(obj);
15020 return Py_BuildValue((char *)"");
15021 }
15022 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj;
15024 wxTIFFHandler *result;
15025 char *kwnames[] = {
15026 NULL
15027 };
15028
15029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15030 {
15031 PyThreadState* __tstate = wxPyBeginAllowThreads();
15032 result = (wxTIFFHandler *)new wxTIFFHandler();
15033
15034 wxPyEndAllowThreads(__tstate);
15035 if (PyErr_Occurred()) SWIG_fail;
15036 }
15037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15038 return resultobj;
15039 fail:
15040 return NULL;
15041 }
15042
15043
15044 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15045 PyObject *obj;
15046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15047 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15048 Py_INCREF(obj);
15049 return Py_BuildValue((char *)"");
15050 }
15051 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15052 PyObject *resultobj;
15053 wxImage *arg1 = 0 ;
15054 wxImage *arg2 = 0 ;
15055 int arg3 = (int) 236 ;
15056 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15057 bool result;
15058 PyObject * obj0 = 0 ;
15059 PyObject * obj1 = 0 ;
15060 PyObject * obj2 = 0 ;
15061 PyObject * obj3 = 0 ;
15062 char *kwnames[] = {
15063 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15064 };
15065
15066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15067 {
15068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15069 if (SWIG_arg_fail(1)) SWIG_fail;
15070 if (arg1 == NULL) {
15071 SWIG_null_ref("wxImage");
15072 }
15073 if (SWIG_arg_fail(1)) SWIG_fail;
15074 }
15075 {
15076 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15077 if (SWIG_arg_fail(2)) SWIG_fail;
15078 if (arg2 == NULL) {
15079 SWIG_null_ref("wxImage");
15080 }
15081 if (SWIG_arg_fail(2)) SWIG_fail;
15082 }
15083 if (obj2) {
15084 {
15085 arg3 = (int)(SWIG_As_int(obj2));
15086 if (SWIG_arg_fail(3)) SWIG_fail;
15087 }
15088 }
15089 if (obj3) {
15090 {
15091 arg4 = (int)(SWIG_As_int(obj3));
15092 if (SWIG_arg_fail(4)) SWIG_fail;
15093 }
15094 }
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15098
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 {
15103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15104 }
15105 return resultobj;
15106 fail:
15107 return NULL;
15108 }
15109
15110
15111 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15112 PyObject *obj;
15113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15114 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15115 Py_INCREF(obj);
15116 return Py_BuildValue((char *)"");
15117 }
15118 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj;
15120 wxEvtHandler *result;
15121 char *kwnames[] = {
15122 NULL
15123 };
15124
15125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15126 {
15127 PyThreadState* __tstate = wxPyBeginAllowThreads();
15128 result = (wxEvtHandler *)new wxEvtHandler();
15129
15130 wxPyEndAllowThreads(__tstate);
15131 if (PyErr_Occurred()) SWIG_fail;
15132 }
15133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15134 return resultobj;
15135 fail:
15136 return NULL;
15137 }
15138
15139
15140 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15141 PyObject *resultobj;
15142 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15143 wxEvtHandler *result;
15144 PyObject * obj0 = 0 ;
15145 char *kwnames[] = {
15146 (char *) "self", NULL
15147 };
15148
15149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15151 if (SWIG_arg_fail(1)) SWIG_fail;
15152 {
15153 PyThreadState* __tstate = wxPyBeginAllowThreads();
15154 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15155
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 {
15160 resultobj = wxPyMake_wxObject(result, 0);
15161 }
15162 return resultobj;
15163 fail:
15164 return NULL;
15165 }
15166
15167
15168 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15169 PyObject *resultobj;
15170 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15171 wxEvtHandler *result;
15172 PyObject * obj0 = 0 ;
15173 char *kwnames[] = {
15174 (char *) "self", NULL
15175 };
15176
15177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15179 if (SWIG_arg_fail(1)) SWIG_fail;
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15183
15184 wxPyEndAllowThreads(__tstate);
15185 if (PyErr_Occurred()) SWIG_fail;
15186 }
15187 {
15188 resultobj = wxPyMake_wxObject(result, 0);
15189 }
15190 return resultobj;
15191 fail:
15192 return NULL;
15193 }
15194
15195
15196 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15197 PyObject *resultobj;
15198 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15199 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15200 PyObject * obj0 = 0 ;
15201 PyObject * obj1 = 0 ;
15202 char *kwnames[] = {
15203 (char *) "self",(char *) "handler", NULL
15204 };
15205
15206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15208 if (SWIG_arg_fail(1)) SWIG_fail;
15209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15210 if (SWIG_arg_fail(2)) SWIG_fail;
15211 {
15212 PyThreadState* __tstate = wxPyBeginAllowThreads();
15213 (arg1)->SetNextHandler(arg2);
15214
15215 wxPyEndAllowThreads(__tstate);
15216 if (PyErr_Occurred()) SWIG_fail;
15217 }
15218 Py_INCREF(Py_None); resultobj = Py_None;
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15226 PyObject *resultobj;
15227 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15228 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15229 PyObject * obj0 = 0 ;
15230 PyObject * obj1 = 0 ;
15231 char *kwnames[] = {
15232 (char *) "self",(char *) "handler", NULL
15233 };
15234
15235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15237 if (SWIG_arg_fail(1)) SWIG_fail;
15238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15239 if (SWIG_arg_fail(2)) SWIG_fail;
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 (arg1)->SetPreviousHandler(arg2);
15243
15244 wxPyEndAllowThreads(__tstate);
15245 if (PyErr_Occurred()) SWIG_fail;
15246 }
15247 Py_INCREF(Py_None); resultobj = Py_None;
15248 return resultobj;
15249 fail:
15250 return NULL;
15251 }
15252
15253
15254 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15255 PyObject *resultobj;
15256 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15257 bool result;
15258 PyObject * obj0 = 0 ;
15259 char *kwnames[] = {
15260 (char *) "self", NULL
15261 };
15262
15263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15265 if (SWIG_arg_fail(1)) SWIG_fail;
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 result = (bool)(arg1)->GetEvtHandlerEnabled();
15269
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 {
15274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15275 }
15276 return resultobj;
15277 fail:
15278 return NULL;
15279 }
15280
15281
15282 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15283 PyObject *resultobj;
15284 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15285 bool arg2 ;
15286 PyObject * obj0 = 0 ;
15287 PyObject * obj1 = 0 ;
15288 char *kwnames[] = {
15289 (char *) "self",(char *) "enabled", NULL
15290 };
15291
15292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15294 if (SWIG_arg_fail(1)) SWIG_fail;
15295 {
15296 arg2 = (bool)(SWIG_As_bool(obj1));
15297 if (SWIG_arg_fail(2)) SWIG_fail;
15298 }
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 (arg1)->SetEvtHandlerEnabled(arg2);
15302
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 Py_INCREF(Py_None); resultobj = Py_None;
15307 return resultobj;
15308 fail:
15309 return NULL;
15310 }
15311
15312
15313 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15314 PyObject *resultobj;
15315 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15316 wxEvent *arg2 = 0 ;
15317 bool result;
15318 PyObject * obj0 = 0 ;
15319 PyObject * obj1 = 0 ;
15320 char *kwnames[] = {
15321 (char *) "self",(char *) "event", NULL
15322 };
15323
15324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15326 if (SWIG_arg_fail(1)) SWIG_fail;
15327 {
15328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15329 if (SWIG_arg_fail(2)) SWIG_fail;
15330 if (arg2 == NULL) {
15331 SWIG_null_ref("wxEvent");
15332 }
15333 if (SWIG_arg_fail(2)) SWIG_fail;
15334 }
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 result = (bool)(arg1)->ProcessEvent(*arg2);
15338
15339 wxPyEndAllowThreads(__tstate);
15340 if (PyErr_Occurred()) SWIG_fail;
15341 }
15342 {
15343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15344 }
15345 return resultobj;
15346 fail:
15347 return NULL;
15348 }
15349
15350
15351 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15352 PyObject *resultobj;
15353 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15354 wxEvent *arg2 = 0 ;
15355 PyObject * obj0 = 0 ;
15356 PyObject * obj1 = 0 ;
15357 char *kwnames[] = {
15358 (char *) "self",(char *) "event", NULL
15359 };
15360
15361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15363 if (SWIG_arg_fail(1)) SWIG_fail;
15364 {
15365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15366 if (SWIG_arg_fail(2)) SWIG_fail;
15367 if (arg2 == NULL) {
15368 SWIG_null_ref("wxEvent");
15369 }
15370 if (SWIG_arg_fail(2)) SWIG_fail;
15371 }
15372 {
15373 PyThreadState* __tstate = wxPyBeginAllowThreads();
15374 (arg1)->AddPendingEvent(*arg2);
15375
15376 wxPyEndAllowThreads(__tstate);
15377 if (PyErr_Occurred()) SWIG_fail;
15378 }
15379 Py_INCREF(Py_None); resultobj = Py_None;
15380 return resultobj;
15381 fail:
15382 return NULL;
15383 }
15384
15385
15386 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15387 PyObject *resultobj;
15388 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15389 PyObject * obj0 = 0 ;
15390 char *kwnames[] = {
15391 (char *) "self", NULL
15392 };
15393
15394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15396 if (SWIG_arg_fail(1)) SWIG_fail;
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 (arg1)->ProcessPendingEvents();
15400
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 Py_INCREF(Py_None); resultobj = Py_None;
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15412 PyObject *resultobj;
15413 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15414 int arg2 ;
15415 int arg3 ;
15416 int arg4 ;
15417 PyObject *arg5 = (PyObject *) 0 ;
15418 PyObject * obj0 = 0 ;
15419 PyObject * obj1 = 0 ;
15420 PyObject * obj2 = 0 ;
15421 PyObject * obj3 = 0 ;
15422 PyObject * obj4 = 0 ;
15423 char *kwnames[] = {
15424 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15425 };
15426
15427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15429 if (SWIG_arg_fail(1)) SWIG_fail;
15430 {
15431 arg2 = (int)(SWIG_As_int(obj1));
15432 if (SWIG_arg_fail(2)) SWIG_fail;
15433 }
15434 {
15435 arg3 = (int)(SWIG_As_int(obj2));
15436 if (SWIG_arg_fail(3)) SWIG_fail;
15437 }
15438 {
15439 arg4 = (int)(SWIG_As_int(obj3));
15440 if (SWIG_arg_fail(4)) SWIG_fail;
15441 }
15442 arg5 = obj4;
15443 {
15444 PyThreadState* __tstate = wxPyBeginAllowThreads();
15445 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15446
15447 wxPyEndAllowThreads(__tstate);
15448 if (PyErr_Occurred()) SWIG_fail;
15449 }
15450 Py_INCREF(Py_None); resultobj = Py_None;
15451 return resultobj;
15452 fail:
15453 return NULL;
15454 }
15455
15456
15457 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15458 PyObject *resultobj;
15459 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15460 int arg2 ;
15461 int arg3 = (int) -1 ;
15462 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15463 bool result;
15464 PyObject * obj0 = 0 ;
15465 PyObject * obj1 = 0 ;
15466 PyObject * obj2 = 0 ;
15467 PyObject * obj3 = 0 ;
15468 char *kwnames[] = {
15469 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15470 };
15471
15472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15474 if (SWIG_arg_fail(1)) SWIG_fail;
15475 {
15476 arg2 = (int)(SWIG_As_int(obj1));
15477 if (SWIG_arg_fail(2)) SWIG_fail;
15478 }
15479 if (obj2) {
15480 {
15481 arg3 = (int)(SWIG_As_int(obj2));
15482 if (SWIG_arg_fail(3)) SWIG_fail;
15483 }
15484 }
15485 if (obj3) {
15486 {
15487 arg4 = (wxEventType)(SWIG_As_int(obj3));
15488 if (SWIG_arg_fail(4)) SWIG_fail;
15489 }
15490 }
15491 {
15492 PyThreadState* __tstate = wxPyBeginAllowThreads();
15493 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15494
15495 wxPyEndAllowThreads(__tstate);
15496 if (PyErr_Occurred()) SWIG_fail;
15497 }
15498 {
15499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15500 }
15501 return resultobj;
15502 fail:
15503 return NULL;
15504 }
15505
15506
15507 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15508 PyObject *resultobj;
15509 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15510 PyObject *arg2 = (PyObject *) 0 ;
15511 bool arg3 = (bool) true ;
15512 PyObject * obj0 = 0 ;
15513 PyObject * obj1 = 0 ;
15514 PyObject * obj2 = 0 ;
15515 char *kwnames[] = {
15516 (char *) "self",(char *) "_self",(char *) "incref", NULL
15517 };
15518
15519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15521 if (SWIG_arg_fail(1)) SWIG_fail;
15522 arg2 = obj1;
15523 if (obj2) {
15524 {
15525 arg3 = (bool)(SWIG_As_bool(obj2));
15526 if (SWIG_arg_fail(3)) SWIG_fail;
15527 }
15528 }
15529 {
15530 PyThreadState* __tstate = wxPyBeginAllowThreads();
15531 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15532
15533 wxPyEndAllowThreads(__tstate);
15534 if (PyErr_Occurred()) SWIG_fail;
15535 }
15536 Py_INCREF(Py_None); resultobj = Py_None;
15537 return resultobj;
15538 fail:
15539 return NULL;
15540 }
15541
15542
15543 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15544 PyObject *obj;
15545 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15546 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15547 Py_INCREF(obj);
15548 return Py_BuildValue((char *)"");
15549 }
15550 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15551 PyObject *resultobj;
15552 wxEventType result;
15553 char *kwnames[] = {
15554 NULL
15555 };
15556
15557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15558 {
15559 PyThreadState* __tstate = wxPyBeginAllowThreads();
15560 result = (wxEventType)wxNewEventType();
15561
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 {
15566 resultobj = SWIG_From_int((int)(result));
15567 }
15568 return resultobj;
15569 fail:
15570 return NULL;
15571 }
15572
15573
15574 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15575 PyObject *resultobj;
15576 wxEvent *arg1 = (wxEvent *) 0 ;
15577 PyObject * obj0 = 0 ;
15578 char *kwnames[] = {
15579 (char *) "self", NULL
15580 };
15581
15582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15584 if (SWIG_arg_fail(1)) SWIG_fail;
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 delete arg1;
15588
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 Py_INCREF(Py_None); resultobj = Py_None;
15593 return resultobj;
15594 fail:
15595 return NULL;
15596 }
15597
15598
15599 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15600 PyObject *resultobj;
15601 wxEvent *arg1 = (wxEvent *) 0 ;
15602 wxEventType arg2 ;
15603 PyObject * obj0 = 0 ;
15604 PyObject * obj1 = 0 ;
15605 char *kwnames[] = {
15606 (char *) "self",(char *) "typ", NULL
15607 };
15608
15609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15611 if (SWIG_arg_fail(1)) SWIG_fail;
15612 {
15613 arg2 = (wxEventType)(SWIG_As_int(obj1));
15614 if (SWIG_arg_fail(2)) SWIG_fail;
15615 }
15616 {
15617 PyThreadState* __tstate = wxPyBeginAllowThreads();
15618 (arg1)->SetEventType(arg2);
15619
15620 wxPyEndAllowThreads(__tstate);
15621 if (PyErr_Occurred()) SWIG_fail;
15622 }
15623 Py_INCREF(Py_None); resultobj = Py_None;
15624 return resultobj;
15625 fail:
15626 return NULL;
15627 }
15628
15629
15630 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15631 PyObject *resultobj;
15632 wxEvent *arg1 = (wxEvent *) 0 ;
15633 wxEventType result;
15634 PyObject * obj0 = 0 ;
15635 char *kwnames[] = {
15636 (char *) "self", NULL
15637 };
15638
15639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15641 if (SWIG_arg_fail(1)) SWIG_fail;
15642 {
15643 PyThreadState* __tstate = wxPyBeginAllowThreads();
15644 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15645
15646 wxPyEndAllowThreads(__tstate);
15647 if (PyErr_Occurred()) SWIG_fail;
15648 }
15649 {
15650 resultobj = SWIG_From_int((int)(result));
15651 }
15652 return resultobj;
15653 fail:
15654 return NULL;
15655 }
15656
15657
15658 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15659 PyObject *resultobj;
15660 wxEvent *arg1 = (wxEvent *) 0 ;
15661 wxObject *result;
15662 PyObject * obj0 = 0 ;
15663 char *kwnames[] = {
15664 (char *) "self", NULL
15665 };
15666
15667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15669 if (SWIG_arg_fail(1)) SWIG_fail;
15670 {
15671 PyThreadState* __tstate = wxPyBeginAllowThreads();
15672 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15673
15674 wxPyEndAllowThreads(__tstate);
15675 if (PyErr_Occurred()) SWIG_fail;
15676 }
15677 {
15678 resultobj = wxPyMake_wxObject(result, 0);
15679 }
15680 return resultobj;
15681 fail:
15682 return NULL;
15683 }
15684
15685
15686 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15687 PyObject *resultobj;
15688 wxEvent *arg1 = (wxEvent *) 0 ;
15689 wxObject *arg2 = (wxObject *) 0 ;
15690 PyObject * obj0 = 0 ;
15691 PyObject * obj1 = 0 ;
15692 char *kwnames[] = {
15693 (char *) "self",(char *) "obj", NULL
15694 };
15695
15696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15698 if (SWIG_arg_fail(1)) SWIG_fail;
15699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15700 if (SWIG_arg_fail(2)) SWIG_fail;
15701 {
15702 PyThreadState* __tstate = wxPyBeginAllowThreads();
15703 (arg1)->SetEventObject(arg2);
15704
15705 wxPyEndAllowThreads(__tstate);
15706 if (PyErr_Occurred()) SWIG_fail;
15707 }
15708 Py_INCREF(Py_None); resultobj = Py_None;
15709 return resultobj;
15710 fail:
15711 return NULL;
15712 }
15713
15714
15715 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15716 PyObject *resultobj;
15717 wxEvent *arg1 = (wxEvent *) 0 ;
15718 long result;
15719 PyObject * obj0 = 0 ;
15720 char *kwnames[] = {
15721 (char *) "self", NULL
15722 };
15723
15724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15726 if (SWIG_arg_fail(1)) SWIG_fail;
15727 {
15728 PyThreadState* __tstate = wxPyBeginAllowThreads();
15729 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15730
15731 wxPyEndAllowThreads(__tstate);
15732 if (PyErr_Occurred()) SWIG_fail;
15733 }
15734 {
15735 resultobj = SWIG_From_long((long)(result));
15736 }
15737 return resultobj;
15738 fail:
15739 return NULL;
15740 }
15741
15742
15743 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15744 PyObject *resultobj;
15745 wxEvent *arg1 = (wxEvent *) 0 ;
15746 long arg2 = (long) 0 ;
15747 PyObject * obj0 = 0 ;
15748 PyObject * obj1 = 0 ;
15749 char *kwnames[] = {
15750 (char *) "self",(char *) "ts", NULL
15751 };
15752
15753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15755 if (SWIG_arg_fail(1)) SWIG_fail;
15756 if (obj1) {
15757 {
15758 arg2 = (long)(SWIG_As_long(obj1));
15759 if (SWIG_arg_fail(2)) SWIG_fail;
15760 }
15761 }
15762 {
15763 PyThreadState* __tstate = wxPyBeginAllowThreads();
15764 (arg1)->SetTimestamp(arg2);
15765
15766 wxPyEndAllowThreads(__tstate);
15767 if (PyErr_Occurred()) SWIG_fail;
15768 }
15769 Py_INCREF(Py_None); resultobj = Py_None;
15770 return resultobj;
15771 fail:
15772 return NULL;
15773 }
15774
15775
15776 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj;
15778 wxEvent *arg1 = (wxEvent *) 0 ;
15779 int result;
15780 PyObject * obj0 = 0 ;
15781 char *kwnames[] = {
15782 (char *) "self", NULL
15783 };
15784
15785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15787 if (SWIG_arg_fail(1)) SWIG_fail;
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (int)((wxEvent const *)arg1)->GetId();
15791
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 {
15796 resultobj = SWIG_From_int((int)(result));
15797 }
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15805 PyObject *resultobj;
15806 wxEvent *arg1 = (wxEvent *) 0 ;
15807 int arg2 ;
15808 PyObject * obj0 = 0 ;
15809 PyObject * obj1 = 0 ;
15810 char *kwnames[] = {
15811 (char *) "self",(char *) "Id", NULL
15812 };
15813
15814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15816 if (SWIG_arg_fail(1)) SWIG_fail;
15817 {
15818 arg2 = (int)(SWIG_As_int(obj1));
15819 if (SWIG_arg_fail(2)) SWIG_fail;
15820 }
15821 {
15822 PyThreadState* __tstate = wxPyBeginAllowThreads();
15823 (arg1)->SetId(arg2);
15824
15825 wxPyEndAllowThreads(__tstate);
15826 if (PyErr_Occurred()) SWIG_fail;
15827 }
15828 Py_INCREF(Py_None); resultobj = Py_None;
15829 return resultobj;
15830 fail:
15831 return NULL;
15832 }
15833
15834
15835 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15836 PyObject *resultobj;
15837 wxEvent *arg1 = (wxEvent *) 0 ;
15838 bool result;
15839 PyObject * obj0 = 0 ;
15840 char *kwnames[] = {
15841 (char *) "self", NULL
15842 };
15843
15844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15846 if (SWIG_arg_fail(1)) SWIG_fail;
15847 {
15848 PyThreadState* __tstate = wxPyBeginAllowThreads();
15849 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15850
15851 wxPyEndAllowThreads(__tstate);
15852 if (PyErr_Occurred()) SWIG_fail;
15853 }
15854 {
15855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15856 }
15857 return resultobj;
15858 fail:
15859 return NULL;
15860 }
15861
15862
15863 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj;
15865 wxEvent *arg1 = (wxEvent *) 0 ;
15866 bool arg2 = (bool) true ;
15867 PyObject * obj0 = 0 ;
15868 PyObject * obj1 = 0 ;
15869 char *kwnames[] = {
15870 (char *) "self",(char *) "skip", NULL
15871 };
15872
15873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15875 if (SWIG_arg_fail(1)) SWIG_fail;
15876 if (obj1) {
15877 {
15878 arg2 = (bool)(SWIG_As_bool(obj1));
15879 if (SWIG_arg_fail(2)) SWIG_fail;
15880 }
15881 }
15882 {
15883 PyThreadState* __tstate = wxPyBeginAllowThreads();
15884 (arg1)->Skip(arg2);
15885
15886 wxPyEndAllowThreads(__tstate);
15887 if (PyErr_Occurred()) SWIG_fail;
15888 }
15889 Py_INCREF(Py_None); resultobj = Py_None;
15890 return resultobj;
15891 fail:
15892 return NULL;
15893 }
15894
15895
15896 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15897 PyObject *resultobj;
15898 wxEvent *arg1 = (wxEvent *) 0 ;
15899 bool result;
15900 PyObject * obj0 = 0 ;
15901 char *kwnames[] = {
15902 (char *) "self", NULL
15903 };
15904
15905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15907 if (SWIG_arg_fail(1)) SWIG_fail;
15908 {
15909 PyThreadState* __tstate = wxPyBeginAllowThreads();
15910 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15911
15912 wxPyEndAllowThreads(__tstate);
15913 if (PyErr_Occurred()) SWIG_fail;
15914 }
15915 {
15916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15917 }
15918 return resultobj;
15919 fail:
15920 return NULL;
15921 }
15922
15923
15924 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15925 PyObject *resultobj;
15926 wxEvent *arg1 = (wxEvent *) 0 ;
15927 bool result;
15928 PyObject * obj0 = 0 ;
15929 char *kwnames[] = {
15930 (char *) "self", NULL
15931 };
15932
15933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15935 if (SWIG_arg_fail(1)) SWIG_fail;
15936 {
15937 PyThreadState* __tstate = wxPyBeginAllowThreads();
15938 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15939
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 {
15944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15945 }
15946 return resultobj;
15947 fail:
15948 return NULL;
15949 }
15950
15951
15952 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15953 PyObject *resultobj;
15954 wxEvent *arg1 = (wxEvent *) 0 ;
15955 int result;
15956 PyObject * obj0 = 0 ;
15957 char *kwnames[] = {
15958 (char *) "self", NULL
15959 };
15960
15961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15963 if (SWIG_arg_fail(1)) SWIG_fail;
15964 {
15965 PyThreadState* __tstate = wxPyBeginAllowThreads();
15966 result = (int)(arg1)->StopPropagation();
15967
15968 wxPyEndAllowThreads(__tstate);
15969 if (PyErr_Occurred()) SWIG_fail;
15970 }
15971 {
15972 resultobj = SWIG_From_int((int)(result));
15973 }
15974 return resultobj;
15975 fail:
15976 return NULL;
15977 }
15978
15979
15980 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15981 PyObject *resultobj;
15982 wxEvent *arg1 = (wxEvent *) 0 ;
15983 int arg2 ;
15984 PyObject * obj0 = 0 ;
15985 PyObject * obj1 = 0 ;
15986 char *kwnames[] = {
15987 (char *) "self",(char *) "propagationLevel", NULL
15988 };
15989
15990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15992 if (SWIG_arg_fail(1)) SWIG_fail;
15993 {
15994 arg2 = (int)(SWIG_As_int(obj1));
15995 if (SWIG_arg_fail(2)) SWIG_fail;
15996 }
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 (arg1)->ResumePropagation(arg2);
16000
16001 wxPyEndAllowThreads(__tstate);
16002 if (PyErr_Occurred()) SWIG_fail;
16003 }
16004 Py_INCREF(Py_None); resultobj = Py_None;
16005 return resultobj;
16006 fail:
16007 return NULL;
16008 }
16009
16010
16011 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16012 PyObject *resultobj;
16013 wxEvent *arg1 = (wxEvent *) 0 ;
16014 wxEvent *result;
16015 PyObject * obj0 = 0 ;
16016 char *kwnames[] = {
16017 (char *) "self", NULL
16018 };
16019
16020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16022 if (SWIG_arg_fail(1)) SWIG_fail;
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 result = (wxEvent *)(arg1)->Clone();
16026
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16038 PyObject *obj;
16039 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16040 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16041 Py_INCREF(obj);
16042 return Py_BuildValue((char *)"");
16043 }
16044 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16045 PyObject *resultobj;
16046 wxEvent *arg1 = 0 ;
16047 wxPropagationDisabler *result;
16048 PyObject * obj0 = 0 ;
16049 char *kwnames[] = {
16050 (char *) "event", NULL
16051 };
16052
16053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16054 {
16055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16056 if (SWIG_arg_fail(1)) SWIG_fail;
16057 if (arg1 == NULL) {
16058 SWIG_null_ref("wxEvent");
16059 }
16060 if (SWIG_arg_fail(1)) SWIG_fail;
16061 }
16062 {
16063 PyThreadState* __tstate = wxPyBeginAllowThreads();
16064 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16065
16066 wxPyEndAllowThreads(__tstate);
16067 if (PyErr_Occurred()) SWIG_fail;
16068 }
16069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16070 return resultobj;
16071 fail:
16072 return NULL;
16073 }
16074
16075
16076 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16077 PyObject *resultobj;
16078 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16079 PyObject * obj0 = 0 ;
16080 char *kwnames[] = {
16081 (char *) "self", NULL
16082 };
16083
16084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16086 if (SWIG_arg_fail(1)) SWIG_fail;
16087 {
16088 PyThreadState* __tstate = wxPyBeginAllowThreads();
16089 delete arg1;
16090
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 Py_INCREF(Py_None); resultobj = Py_None;
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16102 PyObject *obj;
16103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16104 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16105 Py_INCREF(obj);
16106 return Py_BuildValue((char *)"");
16107 }
16108 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj;
16110 wxEvent *arg1 = 0 ;
16111 wxPropagateOnce *result;
16112 PyObject * obj0 = 0 ;
16113 char *kwnames[] = {
16114 (char *) "event", NULL
16115 };
16116
16117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16118 {
16119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16120 if (SWIG_arg_fail(1)) SWIG_fail;
16121 if (arg1 == NULL) {
16122 SWIG_null_ref("wxEvent");
16123 }
16124 if (SWIG_arg_fail(1)) SWIG_fail;
16125 }
16126 {
16127 PyThreadState* __tstate = wxPyBeginAllowThreads();
16128 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16129
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16141 PyObject *resultobj;
16142 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16143 PyObject * obj0 = 0 ;
16144 char *kwnames[] = {
16145 (char *) "self", NULL
16146 };
16147
16148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16150 if (SWIG_arg_fail(1)) SWIG_fail;
16151 {
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 delete arg1;
16154
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 Py_INCREF(Py_None); resultobj = Py_None;
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16166 PyObject *obj;
16167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16168 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16169 Py_INCREF(obj);
16170 return Py_BuildValue((char *)"");
16171 }
16172 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16173 PyObject *resultobj;
16174 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16175 int arg2 = (int) 0 ;
16176 wxCommandEvent *result;
16177 PyObject * obj0 = 0 ;
16178 PyObject * obj1 = 0 ;
16179 char *kwnames[] = {
16180 (char *) "commandType",(char *) "winid", NULL
16181 };
16182
16183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16184 if (obj0) {
16185 {
16186 arg1 = (wxEventType)(SWIG_As_int(obj0));
16187 if (SWIG_arg_fail(1)) SWIG_fail;
16188 }
16189 }
16190 if (obj1) {
16191 {
16192 arg2 = (int)(SWIG_As_int(obj1));
16193 if (SWIG_arg_fail(2)) SWIG_fail;
16194 }
16195 }
16196 {
16197 PyThreadState* __tstate = wxPyBeginAllowThreads();
16198 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16199
16200 wxPyEndAllowThreads(__tstate);
16201 if (PyErr_Occurred()) SWIG_fail;
16202 }
16203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16204 return resultobj;
16205 fail:
16206 return NULL;
16207 }
16208
16209
16210 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16211 PyObject *resultobj;
16212 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16213 int result;
16214 PyObject * obj0 = 0 ;
16215 char *kwnames[] = {
16216 (char *) "self", NULL
16217 };
16218
16219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16221 if (SWIG_arg_fail(1)) SWIG_fail;
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16225
16226 wxPyEndAllowThreads(__tstate);
16227 if (PyErr_Occurred()) SWIG_fail;
16228 }
16229 {
16230 resultobj = SWIG_From_int((int)(result));
16231 }
16232 return resultobj;
16233 fail:
16234 return NULL;
16235 }
16236
16237
16238 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16239 PyObject *resultobj;
16240 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16241 wxString *arg2 = 0 ;
16242 bool temp2 = false ;
16243 PyObject * obj0 = 0 ;
16244 PyObject * obj1 = 0 ;
16245 char *kwnames[] = {
16246 (char *) "self",(char *) "s", NULL
16247 };
16248
16249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16251 if (SWIG_arg_fail(1)) SWIG_fail;
16252 {
16253 arg2 = wxString_in_helper(obj1);
16254 if (arg2 == NULL) SWIG_fail;
16255 temp2 = true;
16256 }
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 (arg1)->SetString((wxString const &)*arg2);
16260
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 Py_INCREF(Py_None); resultobj = Py_None;
16265 {
16266 if (temp2)
16267 delete arg2;
16268 }
16269 return resultobj;
16270 fail:
16271 {
16272 if (temp2)
16273 delete arg2;
16274 }
16275 return NULL;
16276 }
16277
16278
16279 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj;
16281 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16282 wxString result;
16283 PyObject * obj0 = 0 ;
16284 char *kwnames[] = {
16285 (char *) "self", NULL
16286 };
16287
16288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16290 if (SWIG_arg_fail(1)) SWIG_fail;
16291 {
16292 PyThreadState* __tstate = wxPyBeginAllowThreads();
16293 result = ((wxCommandEvent const *)arg1)->GetString();
16294
16295 wxPyEndAllowThreads(__tstate);
16296 if (PyErr_Occurred()) SWIG_fail;
16297 }
16298 {
16299 #if wxUSE_UNICODE
16300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16301 #else
16302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16303 #endif
16304 }
16305 return resultobj;
16306 fail:
16307 return NULL;
16308 }
16309
16310
16311 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16312 PyObject *resultobj;
16313 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16314 bool result;
16315 PyObject * obj0 = 0 ;
16316 char *kwnames[] = {
16317 (char *) "self", NULL
16318 };
16319
16320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16322 if (SWIG_arg_fail(1)) SWIG_fail;
16323 {
16324 PyThreadState* __tstate = wxPyBeginAllowThreads();
16325 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16326
16327 wxPyEndAllowThreads(__tstate);
16328 if (PyErr_Occurred()) SWIG_fail;
16329 }
16330 {
16331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16332 }
16333 return resultobj;
16334 fail:
16335 return NULL;
16336 }
16337
16338
16339 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16340 PyObject *resultobj;
16341 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16342 bool result;
16343 PyObject * obj0 = 0 ;
16344 char *kwnames[] = {
16345 (char *) "self", NULL
16346 };
16347
16348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16350 if (SWIG_arg_fail(1)) SWIG_fail;
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16354
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 {
16359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16360 }
16361 return resultobj;
16362 fail:
16363 return NULL;
16364 }
16365
16366
16367 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16368 PyObject *resultobj;
16369 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16370 long arg2 ;
16371 PyObject * obj0 = 0 ;
16372 PyObject * obj1 = 0 ;
16373 char *kwnames[] = {
16374 (char *) "self",(char *) "extraLong", NULL
16375 };
16376
16377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16379 if (SWIG_arg_fail(1)) SWIG_fail;
16380 {
16381 arg2 = (long)(SWIG_As_long(obj1));
16382 if (SWIG_arg_fail(2)) SWIG_fail;
16383 }
16384 {
16385 PyThreadState* __tstate = wxPyBeginAllowThreads();
16386 (arg1)->SetExtraLong(arg2);
16387
16388 wxPyEndAllowThreads(__tstate);
16389 if (PyErr_Occurred()) SWIG_fail;
16390 }
16391 Py_INCREF(Py_None); resultobj = Py_None;
16392 return resultobj;
16393 fail:
16394 return NULL;
16395 }
16396
16397
16398 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16399 PyObject *resultobj;
16400 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16401 long result;
16402 PyObject * obj0 = 0 ;
16403 char *kwnames[] = {
16404 (char *) "self", NULL
16405 };
16406
16407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16409 if (SWIG_arg_fail(1)) SWIG_fail;
16410 {
16411 PyThreadState* __tstate = wxPyBeginAllowThreads();
16412 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16413
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 {
16418 resultobj = SWIG_From_long((long)(result));
16419 }
16420 return resultobj;
16421 fail:
16422 return NULL;
16423 }
16424
16425
16426 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16427 PyObject *resultobj;
16428 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16429 int arg2 ;
16430 PyObject * obj0 = 0 ;
16431 PyObject * obj1 = 0 ;
16432 char *kwnames[] = {
16433 (char *) "self",(char *) "i", NULL
16434 };
16435
16436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16438 if (SWIG_arg_fail(1)) SWIG_fail;
16439 {
16440 arg2 = (int)(SWIG_As_int(obj1));
16441 if (SWIG_arg_fail(2)) SWIG_fail;
16442 }
16443 {
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 (arg1)->SetInt(arg2);
16446
16447 wxPyEndAllowThreads(__tstate);
16448 if (PyErr_Occurred()) SWIG_fail;
16449 }
16450 Py_INCREF(Py_None); resultobj = Py_None;
16451 return resultobj;
16452 fail:
16453 return NULL;
16454 }
16455
16456
16457 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16458 PyObject *resultobj;
16459 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16460 long result;
16461 PyObject * obj0 = 0 ;
16462 char *kwnames[] = {
16463 (char *) "self", NULL
16464 };
16465
16466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16468 if (SWIG_arg_fail(1)) SWIG_fail;
16469 {
16470 PyThreadState* __tstate = wxPyBeginAllowThreads();
16471 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16472
16473 wxPyEndAllowThreads(__tstate);
16474 if (PyErr_Occurred()) SWIG_fail;
16475 }
16476 {
16477 resultobj = SWIG_From_long((long)(result));
16478 }
16479 return resultobj;
16480 fail:
16481 return NULL;
16482 }
16483
16484
16485 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16486 PyObject *resultobj;
16487 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16488 wxEvent *result;
16489 PyObject * obj0 = 0 ;
16490 char *kwnames[] = {
16491 (char *) "self", NULL
16492 };
16493
16494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16496 if (SWIG_arg_fail(1)) SWIG_fail;
16497 {
16498 PyThreadState* __tstate = wxPyBeginAllowThreads();
16499 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16500
16501 wxPyEndAllowThreads(__tstate);
16502 if (PyErr_Occurred()) SWIG_fail;
16503 }
16504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16505 return resultobj;
16506 fail:
16507 return NULL;
16508 }
16509
16510
16511 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16512 PyObject *obj;
16513 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16514 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16515 Py_INCREF(obj);
16516 return Py_BuildValue((char *)"");
16517 }
16518 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16519 PyObject *resultobj;
16520 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16521 int arg2 = (int) 0 ;
16522 wxNotifyEvent *result;
16523 PyObject * obj0 = 0 ;
16524 PyObject * obj1 = 0 ;
16525 char *kwnames[] = {
16526 (char *) "commandType",(char *) "winid", NULL
16527 };
16528
16529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16530 if (obj0) {
16531 {
16532 arg1 = (wxEventType)(SWIG_As_int(obj0));
16533 if (SWIG_arg_fail(1)) SWIG_fail;
16534 }
16535 }
16536 if (obj1) {
16537 {
16538 arg2 = (int)(SWIG_As_int(obj1));
16539 if (SWIG_arg_fail(2)) SWIG_fail;
16540 }
16541 }
16542 {
16543 PyThreadState* __tstate = wxPyBeginAllowThreads();
16544 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16545
16546 wxPyEndAllowThreads(__tstate);
16547 if (PyErr_Occurred()) SWIG_fail;
16548 }
16549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16550 return resultobj;
16551 fail:
16552 return NULL;
16553 }
16554
16555
16556 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16557 PyObject *resultobj;
16558 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16559 PyObject * obj0 = 0 ;
16560 char *kwnames[] = {
16561 (char *) "self", NULL
16562 };
16563
16564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16566 if (SWIG_arg_fail(1)) SWIG_fail;
16567 {
16568 PyThreadState* __tstate = wxPyBeginAllowThreads();
16569 (arg1)->Veto();
16570
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 Py_INCREF(Py_None); resultobj = Py_None;
16575 return resultobj;
16576 fail:
16577 return NULL;
16578 }
16579
16580
16581 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16582 PyObject *resultobj;
16583 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16584 PyObject * obj0 = 0 ;
16585 char *kwnames[] = {
16586 (char *) "self", NULL
16587 };
16588
16589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16591 if (SWIG_arg_fail(1)) SWIG_fail;
16592 {
16593 PyThreadState* __tstate = wxPyBeginAllowThreads();
16594 (arg1)->Allow();
16595
16596 wxPyEndAllowThreads(__tstate);
16597 if (PyErr_Occurred()) SWIG_fail;
16598 }
16599 Py_INCREF(Py_None); resultobj = Py_None;
16600 return resultobj;
16601 fail:
16602 return NULL;
16603 }
16604
16605
16606 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16607 PyObject *resultobj;
16608 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16609 bool result;
16610 PyObject * obj0 = 0 ;
16611 char *kwnames[] = {
16612 (char *) "self", NULL
16613 };
16614
16615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16617 if (SWIG_arg_fail(1)) SWIG_fail;
16618 {
16619 PyThreadState* __tstate = wxPyBeginAllowThreads();
16620 result = (bool)(arg1)->IsAllowed();
16621
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 {
16626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16627 }
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16635 PyObject *obj;
16636 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16637 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16638 Py_INCREF(obj);
16639 return Py_BuildValue((char *)"");
16640 }
16641 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16642 PyObject *resultobj;
16643 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16644 int arg2 = (int) 0 ;
16645 int arg3 = (int) 0 ;
16646 int arg4 = (int) 0 ;
16647 wxScrollEvent *result;
16648 PyObject * obj0 = 0 ;
16649 PyObject * obj1 = 0 ;
16650 PyObject * obj2 = 0 ;
16651 PyObject * obj3 = 0 ;
16652 char *kwnames[] = {
16653 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16654 };
16655
16656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16657 if (obj0) {
16658 {
16659 arg1 = (wxEventType)(SWIG_As_int(obj0));
16660 if (SWIG_arg_fail(1)) SWIG_fail;
16661 }
16662 }
16663 if (obj1) {
16664 {
16665 arg2 = (int)(SWIG_As_int(obj1));
16666 if (SWIG_arg_fail(2)) SWIG_fail;
16667 }
16668 }
16669 if (obj2) {
16670 {
16671 arg3 = (int)(SWIG_As_int(obj2));
16672 if (SWIG_arg_fail(3)) SWIG_fail;
16673 }
16674 }
16675 if (obj3) {
16676 {
16677 arg4 = (int)(SWIG_As_int(obj3));
16678 if (SWIG_arg_fail(4)) SWIG_fail;
16679 }
16680 }
16681 {
16682 PyThreadState* __tstate = wxPyBeginAllowThreads();
16683 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16684
16685 wxPyEndAllowThreads(__tstate);
16686 if (PyErr_Occurred()) SWIG_fail;
16687 }
16688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16689 return resultobj;
16690 fail:
16691 return NULL;
16692 }
16693
16694
16695 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16696 PyObject *resultobj;
16697 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16698 int result;
16699 PyObject * obj0 = 0 ;
16700 char *kwnames[] = {
16701 (char *) "self", NULL
16702 };
16703
16704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16706 if (SWIG_arg_fail(1)) SWIG_fail;
16707 {
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16710
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 {
16715 resultobj = SWIG_From_int((int)(result));
16716 }
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj;
16725 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16726 int result;
16727 PyObject * obj0 = 0 ;
16728 char *kwnames[] = {
16729 (char *) "self", NULL
16730 };
16731
16732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16734 if (SWIG_arg_fail(1)) SWIG_fail;
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16738
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 {
16743 resultobj = SWIG_From_int((int)(result));
16744 }
16745 return resultobj;
16746 fail:
16747 return NULL;
16748 }
16749
16750
16751 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16752 PyObject *resultobj;
16753 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16754 int arg2 ;
16755 PyObject * obj0 = 0 ;
16756 PyObject * obj1 = 0 ;
16757 char *kwnames[] = {
16758 (char *) "self",(char *) "orient", NULL
16759 };
16760
16761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16763 if (SWIG_arg_fail(1)) SWIG_fail;
16764 {
16765 arg2 = (int)(SWIG_As_int(obj1));
16766 if (SWIG_arg_fail(2)) SWIG_fail;
16767 }
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 (arg1)->SetOrientation(arg2);
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 Py_INCREF(Py_None); resultobj = Py_None;
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16783 PyObject *resultobj;
16784 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16785 int arg2 ;
16786 PyObject * obj0 = 0 ;
16787 PyObject * obj1 = 0 ;
16788 char *kwnames[] = {
16789 (char *) "self",(char *) "pos", NULL
16790 };
16791
16792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16794 if (SWIG_arg_fail(1)) SWIG_fail;
16795 {
16796 arg2 = (int)(SWIG_As_int(obj1));
16797 if (SWIG_arg_fail(2)) SWIG_fail;
16798 }
16799 {
16800 PyThreadState* __tstate = wxPyBeginAllowThreads();
16801 (arg1)->SetPosition(arg2);
16802
16803 wxPyEndAllowThreads(__tstate);
16804 if (PyErr_Occurred()) SWIG_fail;
16805 }
16806 Py_INCREF(Py_None); resultobj = Py_None;
16807 return resultobj;
16808 fail:
16809 return NULL;
16810 }
16811
16812
16813 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16814 PyObject *obj;
16815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16816 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16817 Py_INCREF(obj);
16818 return Py_BuildValue((char *)"");
16819 }
16820 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16821 PyObject *resultobj;
16822 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16823 int arg2 = (int) 0 ;
16824 int arg3 = (int) 0 ;
16825 wxScrollWinEvent *result;
16826 PyObject * obj0 = 0 ;
16827 PyObject * obj1 = 0 ;
16828 PyObject * obj2 = 0 ;
16829 char *kwnames[] = {
16830 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16831 };
16832
16833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16834 if (obj0) {
16835 {
16836 arg1 = (wxEventType)(SWIG_As_int(obj0));
16837 if (SWIG_arg_fail(1)) SWIG_fail;
16838 }
16839 }
16840 if (obj1) {
16841 {
16842 arg2 = (int)(SWIG_As_int(obj1));
16843 if (SWIG_arg_fail(2)) SWIG_fail;
16844 }
16845 }
16846 if (obj2) {
16847 {
16848 arg3 = (int)(SWIG_As_int(obj2));
16849 if (SWIG_arg_fail(3)) SWIG_fail;
16850 }
16851 }
16852 {
16853 PyThreadState* __tstate = wxPyBeginAllowThreads();
16854 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16855
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj;
16868 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16869 int result;
16870 PyObject * obj0 = 0 ;
16871 char *kwnames[] = {
16872 (char *) "self", NULL
16873 };
16874
16875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16877 if (SWIG_arg_fail(1)) SWIG_fail;
16878 {
16879 PyThreadState* __tstate = wxPyBeginAllowThreads();
16880 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16881
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 {
16886 resultobj = SWIG_From_int((int)(result));
16887 }
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj;
16896 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16897 int result;
16898 PyObject * obj0 = 0 ;
16899 char *kwnames[] = {
16900 (char *) "self", NULL
16901 };
16902
16903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16905 if (SWIG_arg_fail(1)) SWIG_fail;
16906 {
16907 PyThreadState* __tstate = wxPyBeginAllowThreads();
16908 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16909
16910 wxPyEndAllowThreads(__tstate);
16911 if (PyErr_Occurred()) SWIG_fail;
16912 }
16913 {
16914 resultobj = SWIG_From_int((int)(result));
16915 }
16916 return resultobj;
16917 fail:
16918 return NULL;
16919 }
16920
16921
16922 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16923 PyObject *resultobj;
16924 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16925 int arg2 ;
16926 PyObject * obj0 = 0 ;
16927 PyObject * obj1 = 0 ;
16928 char *kwnames[] = {
16929 (char *) "self",(char *) "orient", NULL
16930 };
16931
16932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16934 if (SWIG_arg_fail(1)) SWIG_fail;
16935 {
16936 arg2 = (int)(SWIG_As_int(obj1));
16937 if (SWIG_arg_fail(2)) SWIG_fail;
16938 }
16939 {
16940 PyThreadState* __tstate = wxPyBeginAllowThreads();
16941 (arg1)->SetOrientation(arg2);
16942
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 Py_INCREF(Py_None); resultobj = Py_None;
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16954 PyObject *resultobj;
16955 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16956 int arg2 ;
16957 PyObject * obj0 = 0 ;
16958 PyObject * obj1 = 0 ;
16959 char *kwnames[] = {
16960 (char *) "self",(char *) "pos", NULL
16961 };
16962
16963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16965 if (SWIG_arg_fail(1)) SWIG_fail;
16966 {
16967 arg2 = (int)(SWIG_As_int(obj1));
16968 if (SWIG_arg_fail(2)) SWIG_fail;
16969 }
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 (arg1)->SetPosition(arg2);
16973
16974 wxPyEndAllowThreads(__tstate);
16975 if (PyErr_Occurred()) SWIG_fail;
16976 }
16977 Py_INCREF(Py_None); resultobj = Py_None;
16978 return resultobj;
16979 fail:
16980 return NULL;
16981 }
16982
16983
16984 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16985 PyObject *obj;
16986 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16987 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16988 Py_INCREF(obj);
16989 return Py_BuildValue((char *)"");
16990 }
16991 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16992 PyObject *resultobj;
16993 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16994 wxMouseEvent *result;
16995 PyObject * obj0 = 0 ;
16996 char *kwnames[] = {
16997 (char *) "mouseType", NULL
16998 };
16999
17000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17001 if (obj0) {
17002 {
17003 arg1 = (wxEventType)(SWIG_As_int(obj0));
17004 if (SWIG_arg_fail(1)) SWIG_fail;
17005 }
17006 }
17007 {
17008 PyThreadState* __tstate = wxPyBeginAllowThreads();
17009 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17010
17011 wxPyEndAllowThreads(__tstate);
17012 if (PyErr_Occurred()) SWIG_fail;
17013 }
17014 {
17015 resultobj = wxPyMake_wxObject(result, 1);
17016 }
17017 return resultobj;
17018 fail:
17019 return NULL;
17020 }
17021
17022
17023 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17024 PyObject *resultobj;
17025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17026 bool result;
17027 PyObject * obj0 = 0 ;
17028 char *kwnames[] = {
17029 (char *) "self", NULL
17030 };
17031
17032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17034 if (SWIG_arg_fail(1)) SWIG_fail;
17035 {
17036 PyThreadState* __tstate = wxPyBeginAllowThreads();
17037 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17038
17039 wxPyEndAllowThreads(__tstate);
17040 if (PyErr_Occurred()) SWIG_fail;
17041 }
17042 {
17043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17044 }
17045 return resultobj;
17046 fail:
17047 return NULL;
17048 }
17049
17050
17051 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj;
17053 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17054 int arg2 = (int) wxMOUSE_BTN_ANY ;
17055 bool result;
17056 PyObject * obj0 = 0 ;
17057 PyObject * obj1 = 0 ;
17058 char *kwnames[] = {
17059 (char *) "self",(char *) "but", NULL
17060 };
17061
17062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17064 if (SWIG_arg_fail(1)) SWIG_fail;
17065 if (obj1) {
17066 {
17067 arg2 = (int)(SWIG_As_int(obj1));
17068 if (SWIG_arg_fail(2)) SWIG_fail;
17069 }
17070 }
17071 {
17072 PyThreadState* __tstate = wxPyBeginAllowThreads();
17073 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17074
17075 wxPyEndAllowThreads(__tstate);
17076 if (PyErr_Occurred()) SWIG_fail;
17077 }
17078 {
17079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17080 }
17081 return resultobj;
17082 fail:
17083 return NULL;
17084 }
17085
17086
17087 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17088 PyObject *resultobj;
17089 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17090 int arg2 = (int) wxMOUSE_BTN_ANY ;
17091 bool result;
17092 PyObject * obj0 = 0 ;
17093 PyObject * obj1 = 0 ;
17094 char *kwnames[] = {
17095 (char *) "self",(char *) "but", NULL
17096 };
17097
17098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17100 if (SWIG_arg_fail(1)) SWIG_fail;
17101 if (obj1) {
17102 {
17103 arg2 = (int)(SWIG_As_int(obj1));
17104 if (SWIG_arg_fail(2)) SWIG_fail;
17105 }
17106 }
17107 {
17108 PyThreadState* __tstate = wxPyBeginAllowThreads();
17109 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17110
17111 wxPyEndAllowThreads(__tstate);
17112 if (PyErr_Occurred()) SWIG_fail;
17113 }
17114 {
17115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17116 }
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj;
17125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17126 int arg2 = (int) wxMOUSE_BTN_ANY ;
17127 bool result;
17128 PyObject * obj0 = 0 ;
17129 PyObject * obj1 = 0 ;
17130 char *kwnames[] = {
17131 (char *) "self",(char *) "but", NULL
17132 };
17133
17134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17136 if (SWIG_arg_fail(1)) SWIG_fail;
17137 if (obj1) {
17138 {
17139 arg2 = (int)(SWIG_As_int(obj1));
17140 if (SWIG_arg_fail(2)) SWIG_fail;
17141 }
17142 }
17143 {
17144 PyThreadState* __tstate = wxPyBeginAllowThreads();
17145 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17146
17147 wxPyEndAllowThreads(__tstate);
17148 if (PyErr_Occurred()) SWIG_fail;
17149 }
17150 {
17151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17152 }
17153 return resultobj;
17154 fail:
17155 return NULL;
17156 }
17157
17158
17159 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17160 PyObject *resultobj;
17161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17162 int arg2 ;
17163 bool result;
17164 PyObject * obj0 = 0 ;
17165 PyObject * obj1 = 0 ;
17166 char *kwnames[] = {
17167 (char *) "self",(char *) "button", NULL
17168 };
17169
17170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17172 if (SWIG_arg_fail(1)) SWIG_fail;
17173 {
17174 arg2 = (int)(SWIG_As_int(obj1));
17175 if (SWIG_arg_fail(2)) SWIG_fail;
17176 }
17177 {
17178 PyThreadState* __tstate = wxPyBeginAllowThreads();
17179 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17180
17181 wxPyEndAllowThreads(__tstate);
17182 if (PyErr_Occurred()) SWIG_fail;
17183 }
17184 {
17185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17186 }
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj;
17195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17196 int arg2 ;
17197 bool result;
17198 PyObject * obj0 = 0 ;
17199 PyObject * obj1 = 0 ;
17200 char *kwnames[] = {
17201 (char *) "self",(char *) "but", NULL
17202 };
17203
17204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17206 if (SWIG_arg_fail(1)) SWIG_fail;
17207 {
17208 arg2 = (int)(SWIG_As_int(obj1));
17209 if (SWIG_arg_fail(2)) SWIG_fail;
17210 }
17211 {
17212 PyThreadState* __tstate = wxPyBeginAllowThreads();
17213 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17214
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 {
17219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17220 }
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj;
17229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17230 int result;
17231 PyObject * obj0 = 0 ;
17232 char *kwnames[] = {
17233 (char *) "self", NULL
17234 };
17235
17236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17238 if (SWIG_arg_fail(1)) SWIG_fail;
17239 {
17240 PyThreadState* __tstate = wxPyBeginAllowThreads();
17241 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17242
17243 wxPyEndAllowThreads(__tstate);
17244 if (PyErr_Occurred()) SWIG_fail;
17245 }
17246 {
17247 resultobj = SWIG_From_int((int)(result));
17248 }
17249 return resultobj;
17250 fail:
17251 return NULL;
17252 }
17253
17254
17255 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17256 PyObject *resultobj;
17257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17258 bool result;
17259 PyObject * obj0 = 0 ;
17260 char *kwnames[] = {
17261 (char *) "self", NULL
17262 };
17263
17264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17266 if (SWIG_arg_fail(1)) SWIG_fail;
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17270
17271 wxPyEndAllowThreads(__tstate);
17272 if (PyErr_Occurred()) SWIG_fail;
17273 }
17274 {
17275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17276 }
17277 return resultobj;
17278 fail:
17279 return NULL;
17280 }
17281
17282
17283 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17284 PyObject *resultobj;
17285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17286 bool result;
17287 PyObject * obj0 = 0 ;
17288 char *kwnames[] = {
17289 (char *) "self", NULL
17290 };
17291
17292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17294 if (SWIG_arg_fail(1)) SWIG_fail;
17295 {
17296 PyThreadState* __tstate = wxPyBeginAllowThreads();
17297 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17298
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 {
17303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17304 }
17305 return resultobj;
17306 fail:
17307 return NULL;
17308 }
17309
17310
17311 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17312 PyObject *resultobj;
17313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17314 bool result;
17315 PyObject * obj0 = 0 ;
17316 char *kwnames[] = {
17317 (char *) "self", NULL
17318 };
17319
17320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17322 if (SWIG_arg_fail(1)) SWIG_fail;
17323 {
17324 PyThreadState* __tstate = wxPyBeginAllowThreads();
17325 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17326
17327 wxPyEndAllowThreads(__tstate);
17328 if (PyErr_Occurred()) SWIG_fail;
17329 }
17330 {
17331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17332 }
17333 return resultobj;
17334 fail:
17335 return NULL;
17336 }
17337
17338
17339 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17340 PyObject *resultobj;
17341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17342 bool result;
17343 PyObject * obj0 = 0 ;
17344 char *kwnames[] = {
17345 (char *) "self", NULL
17346 };
17347
17348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17350 if (SWIG_arg_fail(1)) SWIG_fail;
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17354
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 {
17359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17360 }
17361 return resultobj;
17362 fail:
17363 return NULL;
17364 }
17365
17366
17367 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17368 PyObject *resultobj;
17369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17370 bool result;
17371 PyObject * obj0 = 0 ;
17372 char *kwnames[] = {
17373 (char *) "self", NULL
17374 };
17375
17376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17378 if (SWIG_arg_fail(1)) SWIG_fail;
17379 {
17380 PyThreadState* __tstate = wxPyBeginAllowThreads();
17381 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17382
17383 wxPyEndAllowThreads(__tstate);
17384 if (PyErr_Occurred()) SWIG_fail;
17385 }
17386 {
17387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17388 }
17389 return resultobj;
17390 fail:
17391 return NULL;
17392 }
17393
17394
17395 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17396 PyObject *resultobj;
17397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17398 bool result;
17399 PyObject * obj0 = 0 ;
17400 char *kwnames[] = {
17401 (char *) "self", NULL
17402 };
17403
17404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17406 if (SWIG_arg_fail(1)) SWIG_fail;
17407 {
17408 PyThreadState* __tstate = wxPyBeginAllowThreads();
17409 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17410
17411 wxPyEndAllowThreads(__tstate);
17412 if (PyErr_Occurred()) SWIG_fail;
17413 }
17414 {
17415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17416 }
17417 return resultobj;
17418 fail:
17419 return NULL;
17420 }
17421
17422
17423 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17424 PyObject *resultobj;
17425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17426 bool result;
17427 PyObject * obj0 = 0 ;
17428 char *kwnames[] = {
17429 (char *) "self", NULL
17430 };
17431
17432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17434 if (SWIG_arg_fail(1)) SWIG_fail;
17435 {
17436 PyThreadState* __tstate = wxPyBeginAllowThreads();
17437 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17438
17439 wxPyEndAllowThreads(__tstate);
17440 if (PyErr_Occurred()) SWIG_fail;
17441 }
17442 {
17443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17444 }
17445 return resultobj;
17446 fail:
17447 return NULL;
17448 }
17449
17450
17451 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17452 PyObject *resultobj;
17453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17454 bool result;
17455 PyObject * obj0 = 0 ;
17456 char *kwnames[] = {
17457 (char *) "self", NULL
17458 };
17459
17460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17462 if (SWIG_arg_fail(1)) SWIG_fail;
17463 {
17464 PyThreadState* __tstate = wxPyBeginAllowThreads();
17465 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17466
17467 wxPyEndAllowThreads(__tstate);
17468 if (PyErr_Occurred()) SWIG_fail;
17469 }
17470 {
17471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17472 }
17473 return resultobj;
17474 fail:
17475 return NULL;
17476 }
17477
17478
17479 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17480 PyObject *resultobj;
17481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17482 bool result;
17483 PyObject * obj0 = 0 ;
17484 char *kwnames[] = {
17485 (char *) "self", NULL
17486 };
17487
17488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17490 if (SWIG_arg_fail(1)) SWIG_fail;
17491 {
17492 PyThreadState* __tstate = wxPyBeginAllowThreads();
17493 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17494
17495 wxPyEndAllowThreads(__tstate);
17496 if (PyErr_Occurred()) SWIG_fail;
17497 }
17498 {
17499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17500 }
17501 return resultobj;
17502 fail:
17503 return NULL;
17504 }
17505
17506
17507 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17508 PyObject *resultobj;
17509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17510 bool result;
17511 PyObject * obj0 = 0 ;
17512 char *kwnames[] = {
17513 (char *) "self", NULL
17514 };
17515
17516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17518 if (SWIG_arg_fail(1)) SWIG_fail;
17519 {
17520 PyThreadState* __tstate = wxPyBeginAllowThreads();
17521 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17522
17523 wxPyEndAllowThreads(__tstate);
17524 if (PyErr_Occurred()) SWIG_fail;
17525 }
17526 {
17527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17528 }
17529 return resultobj;
17530 fail:
17531 return NULL;
17532 }
17533
17534
17535 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17536 PyObject *resultobj;
17537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17538 bool result;
17539 PyObject * obj0 = 0 ;
17540 char *kwnames[] = {
17541 (char *) "self", NULL
17542 };
17543
17544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17546 if (SWIG_arg_fail(1)) SWIG_fail;
17547 {
17548 PyThreadState* __tstate = wxPyBeginAllowThreads();
17549 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17550
17551 wxPyEndAllowThreads(__tstate);
17552 if (PyErr_Occurred()) SWIG_fail;
17553 }
17554 {
17555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17556 }
17557 return resultobj;
17558 fail:
17559 return NULL;
17560 }
17561
17562
17563 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17564 PyObject *resultobj;
17565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17566 bool result;
17567 PyObject * obj0 = 0 ;
17568 char *kwnames[] = {
17569 (char *) "self", NULL
17570 };
17571
17572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17574 if (SWIG_arg_fail(1)) SWIG_fail;
17575 {
17576 PyThreadState* __tstate = wxPyBeginAllowThreads();
17577 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17578
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 {
17583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17584 }
17585 return resultobj;
17586 fail:
17587 return NULL;
17588 }
17589
17590
17591 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17592 PyObject *resultobj;
17593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17594 bool result;
17595 PyObject * obj0 = 0 ;
17596 char *kwnames[] = {
17597 (char *) "self", NULL
17598 };
17599
17600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17602 if (SWIG_arg_fail(1)) SWIG_fail;
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17606
17607 wxPyEndAllowThreads(__tstate);
17608 if (PyErr_Occurred()) SWIG_fail;
17609 }
17610 {
17611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17612 }
17613 return resultobj;
17614 fail:
17615 return NULL;
17616 }
17617
17618
17619 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17620 PyObject *resultobj;
17621 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17622 bool result;
17623 PyObject * obj0 = 0 ;
17624 char *kwnames[] = {
17625 (char *) "self", NULL
17626 };
17627
17628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17630 if (SWIG_arg_fail(1)) SWIG_fail;
17631 {
17632 PyThreadState* __tstate = wxPyBeginAllowThreads();
17633 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17634
17635 wxPyEndAllowThreads(__tstate);
17636 if (PyErr_Occurred()) SWIG_fail;
17637 }
17638 {
17639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17640 }
17641 return resultobj;
17642 fail:
17643 return NULL;
17644 }
17645
17646
17647 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17648 PyObject *resultobj;
17649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17650 bool result;
17651 PyObject * obj0 = 0 ;
17652 char *kwnames[] = {
17653 (char *) "self", NULL
17654 };
17655
17656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17658 if (SWIG_arg_fail(1)) SWIG_fail;
17659 {
17660 PyThreadState* __tstate = wxPyBeginAllowThreads();
17661 result = (bool)(arg1)->LeftIsDown();
17662
17663 wxPyEndAllowThreads(__tstate);
17664 if (PyErr_Occurred()) SWIG_fail;
17665 }
17666 {
17667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17668 }
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17676 PyObject *resultobj;
17677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17678 bool result;
17679 PyObject * obj0 = 0 ;
17680 char *kwnames[] = {
17681 (char *) "self", NULL
17682 };
17683
17684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17686 if (SWIG_arg_fail(1)) SWIG_fail;
17687 {
17688 PyThreadState* __tstate = wxPyBeginAllowThreads();
17689 result = (bool)(arg1)->MiddleIsDown();
17690
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 {
17695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17696 }
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17704 PyObject *resultobj;
17705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17706 bool result;
17707 PyObject * obj0 = 0 ;
17708 char *kwnames[] = {
17709 (char *) "self", NULL
17710 };
17711
17712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17714 if (SWIG_arg_fail(1)) SWIG_fail;
17715 {
17716 PyThreadState* __tstate = wxPyBeginAllowThreads();
17717 result = (bool)(arg1)->RightIsDown();
17718
17719 wxPyEndAllowThreads(__tstate);
17720 if (PyErr_Occurred()) SWIG_fail;
17721 }
17722 {
17723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17724 }
17725 return resultobj;
17726 fail:
17727 return NULL;
17728 }
17729
17730
17731 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17732 PyObject *resultobj;
17733 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17734 bool result;
17735 PyObject * obj0 = 0 ;
17736 char *kwnames[] = {
17737 (char *) "self", NULL
17738 };
17739
17740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17742 if (SWIG_arg_fail(1)) SWIG_fail;
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17746
17747 wxPyEndAllowThreads(__tstate);
17748 if (PyErr_Occurred()) SWIG_fail;
17749 }
17750 {
17751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17752 }
17753 return resultobj;
17754 fail:
17755 return NULL;
17756 }
17757
17758
17759 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj;
17761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17762 bool result;
17763 PyObject * obj0 = 0 ;
17764 char *kwnames[] = {
17765 (char *) "self", NULL
17766 };
17767
17768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17770 if (SWIG_arg_fail(1)) SWIG_fail;
17771 {
17772 PyThreadState* __tstate = wxPyBeginAllowThreads();
17773 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17774
17775 wxPyEndAllowThreads(__tstate);
17776 if (PyErr_Occurred()) SWIG_fail;
17777 }
17778 {
17779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17780 }
17781 return resultobj;
17782 fail:
17783 return NULL;
17784 }
17785
17786
17787 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17788 PyObject *resultobj;
17789 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17790 bool result;
17791 PyObject * obj0 = 0 ;
17792 char *kwnames[] = {
17793 (char *) "self", NULL
17794 };
17795
17796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17798 if (SWIG_arg_fail(1)) SWIG_fail;
17799 {
17800 PyThreadState* __tstate = wxPyBeginAllowThreads();
17801 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17802
17803 wxPyEndAllowThreads(__tstate);
17804 if (PyErr_Occurred()) SWIG_fail;
17805 }
17806 {
17807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17808 }
17809 return resultobj;
17810 fail:
17811 return NULL;
17812 }
17813
17814
17815 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17816 PyObject *resultobj;
17817 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17818 bool result;
17819 PyObject * obj0 = 0 ;
17820 char *kwnames[] = {
17821 (char *) "self", NULL
17822 };
17823
17824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17826 if (SWIG_arg_fail(1)) SWIG_fail;
17827 {
17828 PyThreadState* __tstate = wxPyBeginAllowThreads();
17829 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17830
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 {
17835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17836 }
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj;
17845 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17846 wxPoint result;
17847 PyObject * obj0 = 0 ;
17848 char *kwnames[] = {
17849 (char *) "self", NULL
17850 };
17851
17852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17854 if (SWIG_arg_fail(1)) SWIG_fail;
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 result = (arg1)->GetPosition();
17858
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 {
17863 wxPoint * resultptr;
17864 resultptr = new wxPoint((wxPoint &)(result));
17865 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17866 }
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj;
17875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17876 long *arg2 = (long *) 0 ;
17877 long *arg3 = (long *) 0 ;
17878 long temp2 ;
17879 int res2 = 0 ;
17880 long temp3 ;
17881 int res3 = 0 ;
17882 PyObject * obj0 = 0 ;
17883 char *kwnames[] = {
17884 (char *) "self", NULL
17885 };
17886
17887 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17888 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17891 if (SWIG_arg_fail(1)) SWIG_fail;
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 (arg1)->GetPosition(arg2,arg3);
17895
17896 wxPyEndAllowThreads(__tstate);
17897 if (PyErr_Occurred()) SWIG_fail;
17898 }
17899 Py_INCREF(Py_None); resultobj = Py_None;
17900 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17901 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17902 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17903 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj;
17912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17913 wxDC *arg2 = 0 ;
17914 wxPoint result;
17915 PyObject * obj0 = 0 ;
17916 PyObject * obj1 = 0 ;
17917 char *kwnames[] = {
17918 (char *) "self",(char *) "dc", NULL
17919 };
17920
17921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17923 if (SWIG_arg_fail(1)) SWIG_fail;
17924 {
17925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17926 if (SWIG_arg_fail(2)) SWIG_fail;
17927 if (arg2 == NULL) {
17928 SWIG_null_ref("wxDC");
17929 }
17930 if (SWIG_arg_fail(2)) SWIG_fail;
17931 }
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17935
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 {
17940 wxPoint * resultptr;
17941 resultptr = new wxPoint((wxPoint &)(result));
17942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17943 }
17944 return resultobj;
17945 fail:
17946 return NULL;
17947 }
17948
17949
17950 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17951 PyObject *resultobj;
17952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17953 int result;
17954 PyObject * obj0 = 0 ;
17955 char *kwnames[] = {
17956 (char *) "self", NULL
17957 };
17958
17959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17961 if (SWIG_arg_fail(1)) SWIG_fail;
17962 {
17963 PyThreadState* __tstate = wxPyBeginAllowThreads();
17964 result = (int)((wxMouseEvent const *)arg1)->GetX();
17965
17966 wxPyEndAllowThreads(__tstate);
17967 if (PyErr_Occurred()) SWIG_fail;
17968 }
17969 {
17970 resultobj = SWIG_From_int((int)(result));
17971 }
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17979 PyObject *resultobj;
17980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17981 int result;
17982 PyObject * obj0 = 0 ;
17983 char *kwnames[] = {
17984 (char *) "self", NULL
17985 };
17986
17987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17989 if (SWIG_arg_fail(1)) SWIG_fail;
17990 {
17991 PyThreadState* __tstate = wxPyBeginAllowThreads();
17992 result = (int)((wxMouseEvent const *)arg1)->GetY();
17993
17994 wxPyEndAllowThreads(__tstate);
17995 if (PyErr_Occurred()) SWIG_fail;
17996 }
17997 {
17998 resultobj = SWIG_From_int((int)(result));
17999 }
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18007 PyObject *resultobj;
18008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18009 int result;
18010 PyObject * obj0 = 0 ;
18011 char *kwnames[] = {
18012 (char *) "self", NULL
18013 };
18014
18015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18017 if (SWIG_arg_fail(1)) SWIG_fail;
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18021
18022 wxPyEndAllowThreads(__tstate);
18023 if (PyErr_Occurred()) SWIG_fail;
18024 }
18025 {
18026 resultobj = SWIG_From_int((int)(result));
18027 }
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18035 PyObject *resultobj;
18036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18037 int result;
18038 PyObject * obj0 = 0 ;
18039 char *kwnames[] = {
18040 (char *) "self", NULL
18041 };
18042
18043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18045 if (SWIG_arg_fail(1)) SWIG_fail;
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18049
18050 wxPyEndAllowThreads(__tstate);
18051 if (PyErr_Occurred()) SWIG_fail;
18052 }
18053 {
18054 resultobj = SWIG_From_int((int)(result));
18055 }
18056 return resultobj;
18057 fail:
18058 return NULL;
18059 }
18060
18061
18062 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18063 PyObject *resultobj;
18064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18065 int result;
18066 PyObject * obj0 = 0 ;
18067 char *kwnames[] = {
18068 (char *) "self", NULL
18069 };
18070
18071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18073 if (SWIG_arg_fail(1)) SWIG_fail;
18074 {
18075 PyThreadState* __tstate = wxPyBeginAllowThreads();
18076 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18077
18078 wxPyEndAllowThreads(__tstate);
18079 if (PyErr_Occurred()) SWIG_fail;
18080 }
18081 {
18082 resultobj = SWIG_From_int((int)(result));
18083 }
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj;
18092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18093 bool result;
18094 PyObject * obj0 = 0 ;
18095 char *kwnames[] = {
18096 (char *) "self", NULL
18097 };
18098
18099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18101 if (SWIG_arg_fail(1)) SWIG_fail;
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18105
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 {
18110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18111 }
18112 return resultobj;
18113 fail:
18114 return NULL;
18115 }
18116
18117
18118 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18119 PyObject *resultobj;
18120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18121 int arg2 ;
18122 PyObject * obj0 = 0 ;
18123 PyObject * obj1 = 0 ;
18124 char *kwnames[] = {
18125 (char *) "self",(char *) "m_x", NULL
18126 };
18127
18128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18130 if (SWIG_arg_fail(1)) SWIG_fail;
18131 {
18132 arg2 = (int)(SWIG_As_int(obj1));
18133 if (SWIG_arg_fail(2)) SWIG_fail;
18134 }
18135 if (arg1) (arg1)->m_x = arg2;
18136
18137 Py_INCREF(Py_None); resultobj = Py_None;
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18145 PyObject *resultobj;
18146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18147 int result;
18148 PyObject * obj0 = 0 ;
18149 char *kwnames[] = {
18150 (char *) "self", NULL
18151 };
18152
18153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18155 if (SWIG_arg_fail(1)) SWIG_fail;
18156 result = (int) ((arg1)->m_x);
18157
18158 {
18159 resultobj = SWIG_From_int((int)(result));
18160 }
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18168 PyObject *resultobj;
18169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18170 int arg2 ;
18171 PyObject * obj0 = 0 ;
18172 PyObject * obj1 = 0 ;
18173 char *kwnames[] = {
18174 (char *) "self",(char *) "m_y", NULL
18175 };
18176
18177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18179 if (SWIG_arg_fail(1)) SWIG_fail;
18180 {
18181 arg2 = (int)(SWIG_As_int(obj1));
18182 if (SWIG_arg_fail(2)) SWIG_fail;
18183 }
18184 if (arg1) (arg1)->m_y = arg2;
18185
18186 Py_INCREF(Py_None); resultobj = Py_None;
18187 return resultobj;
18188 fail:
18189 return NULL;
18190 }
18191
18192
18193 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18194 PyObject *resultobj;
18195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18196 int result;
18197 PyObject * obj0 = 0 ;
18198 char *kwnames[] = {
18199 (char *) "self", NULL
18200 };
18201
18202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18204 if (SWIG_arg_fail(1)) SWIG_fail;
18205 result = (int) ((arg1)->m_y);
18206
18207 {
18208 resultobj = SWIG_From_int((int)(result));
18209 }
18210 return resultobj;
18211 fail:
18212 return NULL;
18213 }
18214
18215
18216 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18217 PyObject *resultobj;
18218 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18219 bool arg2 ;
18220 PyObject * obj0 = 0 ;
18221 PyObject * obj1 = 0 ;
18222 char *kwnames[] = {
18223 (char *) "self",(char *) "m_leftDown", NULL
18224 };
18225
18226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18228 if (SWIG_arg_fail(1)) SWIG_fail;
18229 {
18230 arg2 = (bool)(SWIG_As_bool(obj1));
18231 if (SWIG_arg_fail(2)) SWIG_fail;
18232 }
18233 if (arg1) (arg1)->m_leftDown = arg2;
18234
18235 Py_INCREF(Py_None); resultobj = Py_None;
18236 return resultobj;
18237 fail:
18238 return NULL;
18239 }
18240
18241
18242 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18243 PyObject *resultobj;
18244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18245 bool result;
18246 PyObject * obj0 = 0 ;
18247 char *kwnames[] = {
18248 (char *) "self", NULL
18249 };
18250
18251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18253 if (SWIG_arg_fail(1)) SWIG_fail;
18254 result = (bool) ((arg1)->m_leftDown);
18255
18256 {
18257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18258 }
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj;
18267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18268 bool arg2 ;
18269 PyObject * obj0 = 0 ;
18270 PyObject * obj1 = 0 ;
18271 char *kwnames[] = {
18272 (char *) "self",(char *) "m_middleDown", NULL
18273 };
18274
18275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18277 if (SWIG_arg_fail(1)) SWIG_fail;
18278 {
18279 arg2 = (bool)(SWIG_As_bool(obj1));
18280 if (SWIG_arg_fail(2)) SWIG_fail;
18281 }
18282 if (arg1) (arg1)->m_middleDown = arg2;
18283
18284 Py_INCREF(Py_None); resultobj = Py_None;
18285 return resultobj;
18286 fail:
18287 return NULL;
18288 }
18289
18290
18291 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18292 PyObject *resultobj;
18293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18294 bool result;
18295 PyObject * obj0 = 0 ;
18296 char *kwnames[] = {
18297 (char *) "self", NULL
18298 };
18299
18300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18302 if (SWIG_arg_fail(1)) SWIG_fail;
18303 result = (bool) ((arg1)->m_middleDown);
18304
18305 {
18306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18307 }
18308 return resultobj;
18309 fail:
18310 return NULL;
18311 }
18312
18313
18314 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18315 PyObject *resultobj;
18316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18317 bool arg2 ;
18318 PyObject * obj0 = 0 ;
18319 PyObject * obj1 = 0 ;
18320 char *kwnames[] = {
18321 (char *) "self",(char *) "m_rightDown", NULL
18322 };
18323
18324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18326 if (SWIG_arg_fail(1)) SWIG_fail;
18327 {
18328 arg2 = (bool)(SWIG_As_bool(obj1));
18329 if (SWIG_arg_fail(2)) SWIG_fail;
18330 }
18331 if (arg1) (arg1)->m_rightDown = arg2;
18332
18333 Py_INCREF(Py_None); resultobj = Py_None;
18334 return resultobj;
18335 fail:
18336 return NULL;
18337 }
18338
18339
18340 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18341 PyObject *resultobj;
18342 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18343 bool result;
18344 PyObject * obj0 = 0 ;
18345 char *kwnames[] = {
18346 (char *) "self", NULL
18347 };
18348
18349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18351 if (SWIG_arg_fail(1)) SWIG_fail;
18352 result = (bool) ((arg1)->m_rightDown);
18353
18354 {
18355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18356 }
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18364 PyObject *resultobj;
18365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18366 bool arg2 ;
18367 PyObject * obj0 = 0 ;
18368 PyObject * obj1 = 0 ;
18369 char *kwnames[] = {
18370 (char *) "self",(char *) "m_controlDown", NULL
18371 };
18372
18373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18375 if (SWIG_arg_fail(1)) SWIG_fail;
18376 {
18377 arg2 = (bool)(SWIG_As_bool(obj1));
18378 if (SWIG_arg_fail(2)) SWIG_fail;
18379 }
18380 if (arg1) (arg1)->m_controlDown = arg2;
18381
18382 Py_INCREF(Py_None); resultobj = Py_None;
18383 return resultobj;
18384 fail:
18385 return NULL;
18386 }
18387
18388
18389 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18390 PyObject *resultobj;
18391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18392 bool result;
18393 PyObject * obj0 = 0 ;
18394 char *kwnames[] = {
18395 (char *) "self", NULL
18396 };
18397
18398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18400 if (SWIG_arg_fail(1)) SWIG_fail;
18401 result = (bool) ((arg1)->m_controlDown);
18402
18403 {
18404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18405 }
18406 return resultobj;
18407 fail:
18408 return NULL;
18409 }
18410
18411
18412 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18413 PyObject *resultobj;
18414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18415 bool arg2 ;
18416 PyObject * obj0 = 0 ;
18417 PyObject * obj1 = 0 ;
18418 char *kwnames[] = {
18419 (char *) "self",(char *) "m_shiftDown", NULL
18420 };
18421
18422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18424 if (SWIG_arg_fail(1)) SWIG_fail;
18425 {
18426 arg2 = (bool)(SWIG_As_bool(obj1));
18427 if (SWIG_arg_fail(2)) SWIG_fail;
18428 }
18429 if (arg1) (arg1)->m_shiftDown = arg2;
18430
18431 Py_INCREF(Py_None); resultobj = Py_None;
18432 return resultobj;
18433 fail:
18434 return NULL;
18435 }
18436
18437
18438 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18439 PyObject *resultobj;
18440 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18441 bool result;
18442 PyObject * obj0 = 0 ;
18443 char *kwnames[] = {
18444 (char *) "self", NULL
18445 };
18446
18447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18449 if (SWIG_arg_fail(1)) SWIG_fail;
18450 result = (bool) ((arg1)->m_shiftDown);
18451
18452 {
18453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18454 }
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18462 PyObject *resultobj;
18463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18464 bool arg2 ;
18465 PyObject * obj0 = 0 ;
18466 PyObject * obj1 = 0 ;
18467 char *kwnames[] = {
18468 (char *) "self",(char *) "m_altDown", NULL
18469 };
18470
18471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18473 if (SWIG_arg_fail(1)) SWIG_fail;
18474 {
18475 arg2 = (bool)(SWIG_As_bool(obj1));
18476 if (SWIG_arg_fail(2)) SWIG_fail;
18477 }
18478 if (arg1) (arg1)->m_altDown = arg2;
18479
18480 Py_INCREF(Py_None); resultobj = Py_None;
18481 return resultobj;
18482 fail:
18483 return NULL;
18484 }
18485
18486
18487 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18488 PyObject *resultobj;
18489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18490 bool result;
18491 PyObject * obj0 = 0 ;
18492 char *kwnames[] = {
18493 (char *) "self", NULL
18494 };
18495
18496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18498 if (SWIG_arg_fail(1)) SWIG_fail;
18499 result = (bool) ((arg1)->m_altDown);
18500
18501 {
18502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18503 }
18504 return resultobj;
18505 fail:
18506 return NULL;
18507 }
18508
18509
18510 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18511 PyObject *resultobj;
18512 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18513 bool arg2 ;
18514 PyObject * obj0 = 0 ;
18515 PyObject * obj1 = 0 ;
18516 char *kwnames[] = {
18517 (char *) "self",(char *) "m_metaDown", NULL
18518 };
18519
18520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18522 if (SWIG_arg_fail(1)) SWIG_fail;
18523 {
18524 arg2 = (bool)(SWIG_As_bool(obj1));
18525 if (SWIG_arg_fail(2)) SWIG_fail;
18526 }
18527 if (arg1) (arg1)->m_metaDown = arg2;
18528
18529 Py_INCREF(Py_None); resultobj = Py_None;
18530 return resultobj;
18531 fail:
18532 return NULL;
18533 }
18534
18535
18536 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18537 PyObject *resultobj;
18538 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18539 bool result;
18540 PyObject * obj0 = 0 ;
18541 char *kwnames[] = {
18542 (char *) "self", NULL
18543 };
18544
18545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18547 if (SWIG_arg_fail(1)) SWIG_fail;
18548 result = (bool) ((arg1)->m_metaDown);
18549
18550 {
18551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18552 }
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj;
18561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18562 int arg2 ;
18563 PyObject * obj0 = 0 ;
18564 PyObject * obj1 = 0 ;
18565 char *kwnames[] = {
18566 (char *) "self",(char *) "m_wheelRotation", NULL
18567 };
18568
18569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18571 if (SWIG_arg_fail(1)) SWIG_fail;
18572 {
18573 arg2 = (int)(SWIG_As_int(obj1));
18574 if (SWIG_arg_fail(2)) SWIG_fail;
18575 }
18576 if (arg1) (arg1)->m_wheelRotation = arg2;
18577
18578 Py_INCREF(Py_None); resultobj = Py_None;
18579 return resultobj;
18580 fail:
18581 return NULL;
18582 }
18583
18584
18585 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18586 PyObject *resultobj;
18587 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18588 int result;
18589 PyObject * obj0 = 0 ;
18590 char *kwnames[] = {
18591 (char *) "self", NULL
18592 };
18593
18594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18596 if (SWIG_arg_fail(1)) SWIG_fail;
18597 result = (int) ((arg1)->m_wheelRotation);
18598
18599 {
18600 resultobj = SWIG_From_int((int)(result));
18601 }
18602 return resultobj;
18603 fail:
18604 return NULL;
18605 }
18606
18607
18608 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj;
18610 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18611 int arg2 ;
18612 PyObject * obj0 = 0 ;
18613 PyObject * obj1 = 0 ;
18614 char *kwnames[] = {
18615 (char *) "self",(char *) "m_wheelDelta", NULL
18616 };
18617
18618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18620 if (SWIG_arg_fail(1)) SWIG_fail;
18621 {
18622 arg2 = (int)(SWIG_As_int(obj1));
18623 if (SWIG_arg_fail(2)) SWIG_fail;
18624 }
18625 if (arg1) (arg1)->m_wheelDelta = arg2;
18626
18627 Py_INCREF(Py_None); resultobj = Py_None;
18628 return resultobj;
18629 fail:
18630 return NULL;
18631 }
18632
18633
18634 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18635 PyObject *resultobj;
18636 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18637 int result;
18638 PyObject * obj0 = 0 ;
18639 char *kwnames[] = {
18640 (char *) "self", NULL
18641 };
18642
18643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18645 if (SWIG_arg_fail(1)) SWIG_fail;
18646 result = (int) ((arg1)->m_wheelDelta);
18647
18648 {
18649 resultobj = SWIG_From_int((int)(result));
18650 }
18651 return resultobj;
18652 fail:
18653 return NULL;
18654 }
18655
18656
18657 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18658 PyObject *resultobj;
18659 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18660 int arg2 ;
18661 PyObject * obj0 = 0 ;
18662 PyObject * obj1 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self",(char *) "m_linesPerAction", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 {
18671 arg2 = (int)(SWIG_As_int(obj1));
18672 if (SWIG_arg_fail(2)) SWIG_fail;
18673 }
18674 if (arg1) (arg1)->m_linesPerAction = arg2;
18675
18676 Py_INCREF(Py_None); resultobj = Py_None;
18677 return resultobj;
18678 fail:
18679 return NULL;
18680 }
18681
18682
18683 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18684 PyObject *resultobj;
18685 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18686 int result;
18687 PyObject * obj0 = 0 ;
18688 char *kwnames[] = {
18689 (char *) "self", NULL
18690 };
18691
18692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18694 if (SWIG_arg_fail(1)) SWIG_fail;
18695 result = (int) ((arg1)->m_linesPerAction);
18696
18697 {
18698 resultobj = SWIG_From_int((int)(result));
18699 }
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18707 PyObject *obj;
18708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18709 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18710 Py_INCREF(obj);
18711 return Py_BuildValue((char *)"");
18712 }
18713 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18714 PyObject *resultobj;
18715 int arg1 = (int) 0 ;
18716 int arg2 = (int) 0 ;
18717 wxSetCursorEvent *result;
18718 PyObject * obj0 = 0 ;
18719 PyObject * obj1 = 0 ;
18720 char *kwnames[] = {
18721 (char *) "x",(char *) "y", NULL
18722 };
18723
18724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18725 if (obj0) {
18726 {
18727 arg1 = (int)(SWIG_As_int(obj0));
18728 if (SWIG_arg_fail(1)) SWIG_fail;
18729 }
18730 }
18731 if (obj1) {
18732 {
18733 arg2 = (int)(SWIG_As_int(obj1));
18734 if (SWIG_arg_fail(2)) SWIG_fail;
18735 }
18736 }
18737 {
18738 PyThreadState* __tstate = wxPyBeginAllowThreads();
18739 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18740
18741 wxPyEndAllowThreads(__tstate);
18742 if (PyErr_Occurred()) SWIG_fail;
18743 }
18744 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18745 return resultobj;
18746 fail:
18747 return NULL;
18748 }
18749
18750
18751 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18752 PyObject *resultobj;
18753 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18754 int result;
18755 PyObject * obj0 = 0 ;
18756 char *kwnames[] = {
18757 (char *) "self", NULL
18758 };
18759
18760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18762 if (SWIG_arg_fail(1)) SWIG_fail;
18763 {
18764 PyThreadState* __tstate = wxPyBeginAllowThreads();
18765 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18766
18767 wxPyEndAllowThreads(__tstate);
18768 if (PyErr_Occurred()) SWIG_fail;
18769 }
18770 {
18771 resultobj = SWIG_From_int((int)(result));
18772 }
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj;
18781 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18782 int result;
18783 PyObject * obj0 = 0 ;
18784 char *kwnames[] = {
18785 (char *) "self", NULL
18786 };
18787
18788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18790 if (SWIG_arg_fail(1)) SWIG_fail;
18791 {
18792 PyThreadState* __tstate = wxPyBeginAllowThreads();
18793 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18794
18795 wxPyEndAllowThreads(__tstate);
18796 if (PyErr_Occurred()) SWIG_fail;
18797 }
18798 {
18799 resultobj = SWIG_From_int((int)(result));
18800 }
18801 return resultobj;
18802 fail:
18803 return NULL;
18804 }
18805
18806
18807 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18808 PyObject *resultobj;
18809 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18810 wxCursor *arg2 = 0 ;
18811 PyObject * obj0 = 0 ;
18812 PyObject * obj1 = 0 ;
18813 char *kwnames[] = {
18814 (char *) "self",(char *) "cursor", NULL
18815 };
18816
18817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18819 if (SWIG_arg_fail(1)) SWIG_fail;
18820 {
18821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18822 if (SWIG_arg_fail(2)) SWIG_fail;
18823 if (arg2 == NULL) {
18824 SWIG_null_ref("wxCursor");
18825 }
18826 if (SWIG_arg_fail(2)) SWIG_fail;
18827 }
18828 {
18829 PyThreadState* __tstate = wxPyBeginAllowThreads();
18830 (arg1)->SetCursor((wxCursor const &)*arg2);
18831
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 Py_INCREF(Py_None); resultobj = Py_None;
18836 return resultobj;
18837 fail:
18838 return NULL;
18839 }
18840
18841
18842 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj;
18844 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18845 wxCursor *result;
18846 PyObject * obj0 = 0 ;
18847 char *kwnames[] = {
18848 (char *) "self", NULL
18849 };
18850
18851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18853 if (SWIG_arg_fail(1)) SWIG_fail;
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 {
18857 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18858 result = (wxCursor *) &_result_ref;
18859 }
18860
18861 wxPyEndAllowThreads(__tstate);
18862 if (PyErr_Occurred()) SWIG_fail;
18863 }
18864 {
18865 wxCursor* resultptr = new wxCursor(*result);
18866 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18867 }
18868 return resultobj;
18869 fail:
18870 return NULL;
18871 }
18872
18873
18874 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18875 PyObject *resultobj;
18876 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18877 bool result;
18878 PyObject * obj0 = 0 ;
18879 char *kwnames[] = {
18880 (char *) "self", NULL
18881 };
18882
18883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18885 if (SWIG_arg_fail(1)) SWIG_fail;
18886 {
18887 PyThreadState* __tstate = wxPyBeginAllowThreads();
18888 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18889
18890 wxPyEndAllowThreads(__tstate);
18891 if (PyErr_Occurred()) SWIG_fail;
18892 }
18893 {
18894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18895 }
18896 return resultobj;
18897 fail:
18898 return NULL;
18899 }
18900
18901
18902 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18903 PyObject *obj;
18904 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18905 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18906 Py_INCREF(obj);
18907 return Py_BuildValue((char *)"");
18908 }
18909 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18910 PyObject *resultobj;
18911 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18912 wxKeyEvent *result;
18913 PyObject * obj0 = 0 ;
18914 char *kwnames[] = {
18915 (char *) "eventType", NULL
18916 };
18917
18918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18919 if (obj0) {
18920 {
18921 arg1 = (wxEventType)(SWIG_As_int(obj0));
18922 if (SWIG_arg_fail(1)) SWIG_fail;
18923 }
18924 }
18925 {
18926 PyThreadState* __tstate = wxPyBeginAllowThreads();
18927 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18928
18929 wxPyEndAllowThreads(__tstate);
18930 if (PyErr_Occurred()) SWIG_fail;
18931 }
18932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18933 return resultobj;
18934 fail:
18935 return NULL;
18936 }
18937
18938
18939 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18940 PyObject *resultobj;
18941 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18942 bool result;
18943 PyObject * obj0 = 0 ;
18944 char *kwnames[] = {
18945 (char *) "self", NULL
18946 };
18947
18948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18950 if (SWIG_arg_fail(1)) SWIG_fail;
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18954
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 {
18959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18960 }
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18968 PyObject *resultobj;
18969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18970 bool result;
18971 PyObject * obj0 = 0 ;
18972 char *kwnames[] = {
18973 (char *) "self", NULL
18974 };
18975
18976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18978 if (SWIG_arg_fail(1)) SWIG_fail;
18979 {
18980 PyThreadState* __tstate = wxPyBeginAllowThreads();
18981 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18982
18983 wxPyEndAllowThreads(__tstate);
18984 if (PyErr_Occurred()) SWIG_fail;
18985 }
18986 {
18987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18988 }
18989 return resultobj;
18990 fail:
18991 return NULL;
18992 }
18993
18994
18995 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18996 PyObject *resultobj;
18997 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18998 bool result;
18999 PyObject * obj0 = 0 ;
19000 char *kwnames[] = {
19001 (char *) "self", NULL
19002 };
19003
19004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19006 if (SWIG_arg_fail(1)) SWIG_fail;
19007 {
19008 PyThreadState* __tstate = wxPyBeginAllowThreads();
19009 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19010
19011 wxPyEndAllowThreads(__tstate);
19012 if (PyErr_Occurred()) SWIG_fail;
19013 }
19014 {
19015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19016 }
19017 return resultobj;
19018 fail:
19019 return NULL;
19020 }
19021
19022
19023 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19024 PyObject *resultobj;
19025 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19026 bool result;
19027 PyObject * obj0 = 0 ;
19028 char *kwnames[] = {
19029 (char *) "self", NULL
19030 };
19031
19032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19034 if (SWIG_arg_fail(1)) SWIG_fail;
19035 {
19036 PyThreadState* __tstate = wxPyBeginAllowThreads();
19037 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19038
19039 wxPyEndAllowThreads(__tstate);
19040 if (PyErr_Occurred()) SWIG_fail;
19041 }
19042 {
19043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19044 }
19045 return resultobj;
19046 fail:
19047 return NULL;
19048 }
19049
19050
19051 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19052 PyObject *resultobj;
19053 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19054 bool result;
19055 PyObject * obj0 = 0 ;
19056 char *kwnames[] = {
19057 (char *) "self", NULL
19058 };
19059
19060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19062 if (SWIG_arg_fail(1)) SWIG_fail;
19063 {
19064 PyThreadState* __tstate = wxPyBeginAllowThreads();
19065 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19066
19067 wxPyEndAllowThreads(__tstate);
19068 if (PyErr_Occurred()) SWIG_fail;
19069 }
19070 {
19071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19072 }
19073 return resultobj;
19074 fail:
19075 return NULL;
19076 }
19077
19078
19079 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19080 PyObject *resultobj;
19081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19082 bool result;
19083 PyObject * obj0 = 0 ;
19084 char *kwnames[] = {
19085 (char *) "self", NULL
19086 };
19087
19088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19090 if (SWIG_arg_fail(1)) SWIG_fail;
19091 {
19092 PyThreadState* __tstate = wxPyBeginAllowThreads();
19093 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19094
19095 wxPyEndAllowThreads(__tstate);
19096 if (PyErr_Occurred()) SWIG_fail;
19097 }
19098 {
19099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19100 }
19101 return resultobj;
19102 fail:
19103 return NULL;
19104 }
19105
19106
19107 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19108 PyObject *resultobj;
19109 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19110 int result;
19111 PyObject * obj0 = 0 ;
19112 char *kwnames[] = {
19113 (char *) "self", NULL
19114 };
19115
19116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19118 if (SWIG_arg_fail(1)) SWIG_fail;
19119 {
19120 PyThreadState* __tstate = wxPyBeginAllowThreads();
19121 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19122
19123 wxPyEndAllowThreads(__tstate);
19124 if (PyErr_Occurred()) SWIG_fail;
19125 }
19126 {
19127 resultobj = SWIG_From_int((int)(result));
19128 }
19129 return resultobj;
19130 fail:
19131 return NULL;
19132 }
19133
19134
19135 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19136 PyObject *resultobj;
19137 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19138 int result;
19139 PyObject * obj0 = 0 ;
19140 char *kwnames[] = {
19141 (char *) "self", NULL
19142 };
19143
19144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19146 if (SWIG_arg_fail(1)) SWIG_fail;
19147 {
19148 PyThreadState* __tstate = wxPyBeginAllowThreads();
19149 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19150
19151 wxPyEndAllowThreads(__tstate);
19152 if (PyErr_Occurred()) SWIG_fail;
19153 }
19154 {
19155 resultobj = SWIG_From_int((int)(result));
19156 }
19157 return resultobj;
19158 fail:
19159 return NULL;
19160 }
19161
19162
19163 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19164 PyObject *resultobj;
19165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19166 unsigned int result;
19167 PyObject * obj0 = 0 ;
19168 char *kwnames[] = {
19169 (char *) "self", NULL
19170 };
19171
19172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19174 if (SWIG_arg_fail(1)) SWIG_fail;
19175 {
19176 PyThreadState* __tstate = wxPyBeginAllowThreads();
19177 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19178
19179 wxPyEndAllowThreads(__tstate);
19180 if (PyErr_Occurred()) SWIG_fail;
19181 }
19182 {
19183 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19184 }
19185 return resultobj;
19186 fail:
19187 return NULL;
19188 }
19189
19190
19191 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19192 PyObject *resultobj;
19193 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19194 unsigned int result;
19195 PyObject * obj0 = 0 ;
19196 char *kwnames[] = {
19197 (char *) "self", NULL
19198 };
19199
19200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19202 if (SWIG_arg_fail(1)) SWIG_fail;
19203 {
19204 PyThreadState* __tstate = wxPyBeginAllowThreads();
19205 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19206
19207 wxPyEndAllowThreads(__tstate);
19208 if (PyErr_Occurred()) SWIG_fail;
19209 }
19210 {
19211 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19212 }
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19220 PyObject *resultobj;
19221 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19222 wxPoint result;
19223 PyObject * obj0 = 0 ;
19224 char *kwnames[] = {
19225 (char *) "self", NULL
19226 };
19227
19228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 {
19232 PyThreadState* __tstate = wxPyBeginAllowThreads();
19233 result = (arg1)->GetPosition();
19234
19235 wxPyEndAllowThreads(__tstate);
19236 if (PyErr_Occurred()) SWIG_fail;
19237 }
19238 {
19239 wxPoint * resultptr;
19240 resultptr = new wxPoint((wxPoint &)(result));
19241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19242 }
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19250 PyObject *resultobj;
19251 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19252 long *arg2 = (long *) 0 ;
19253 long *arg3 = (long *) 0 ;
19254 long temp2 ;
19255 int res2 = 0 ;
19256 long temp3 ;
19257 int res3 = 0 ;
19258 PyObject * obj0 = 0 ;
19259 char *kwnames[] = {
19260 (char *) "self", NULL
19261 };
19262
19263 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19264 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19267 if (SWIG_arg_fail(1)) SWIG_fail;
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 (arg1)->GetPosition(arg2,arg3);
19271
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 Py_INCREF(Py_None); resultobj = Py_None;
19276 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19277 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19278 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19279 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19287 PyObject *resultobj;
19288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19289 int result;
19290 PyObject * obj0 = 0 ;
19291 char *kwnames[] = {
19292 (char *) "self", NULL
19293 };
19294
19295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19297 if (SWIG_arg_fail(1)) SWIG_fail;
19298 {
19299 PyThreadState* __tstate = wxPyBeginAllowThreads();
19300 result = (int)((wxKeyEvent const *)arg1)->GetX();
19301
19302 wxPyEndAllowThreads(__tstate);
19303 if (PyErr_Occurred()) SWIG_fail;
19304 }
19305 {
19306 resultobj = SWIG_From_int((int)(result));
19307 }
19308 return resultobj;
19309 fail:
19310 return NULL;
19311 }
19312
19313
19314 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19315 PyObject *resultobj;
19316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19317 int result;
19318 PyObject * obj0 = 0 ;
19319 char *kwnames[] = {
19320 (char *) "self", NULL
19321 };
19322
19323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19325 if (SWIG_arg_fail(1)) SWIG_fail;
19326 {
19327 PyThreadState* __tstate = wxPyBeginAllowThreads();
19328 result = (int)((wxKeyEvent const *)arg1)->GetY();
19329
19330 wxPyEndAllowThreads(__tstate);
19331 if (PyErr_Occurred()) SWIG_fail;
19332 }
19333 {
19334 resultobj = SWIG_From_int((int)(result));
19335 }
19336 return resultobj;
19337 fail:
19338 return NULL;
19339 }
19340
19341
19342 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19343 PyObject *resultobj;
19344 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19345 int arg2 ;
19346 PyObject * obj0 = 0 ;
19347 PyObject * obj1 = 0 ;
19348 char *kwnames[] = {
19349 (char *) "self",(char *) "m_x", NULL
19350 };
19351
19352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19354 if (SWIG_arg_fail(1)) SWIG_fail;
19355 {
19356 arg2 = (int)(SWIG_As_int(obj1));
19357 if (SWIG_arg_fail(2)) SWIG_fail;
19358 }
19359 if (arg1) (arg1)->m_x = arg2;
19360
19361 Py_INCREF(Py_None); resultobj = Py_None;
19362 return resultobj;
19363 fail:
19364 return NULL;
19365 }
19366
19367
19368 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19369 PyObject *resultobj;
19370 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19371 int result;
19372 PyObject * obj0 = 0 ;
19373 char *kwnames[] = {
19374 (char *) "self", NULL
19375 };
19376
19377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19379 if (SWIG_arg_fail(1)) SWIG_fail;
19380 result = (int) ((arg1)->m_x);
19381
19382 {
19383 resultobj = SWIG_From_int((int)(result));
19384 }
19385 return resultobj;
19386 fail:
19387 return NULL;
19388 }
19389
19390
19391 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19392 PyObject *resultobj;
19393 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19394 int arg2 ;
19395 PyObject * obj0 = 0 ;
19396 PyObject * obj1 = 0 ;
19397 char *kwnames[] = {
19398 (char *) "self",(char *) "m_y", NULL
19399 };
19400
19401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19403 if (SWIG_arg_fail(1)) SWIG_fail;
19404 {
19405 arg2 = (int)(SWIG_As_int(obj1));
19406 if (SWIG_arg_fail(2)) SWIG_fail;
19407 }
19408 if (arg1) (arg1)->m_y = arg2;
19409
19410 Py_INCREF(Py_None); resultobj = Py_None;
19411 return resultobj;
19412 fail:
19413 return NULL;
19414 }
19415
19416
19417 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19418 PyObject *resultobj;
19419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19420 int result;
19421 PyObject * obj0 = 0 ;
19422 char *kwnames[] = {
19423 (char *) "self", NULL
19424 };
19425
19426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19428 if (SWIG_arg_fail(1)) SWIG_fail;
19429 result = (int) ((arg1)->m_y);
19430
19431 {
19432 resultobj = SWIG_From_int((int)(result));
19433 }
19434 return resultobj;
19435 fail:
19436 return NULL;
19437 }
19438
19439
19440 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19441 PyObject *resultobj;
19442 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19443 long arg2 ;
19444 PyObject * obj0 = 0 ;
19445 PyObject * obj1 = 0 ;
19446 char *kwnames[] = {
19447 (char *) "self",(char *) "m_keyCode", NULL
19448 };
19449
19450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19452 if (SWIG_arg_fail(1)) SWIG_fail;
19453 {
19454 arg2 = (long)(SWIG_As_long(obj1));
19455 if (SWIG_arg_fail(2)) SWIG_fail;
19456 }
19457 if (arg1) (arg1)->m_keyCode = arg2;
19458
19459 Py_INCREF(Py_None); resultobj = Py_None;
19460 return resultobj;
19461 fail:
19462 return NULL;
19463 }
19464
19465
19466 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj;
19468 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19469 long result;
19470 PyObject * obj0 = 0 ;
19471 char *kwnames[] = {
19472 (char *) "self", NULL
19473 };
19474
19475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19477 if (SWIG_arg_fail(1)) SWIG_fail;
19478 result = (long) ((arg1)->m_keyCode);
19479
19480 {
19481 resultobj = SWIG_From_long((long)(result));
19482 }
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19490 PyObject *resultobj;
19491 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19492 bool arg2 ;
19493 PyObject * obj0 = 0 ;
19494 PyObject * obj1 = 0 ;
19495 char *kwnames[] = {
19496 (char *) "self",(char *) "m_controlDown", NULL
19497 };
19498
19499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19501 if (SWIG_arg_fail(1)) SWIG_fail;
19502 {
19503 arg2 = (bool)(SWIG_As_bool(obj1));
19504 if (SWIG_arg_fail(2)) SWIG_fail;
19505 }
19506 if (arg1) (arg1)->m_controlDown = arg2;
19507
19508 Py_INCREF(Py_None); resultobj = Py_None;
19509 return resultobj;
19510 fail:
19511 return NULL;
19512 }
19513
19514
19515 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19516 PyObject *resultobj;
19517 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19518 bool result;
19519 PyObject * obj0 = 0 ;
19520 char *kwnames[] = {
19521 (char *) "self", NULL
19522 };
19523
19524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19526 if (SWIG_arg_fail(1)) SWIG_fail;
19527 result = (bool) ((arg1)->m_controlDown);
19528
19529 {
19530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19531 }
19532 return resultobj;
19533 fail:
19534 return NULL;
19535 }
19536
19537
19538 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19539 PyObject *resultobj;
19540 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19541 bool arg2 ;
19542 PyObject * obj0 = 0 ;
19543 PyObject * obj1 = 0 ;
19544 char *kwnames[] = {
19545 (char *) "self",(char *) "m_shiftDown", NULL
19546 };
19547
19548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19550 if (SWIG_arg_fail(1)) SWIG_fail;
19551 {
19552 arg2 = (bool)(SWIG_As_bool(obj1));
19553 if (SWIG_arg_fail(2)) SWIG_fail;
19554 }
19555 if (arg1) (arg1)->m_shiftDown = arg2;
19556
19557 Py_INCREF(Py_None); resultobj = Py_None;
19558 return resultobj;
19559 fail:
19560 return NULL;
19561 }
19562
19563
19564 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19565 PyObject *resultobj;
19566 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19567 bool result;
19568 PyObject * obj0 = 0 ;
19569 char *kwnames[] = {
19570 (char *) "self", NULL
19571 };
19572
19573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19575 if (SWIG_arg_fail(1)) SWIG_fail;
19576 result = (bool) ((arg1)->m_shiftDown);
19577
19578 {
19579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19580 }
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19588 PyObject *resultobj;
19589 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19590 bool arg2 ;
19591 PyObject * obj0 = 0 ;
19592 PyObject * obj1 = 0 ;
19593 char *kwnames[] = {
19594 (char *) "self",(char *) "m_altDown", NULL
19595 };
19596
19597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19599 if (SWIG_arg_fail(1)) SWIG_fail;
19600 {
19601 arg2 = (bool)(SWIG_As_bool(obj1));
19602 if (SWIG_arg_fail(2)) SWIG_fail;
19603 }
19604 if (arg1) (arg1)->m_altDown = arg2;
19605
19606 Py_INCREF(Py_None); resultobj = Py_None;
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19614 PyObject *resultobj;
19615 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19616 bool result;
19617 PyObject * obj0 = 0 ;
19618 char *kwnames[] = {
19619 (char *) "self", NULL
19620 };
19621
19622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19624 if (SWIG_arg_fail(1)) SWIG_fail;
19625 result = (bool) ((arg1)->m_altDown);
19626
19627 {
19628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19629 }
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19637 PyObject *resultobj;
19638 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19639 bool arg2 ;
19640 PyObject * obj0 = 0 ;
19641 PyObject * obj1 = 0 ;
19642 char *kwnames[] = {
19643 (char *) "self",(char *) "m_metaDown", NULL
19644 };
19645
19646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19648 if (SWIG_arg_fail(1)) SWIG_fail;
19649 {
19650 arg2 = (bool)(SWIG_As_bool(obj1));
19651 if (SWIG_arg_fail(2)) SWIG_fail;
19652 }
19653 if (arg1) (arg1)->m_metaDown = arg2;
19654
19655 Py_INCREF(Py_None); resultobj = Py_None;
19656 return resultobj;
19657 fail:
19658 return NULL;
19659 }
19660
19661
19662 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj;
19664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19665 bool result;
19666 PyObject * obj0 = 0 ;
19667 char *kwnames[] = {
19668 (char *) "self", NULL
19669 };
19670
19671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19673 if (SWIG_arg_fail(1)) SWIG_fail;
19674 result = (bool) ((arg1)->m_metaDown);
19675
19676 {
19677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19678 }
19679 return resultobj;
19680 fail:
19681 return NULL;
19682 }
19683
19684
19685 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19686 PyObject *resultobj;
19687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19688 bool arg2 ;
19689 PyObject * obj0 = 0 ;
19690 PyObject * obj1 = 0 ;
19691 char *kwnames[] = {
19692 (char *) "self",(char *) "m_scanCode", NULL
19693 };
19694
19695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19697 if (SWIG_arg_fail(1)) SWIG_fail;
19698 {
19699 arg2 = (bool)(SWIG_As_bool(obj1));
19700 if (SWIG_arg_fail(2)) SWIG_fail;
19701 }
19702 if (arg1) (arg1)->m_scanCode = arg2;
19703
19704 Py_INCREF(Py_None); resultobj = Py_None;
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19712 PyObject *resultobj;
19713 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19714 bool result;
19715 PyObject * obj0 = 0 ;
19716 char *kwnames[] = {
19717 (char *) "self", NULL
19718 };
19719
19720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19722 if (SWIG_arg_fail(1)) SWIG_fail;
19723 result = (bool) ((arg1)->m_scanCode);
19724
19725 {
19726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19727 }
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19735 PyObject *resultobj;
19736 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19737 unsigned int arg2 ;
19738 PyObject * obj0 = 0 ;
19739 PyObject * obj1 = 0 ;
19740 char *kwnames[] = {
19741 (char *) "self",(char *) "m_rawCode", NULL
19742 };
19743
19744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19746 if (SWIG_arg_fail(1)) SWIG_fail;
19747 {
19748 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19749 if (SWIG_arg_fail(2)) SWIG_fail;
19750 }
19751 if (arg1) (arg1)->m_rawCode = arg2;
19752
19753 Py_INCREF(Py_None); resultobj = Py_None;
19754 return resultobj;
19755 fail:
19756 return NULL;
19757 }
19758
19759
19760 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19761 PyObject *resultobj;
19762 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19763 unsigned int result;
19764 PyObject * obj0 = 0 ;
19765 char *kwnames[] = {
19766 (char *) "self", NULL
19767 };
19768
19769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19771 if (SWIG_arg_fail(1)) SWIG_fail;
19772 result = (unsigned int) ((arg1)->m_rawCode);
19773
19774 {
19775 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19776 }
19777 return resultobj;
19778 fail:
19779 return NULL;
19780 }
19781
19782
19783 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj;
19785 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19786 unsigned int arg2 ;
19787 PyObject * obj0 = 0 ;
19788 PyObject * obj1 = 0 ;
19789 char *kwnames[] = {
19790 (char *) "self",(char *) "m_rawFlags", NULL
19791 };
19792
19793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19795 if (SWIG_arg_fail(1)) SWIG_fail;
19796 {
19797 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19798 if (SWIG_arg_fail(2)) SWIG_fail;
19799 }
19800 if (arg1) (arg1)->m_rawFlags = arg2;
19801
19802 Py_INCREF(Py_None); resultobj = Py_None;
19803 return resultobj;
19804 fail:
19805 return NULL;
19806 }
19807
19808
19809 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19810 PyObject *resultobj;
19811 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19812 unsigned int result;
19813 PyObject * obj0 = 0 ;
19814 char *kwnames[] = {
19815 (char *) "self", NULL
19816 };
19817
19818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19820 if (SWIG_arg_fail(1)) SWIG_fail;
19821 result = (unsigned int) ((arg1)->m_rawFlags);
19822
19823 {
19824 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19825 }
19826 return resultobj;
19827 fail:
19828 return NULL;
19829 }
19830
19831
19832 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19833 PyObject *obj;
19834 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19835 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19836 Py_INCREF(obj);
19837 return Py_BuildValue((char *)"");
19838 }
19839 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19840 PyObject *resultobj;
19841 wxSize const &arg1_defvalue = wxDefaultSize ;
19842 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19843 int arg2 = (int) 0 ;
19844 wxSizeEvent *result;
19845 wxSize temp1 ;
19846 PyObject * obj0 = 0 ;
19847 PyObject * obj1 = 0 ;
19848 char *kwnames[] = {
19849 (char *) "sz",(char *) "winid", NULL
19850 };
19851
19852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19853 if (obj0) {
19854 {
19855 arg1 = &temp1;
19856 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19857 }
19858 }
19859 if (obj1) {
19860 {
19861 arg2 = (int)(SWIG_As_int(obj1));
19862 if (SWIG_arg_fail(2)) SWIG_fail;
19863 }
19864 }
19865 {
19866 PyThreadState* __tstate = wxPyBeginAllowThreads();
19867 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19868
19869 wxPyEndAllowThreads(__tstate);
19870 if (PyErr_Occurred()) SWIG_fail;
19871 }
19872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19873 return resultobj;
19874 fail:
19875 return NULL;
19876 }
19877
19878
19879 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19880 PyObject *resultobj;
19881 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19882 wxSize result;
19883 PyObject * obj0 = 0 ;
19884 char *kwnames[] = {
19885 (char *) "self", NULL
19886 };
19887
19888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19890 if (SWIG_arg_fail(1)) SWIG_fail;
19891 {
19892 PyThreadState* __tstate = wxPyBeginAllowThreads();
19893 result = ((wxSizeEvent const *)arg1)->GetSize();
19894
19895 wxPyEndAllowThreads(__tstate);
19896 if (PyErr_Occurred()) SWIG_fail;
19897 }
19898 {
19899 wxSize * resultptr;
19900 resultptr = new wxSize((wxSize &)(result));
19901 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19902 }
19903 return resultobj;
19904 fail:
19905 return NULL;
19906 }
19907
19908
19909 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19910 PyObject *resultobj;
19911 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19912 wxRect result;
19913 PyObject * obj0 = 0 ;
19914 char *kwnames[] = {
19915 (char *) "self", NULL
19916 };
19917
19918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19920 if (SWIG_arg_fail(1)) SWIG_fail;
19921 {
19922 PyThreadState* __tstate = wxPyBeginAllowThreads();
19923 result = ((wxSizeEvent const *)arg1)->GetRect();
19924
19925 wxPyEndAllowThreads(__tstate);
19926 if (PyErr_Occurred()) SWIG_fail;
19927 }
19928 {
19929 wxRect * resultptr;
19930 resultptr = new wxRect((wxRect &)(result));
19931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19932 }
19933 return resultobj;
19934 fail:
19935 return NULL;
19936 }
19937
19938
19939 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19940 PyObject *resultobj;
19941 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19942 wxRect arg2 ;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 char *kwnames[] = {
19946 (char *) "self",(char *) "rect", NULL
19947 };
19948
19949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19951 if (SWIG_arg_fail(1)) SWIG_fail;
19952 {
19953 wxRect * argp;
19954 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19955 if (SWIG_arg_fail(2)) SWIG_fail;
19956 if (argp == NULL) {
19957 SWIG_null_ref("wxRect");
19958 }
19959 if (SWIG_arg_fail(2)) SWIG_fail;
19960 arg2 = *argp;
19961 }
19962 {
19963 PyThreadState* __tstate = wxPyBeginAllowThreads();
19964 (arg1)->SetRect(arg2);
19965
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 Py_INCREF(Py_None); resultobj = Py_None;
19970 return resultobj;
19971 fail:
19972 return NULL;
19973 }
19974
19975
19976 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19977 PyObject *resultobj;
19978 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19979 wxSize arg2 ;
19980 PyObject * obj0 = 0 ;
19981 PyObject * obj1 = 0 ;
19982 char *kwnames[] = {
19983 (char *) "self",(char *) "size", NULL
19984 };
19985
19986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19988 if (SWIG_arg_fail(1)) SWIG_fail;
19989 {
19990 wxSize * argp;
19991 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19992 if (SWIG_arg_fail(2)) SWIG_fail;
19993 if (argp == NULL) {
19994 SWIG_null_ref("wxSize");
19995 }
19996 if (SWIG_arg_fail(2)) SWIG_fail;
19997 arg2 = *argp;
19998 }
19999 {
20000 PyThreadState* __tstate = wxPyBeginAllowThreads();
20001 wxSizeEvent_SetSize(arg1,arg2);
20002
20003 wxPyEndAllowThreads(__tstate);
20004 if (PyErr_Occurred()) SWIG_fail;
20005 }
20006 Py_INCREF(Py_None); resultobj = Py_None;
20007 return resultobj;
20008 fail:
20009 return NULL;
20010 }
20011
20012
20013 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20014 PyObject *resultobj;
20015 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20016 wxSize *arg2 = (wxSize *) 0 ;
20017 PyObject * obj0 = 0 ;
20018 PyObject * obj1 = 0 ;
20019 char *kwnames[] = {
20020 (char *) "self",(char *) "m_size", NULL
20021 };
20022
20023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20025 if (SWIG_arg_fail(1)) SWIG_fail;
20026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20027 if (SWIG_arg_fail(2)) SWIG_fail;
20028 if (arg1) (arg1)->m_size = *arg2;
20029
20030 Py_INCREF(Py_None); resultobj = Py_None;
20031 return resultobj;
20032 fail:
20033 return NULL;
20034 }
20035
20036
20037 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20038 PyObject *resultobj;
20039 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20040 wxSize *result;
20041 PyObject * obj0 = 0 ;
20042 char *kwnames[] = {
20043 (char *) "self", NULL
20044 };
20045
20046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20048 if (SWIG_arg_fail(1)) SWIG_fail;
20049 result = (wxSize *)& ((arg1)->m_size);
20050
20051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20059 PyObject *resultobj;
20060 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20061 wxRect *arg2 = (wxRect *) 0 ;
20062 PyObject * obj0 = 0 ;
20063 PyObject * obj1 = 0 ;
20064 char *kwnames[] = {
20065 (char *) "self",(char *) "m_rect", NULL
20066 };
20067
20068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20070 if (SWIG_arg_fail(1)) SWIG_fail;
20071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20072 if (SWIG_arg_fail(2)) SWIG_fail;
20073 if (arg1) (arg1)->m_rect = *arg2;
20074
20075 Py_INCREF(Py_None); resultobj = Py_None;
20076 return resultobj;
20077 fail:
20078 return NULL;
20079 }
20080
20081
20082 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20083 PyObject *resultobj;
20084 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20085 wxRect *result;
20086 PyObject * obj0 = 0 ;
20087 char *kwnames[] = {
20088 (char *) "self", NULL
20089 };
20090
20091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20093 if (SWIG_arg_fail(1)) SWIG_fail;
20094 result = (wxRect *)& ((arg1)->m_rect);
20095
20096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20097 return resultobj;
20098 fail:
20099 return NULL;
20100 }
20101
20102
20103 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20104 PyObject *obj;
20105 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20106 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20107 Py_INCREF(obj);
20108 return Py_BuildValue((char *)"");
20109 }
20110 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20111 PyObject *resultobj;
20112 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20113 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20114 int arg2 = (int) 0 ;
20115 wxMoveEvent *result;
20116 wxPoint temp1 ;
20117 PyObject * obj0 = 0 ;
20118 PyObject * obj1 = 0 ;
20119 char *kwnames[] = {
20120 (char *) "pos",(char *) "winid", NULL
20121 };
20122
20123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20124 if (obj0) {
20125 {
20126 arg1 = &temp1;
20127 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20128 }
20129 }
20130 if (obj1) {
20131 {
20132 arg2 = (int)(SWIG_As_int(obj1));
20133 if (SWIG_arg_fail(2)) SWIG_fail;
20134 }
20135 }
20136 {
20137 PyThreadState* __tstate = wxPyBeginAllowThreads();
20138 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20139
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20144 return resultobj;
20145 fail:
20146 return NULL;
20147 }
20148
20149
20150 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20151 PyObject *resultobj;
20152 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20153 wxPoint result;
20154 PyObject * obj0 = 0 ;
20155 char *kwnames[] = {
20156 (char *) "self", NULL
20157 };
20158
20159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20161 if (SWIG_arg_fail(1)) SWIG_fail;
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = ((wxMoveEvent const *)arg1)->GetPosition();
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 {
20170 wxPoint * resultptr;
20171 resultptr = new wxPoint((wxPoint &)(result));
20172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20173 }
20174 return resultobj;
20175 fail:
20176 return NULL;
20177 }
20178
20179
20180 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20181 PyObject *resultobj;
20182 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20183 wxRect result;
20184 PyObject * obj0 = 0 ;
20185 char *kwnames[] = {
20186 (char *) "self", NULL
20187 };
20188
20189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20191 if (SWIG_arg_fail(1)) SWIG_fail;
20192 {
20193 PyThreadState* __tstate = wxPyBeginAllowThreads();
20194 result = ((wxMoveEvent const *)arg1)->GetRect();
20195
20196 wxPyEndAllowThreads(__tstate);
20197 if (PyErr_Occurred()) SWIG_fail;
20198 }
20199 {
20200 wxRect * resultptr;
20201 resultptr = new wxRect((wxRect &)(result));
20202 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20203 }
20204 return resultobj;
20205 fail:
20206 return NULL;
20207 }
20208
20209
20210 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20211 PyObject *resultobj;
20212 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20213 wxRect *arg2 = 0 ;
20214 wxRect temp2 ;
20215 PyObject * obj0 = 0 ;
20216 PyObject * obj1 = 0 ;
20217 char *kwnames[] = {
20218 (char *) "self",(char *) "rect", NULL
20219 };
20220
20221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20223 if (SWIG_arg_fail(1)) SWIG_fail;
20224 {
20225 arg2 = &temp2;
20226 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20227 }
20228 {
20229 PyThreadState* __tstate = wxPyBeginAllowThreads();
20230 (arg1)->SetRect((wxRect const &)*arg2);
20231
20232 wxPyEndAllowThreads(__tstate);
20233 if (PyErr_Occurred()) SWIG_fail;
20234 }
20235 Py_INCREF(Py_None); resultobj = Py_None;
20236 return resultobj;
20237 fail:
20238 return NULL;
20239 }
20240
20241
20242 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20243 PyObject *resultobj;
20244 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20245 wxPoint *arg2 = 0 ;
20246 wxPoint temp2 ;
20247 PyObject * obj0 = 0 ;
20248 PyObject * obj1 = 0 ;
20249 char *kwnames[] = {
20250 (char *) "self",(char *) "pos", NULL
20251 };
20252
20253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20255 if (SWIG_arg_fail(1)) SWIG_fail;
20256 {
20257 arg2 = &temp2;
20258 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20259 }
20260 {
20261 PyThreadState* __tstate = wxPyBeginAllowThreads();
20262 (arg1)->SetPosition((wxPoint const &)*arg2);
20263
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 Py_INCREF(Py_None); resultobj = Py_None;
20268 return resultobj;
20269 fail:
20270 return NULL;
20271 }
20272
20273
20274 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20275 PyObject *obj;
20276 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20277 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20278 Py_INCREF(obj);
20279 return Py_BuildValue((char *)"");
20280 }
20281 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20282 PyObject *resultobj;
20283 int arg1 = (int) 0 ;
20284 wxPaintEvent *result;
20285 PyObject * obj0 = 0 ;
20286 char *kwnames[] = {
20287 (char *) "Id", NULL
20288 };
20289
20290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20291 if (obj0) {
20292 {
20293 arg1 = (int)(SWIG_As_int(obj0));
20294 if (SWIG_arg_fail(1)) SWIG_fail;
20295 }
20296 }
20297 {
20298 PyThreadState* __tstate = wxPyBeginAllowThreads();
20299 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20300
20301 wxPyEndAllowThreads(__tstate);
20302 if (PyErr_Occurred()) SWIG_fail;
20303 }
20304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20305 return resultobj;
20306 fail:
20307 return NULL;
20308 }
20309
20310
20311 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20312 PyObject *obj;
20313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20314 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20315 Py_INCREF(obj);
20316 return Py_BuildValue((char *)"");
20317 }
20318 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20319 PyObject *resultobj;
20320 int arg1 = (int) 0 ;
20321 wxNcPaintEvent *result;
20322 PyObject * obj0 = 0 ;
20323 char *kwnames[] = {
20324 (char *) "winid", NULL
20325 };
20326
20327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20328 if (obj0) {
20329 {
20330 arg1 = (int)(SWIG_As_int(obj0));
20331 if (SWIG_arg_fail(1)) SWIG_fail;
20332 }
20333 }
20334 {
20335 PyThreadState* __tstate = wxPyBeginAllowThreads();
20336 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20337
20338 wxPyEndAllowThreads(__tstate);
20339 if (PyErr_Occurred()) SWIG_fail;
20340 }
20341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20342 return resultobj;
20343 fail:
20344 return NULL;
20345 }
20346
20347
20348 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20349 PyObject *obj;
20350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20351 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20352 Py_INCREF(obj);
20353 return Py_BuildValue((char *)"");
20354 }
20355 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20356 PyObject *resultobj;
20357 int arg1 = (int) 0 ;
20358 wxDC *arg2 = (wxDC *) NULL ;
20359 wxEraseEvent *result;
20360 PyObject * obj0 = 0 ;
20361 PyObject * obj1 = 0 ;
20362 char *kwnames[] = {
20363 (char *) "Id",(char *) "dc", NULL
20364 };
20365
20366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20367 if (obj0) {
20368 {
20369 arg1 = (int)(SWIG_As_int(obj0));
20370 if (SWIG_arg_fail(1)) SWIG_fail;
20371 }
20372 }
20373 if (obj1) {
20374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20375 if (SWIG_arg_fail(2)) SWIG_fail;
20376 }
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20380
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20385 return resultobj;
20386 fail:
20387 return NULL;
20388 }
20389
20390
20391 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20392 PyObject *resultobj;
20393 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20394 wxDC *result;
20395 PyObject * obj0 = 0 ;
20396 char *kwnames[] = {
20397 (char *) "self", NULL
20398 };
20399
20400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20402 if (SWIG_arg_fail(1)) SWIG_fail;
20403 {
20404 PyThreadState* __tstate = wxPyBeginAllowThreads();
20405 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20406
20407 wxPyEndAllowThreads(__tstate);
20408 if (PyErr_Occurred()) SWIG_fail;
20409 }
20410 {
20411 resultobj = wxPyMake_wxObject(result, 0);
20412 }
20413 return resultobj;
20414 fail:
20415 return NULL;
20416 }
20417
20418
20419 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20420 PyObject *obj;
20421 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20422 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20423 Py_INCREF(obj);
20424 return Py_BuildValue((char *)"");
20425 }
20426 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20427 PyObject *resultobj;
20428 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20429 int arg2 = (int) 0 ;
20430 wxFocusEvent *result;
20431 PyObject * obj0 = 0 ;
20432 PyObject * obj1 = 0 ;
20433 char *kwnames[] = {
20434 (char *) "type",(char *) "winid", NULL
20435 };
20436
20437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20438 if (obj0) {
20439 {
20440 arg1 = (wxEventType)(SWIG_As_int(obj0));
20441 if (SWIG_arg_fail(1)) SWIG_fail;
20442 }
20443 }
20444 if (obj1) {
20445 {
20446 arg2 = (int)(SWIG_As_int(obj1));
20447 if (SWIG_arg_fail(2)) SWIG_fail;
20448 }
20449 }
20450 {
20451 PyThreadState* __tstate = wxPyBeginAllowThreads();
20452 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20453
20454 wxPyEndAllowThreads(__tstate);
20455 if (PyErr_Occurred()) SWIG_fail;
20456 }
20457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20458 return resultobj;
20459 fail:
20460 return NULL;
20461 }
20462
20463
20464 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20465 PyObject *resultobj;
20466 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20467 wxWindow *result;
20468 PyObject * obj0 = 0 ;
20469 char *kwnames[] = {
20470 (char *) "self", NULL
20471 };
20472
20473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20475 if (SWIG_arg_fail(1)) SWIG_fail;
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20479
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 {
20484 resultobj = wxPyMake_wxObject(result, 0);
20485 }
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20493 PyObject *resultobj;
20494 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20495 wxWindow *arg2 = (wxWindow *) 0 ;
20496 PyObject * obj0 = 0 ;
20497 PyObject * obj1 = 0 ;
20498 char *kwnames[] = {
20499 (char *) "self",(char *) "win", NULL
20500 };
20501
20502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20504 if (SWIG_arg_fail(1)) SWIG_fail;
20505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20506 if (SWIG_arg_fail(2)) SWIG_fail;
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 (arg1)->SetWindow(arg2);
20510
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 Py_INCREF(Py_None); resultobj = Py_None;
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20522 PyObject *obj;
20523 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20524 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20525 Py_INCREF(obj);
20526 return Py_BuildValue((char *)"");
20527 }
20528 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20529 PyObject *resultobj;
20530 wxWindow *arg1 = (wxWindow *) NULL ;
20531 wxChildFocusEvent *result;
20532 PyObject * obj0 = 0 ;
20533 char *kwnames[] = {
20534 (char *) "win", NULL
20535 };
20536
20537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20538 if (obj0) {
20539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20540 if (SWIG_arg_fail(1)) SWIG_fail;
20541 }
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20545
20546 wxPyEndAllowThreads(__tstate);
20547 if (PyErr_Occurred()) SWIG_fail;
20548 }
20549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20550 return resultobj;
20551 fail:
20552 return NULL;
20553 }
20554
20555
20556 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20557 PyObject *resultobj;
20558 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20559 wxWindow *result;
20560 PyObject * obj0 = 0 ;
20561 char *kwnames[] = {
20562 (char *) "self", NULL
20563 };
20564
20565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20567 if (SWIG_arg_fail(1)) SWIG_fail;
20568 {
20569 PyThreadState* __tstate = wxPyBeginAllowThreads();
20570 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20571
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 {
20576 resultobj = wxPyMake_wxObject(result, 0);
20577 }
20578 return resultobj;
20579 fail:
20580 return NULL;
20581 }
20582
20583
20584 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20585 PyObject *obj;
20586 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20587 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20588 Py_INCREF(obj);
20589 return Py_BuildValue((char *)"");
20590 }
20591 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20592 PyObject *resultobj;
20593 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20594 bool arg2 = (bool) true ;
20595 int arg3 = (int) 0 ;
20596 wxActivateEvent *result;
20597 PyObject * obj0 = 0 ;
20598 PyObject * obj1 = 0 ;
20599 PyObject * obj2 = 0 ;
20600 char *kwnames[] = {
20601 (char *) "type",(char *) "active",(char *) "Id", NULL
20602 };
20603
20604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20605 if (obj0) {
20606 {
20607 arg1 = (wxEventType)(SWIG_As_int(obj0));
20608 if (SWIG_arg_fail(1)) SWIG_fail;
20609 }
20610 }
20611 if (obj1) {
20612 {
20613 arg2 = (bool)(SWIG_As_bool(obj1));
20614 if (SWIG_arg_fail(2)) SWIG_fail;
20615 }
20616 }
20617 if (obj2) {
20618 {
20619 arg3 = (int)(SWIG_As_int(obj2));
20620 if (SWIG_arg_fail(3)) SWIG_fail;
20621 }
20622 }
20623 {
20624 PyThreadState* __tstate = wxPyBeginAllowThreads();
20625 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20626
20627 wxPyEndAllowThreads(__tstate);
20628 if (PyErr_Occurred()) SWIG_fail;
20629 }
20630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20631 return resultobj;
20632 fail:
20633 return NULL;
20634 }
20635
20636
20637 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20638 PyObject *resultobj;
20639 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20640 bool result;
20641 PyObject * obj0 = 0 ;
20642 char *kwnames[] = {
20643 (char *) "self", NULL
20644 };
20645
20646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20648 if (SWIG_arg_fail(1)) SWIG_fail;
20649 {
20650 PyThreadState* __tstate = wxPyBeginAllowThreads();
20651 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20652
20653 wxPyEndAllowThreads(__tstate);
20654 if (PyErr_Occurred()) SWIG_fail;
20655 }
20656 {
20657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20658 }
20659 return resultobj;
20660 fail:
20661 return NULL;
20662 }
20663
20664
20665 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20666 PyObject *obj;
20667 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20668 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20669 Py_INCREF(obj);
20670 return Py_BuildValue((char *)"");
20671 }
20672 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20673 PyObject *resultobj;
20674 int arg1 = (int) 0 ;
20675 wxInitDialogEvent *result;
20676 PyObject * obj0 = 0 ;
20677 char *kwnames[] = {
20678 (char *) "Id", NULL
20679 };
20680
20681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20682 if (obj0) {
20683 {
20684 arg1 = (int)(SWIG_As_int(obj0));
20685 if (SWIG_arg_fail(1)) SWIG_fail;
20686 }
20687 }
20688 {
20689 PyThreadState* __tstate = wxPyBeginAllowThreads();
20690 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20691
20692 wxPyEndAllowThreads(__tstate);
20693 if (PyErr_Occurred()) SWIG_fail;
20694 }
20695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20696 return resultobj;
20697 fail:
20698 return NULL;
20699 }
20700
20701
20702 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20703 PyObject *obj;
20704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20705 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20706 Py_INCREF(obj);
20707 return Py_BuildValue((char *)"");
20708 }
20709 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20710 PyObject *resultobj;
20711 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20712 int arg2 = (int) 0 ;
20713 wxMenu *arg3 = (wxMenu *) NULL ;
20714 wxMenuEvent *result;
20715 PyObject * obj0 = 0 ;
20716 PyObject * obj1 = 0 ;
20717 PyObject * obj2 = 0 ;
20718 char *kwnames[] = {
20719 (char *) "type",(char *) "winid",(char *) "menu", NULL
20720 };
20721
20722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20723 if (obj0) {
20724 {
20725 arg1 = (wxEventType)(SWIG_As_int(obj0));
20726 if (SWIG_arg_fail(1)) SWIG_fail;
20727 }
20728 }
20729 if (obj1) {
20730 {
20731 arg2 = (int)(SWIG_As_int(obj1));
20732 if (SWIG_arg_fail(2)) SWIG_fail;
20733 }
20734 }
20735 if (obj2) {
20736 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20737 if (SWIG_arg_fail(3)) SWIG_fail;
20738 }
20739 {
20740 PyThreadState* __tstate = wxPyBeginAllowThreads();
20741 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20742
20743 wxPyEndAllowThreads(__tstate);
20744 if (PyErr_Occurred()) SWIG_fail;
20745 }
20746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20747 return resultobj;
20748 fail:
20749 return NULL;
20750 }
20751
20752
20753 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20754 PyObject *resultobj;
20755 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20756 int result;
20757 PyObject * obj0 = 0 ;
20758 char *kwnames[] = {
20759 (char *) "self", NULL
20760 };
20761
20762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20764 if (SWIG_arg_fail(1)) SWIG_fail;
20765 {
20766 PyThreadState* __tstate = wxPyBeginAllowThreads();
20767 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20768
20769 wxPyEndAllowThreads(__tstate);
20770 if (PyErr_Occurred()) SWIG_fail;
20771 }
20772 {
20773 resultobj = SWIG_From_int((int)(result));
20774 }
20775 return resultobj;
20776 fail:
20777 return NULL;
20778 }
20779
20780
20781 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20782 PyObject *resultobj;
20783 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20784 bool result;
20785 PyObject * obj0 = 0 ;
20786 char *kwnames[] = {
20787 (char *) "self", NULL
20788 };
20789
20790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 {
20794 PyThreadState* __tstate = wxPyBeginAllowThreads();
20795 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20796
20797 wxPyEndAllowThreads(__tstate);
20798 if (PyErr_Occurred()) SWIG_fail;
20799 }
20800 {
20801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20802 }
20803 return resultobj;
20804 fail:
20805 return NULL;
20806 }
20807
20808
20809 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20810 PyObject *resultobj;
20811 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20812 wxMenu *result;
20813 PyObject * obj0 = 0 ;
20814 char *kwnames[] = {
20815 (char *) "self", NULL
20816 };
20817
20818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20820 if (SWIG_arg_fail(1)) SWIG_fail;
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20824
20825 wxPyEndAllowThreads(__tstate);
20826 if (PyErr_Occurred()) SWIG_fail;
20827 }
20828 {
20829 resultobj = wxPyMake_wxObject(result, 0);
20830 }
20831 return resultobj;
20832 fail:
20833 return NULL;
20834 }
20835
20836
20837 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20838 PyObject *obj;
20839 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20840 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20841 Py_INCREF(obj);
20842 return Py_BuildValue((char *)"");
20843 }
20844 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20845 PyObject *resultobj;
20846 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20847 int arg2 = (int) 0 ;
20848 wxCloseEvent *result;
20849 PyObject * obj0 = 0 ;
20850 PyObject * obj1 = 0 ;
20851 char *kwnames[] = {
20852 (char *) "type",(char *) "winid", NULL
20853 };
20854
20855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20856 if (obj0) {
20857 {
20858 arg1 = (wxEventType)(SWIG_As_int(obj0));
20859 if (SWIG_arg_fail(1)) SWIG_fail;
20860 }
20861 }
20862 if (obj1) {
20863 {
20864 arg2 = (int)(SWIG_As_int(obj1));
20865 if (SWIG_arg_fail(2)) SWIG_fail;
20866 }
20867 }
20868 {
20869 PyThreadState* __tstate = wxPyBeginAllowThreads();
20870 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20871
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20876 return resultobj;
20877 fail:
20878 return NULL;
20879 }
20880
20881
20882 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20883 PyObject *resultobj;
20884 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20885 bool arg2 ;
20886 PyObject * obj0 = 0 ;
20887 PyObject * obj1 = 0 ;
20888 char *kwnames[] = {
20889 (char *) "self",(char *) "logOff", NULL
20890 };
20891
20892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20894 if (SWIG_arg_fail(1)) SWIG_fail;
20895 {
20896 arg2 = (bool)(SWIG_As_bool(obj1));
20897 if (SWIG_arg_fail(2)) SWIG_fail;
20898 }
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 (arg1)->SetLoggingOff(arg2);
20902
20903 wxPyEndAllowThreads(__tstate);
20904 if (PyErr_Occurred()) SWIG_fail;
20905 }
20906 Py_INCREF(Py_None); resultobj = Py_None;
20907 return resultobj;
20908 fail:
20909 return NULL;
20910 }
20911
20912
20913 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20914 PyObject *resultobj;
20915 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20916 bool result;
20917 PyObject * obj0 = 0 ;
20918 char *kwnames[] = {
20919 (char *) "self", NULL
20920 };
20921
20922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20924 if (SWIG_arg_fail(1)) SWIG_fail;
20925 {
20926 PyThreadState* __tstate = wxPyBeginAllowThreads();
20927 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20928
20929 wxPyEndAllowThreads(__tstate);
20930 if (PyErr_Occurred()) SWIG_fail;
20931 }
20932 {
20933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20934 }
20935 return resultobj;
20936 fail:
20937 return NULL;
20938 }
20939
20940
20941 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20942 PyObject *resultobj;
20943 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20944 bool arg2 = (bool) true ;
20945 PyObject * obj0 = 0 ;
20946 PyObject * obj1 = 0 ;
20947 char *kwnames[] = {
20948 (char *) "self",(char *) "veto", NULL
20949 };
20950
20951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20953 if (SWIG_arg_fail(1)) SWIG_fail;
20954 if (obj1) {
20955 {
20956 arg2 = (bool)(SWIG_As_bool(obj1));
20957 if (SWIG_arg_fail(2)) SWIG_fail;
20958 }
20959 }
20960 {
20961 PyThreadState* __tstate = wxPyBeginAllowThreads();
20962 (arg1)->Veto(arg2);
20963
20964 wxPyEndAllowThreads(__tstate);
20965 if (PyErr_Occurred()) SWIG_fail;
20966 }
20967 Py_INCREF(Py_None); resultobj = Py_None;
20968 return resultobj;
20969 fail:
20970 return NULL;
20971 }
20972
20973
20974 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20975 PyObject *resultobj;
20976 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20977 bool result;
20978 PyObject * obj0 = 0 ;
20979 char *kwnames[] = {
20980 (char *) "self", NULL
20981 };
20982
20983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20985 if (SWIG_arg_fail(1)) SWIG_fail;
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20989
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 {
20994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20995 }
20996 return resultobj;
20997 fail:
20998 return NULL;
20999 }
21000
21001
21002 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21003 PyObject *resultobj;
21004 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21005 bool arg2 ;
21006 PyObject * obj0 = 0 ;
21007 PyObject * obj1 = 0 ;
21008 char *kwnames[] = {
21009 (char *) "self",(char *) "canVeto", NULL
21010 };
21011
21012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21014 if (SWIG_arg_fail(1)) SWIG_fail;
21015 {
21016 arg2 = (bool)(SWIG_As_bool(obj1));
21017 if (SWIG_arg_fail(2)) SWIG_fail;
21018 }
21019 {
21020 PyThreadState* __tstate = wxPyBeginAllowThreads();
21021 (arg1)->SetCanVeto(arg2);
21022
21023 wxPyEndAllowThreads(__tstate);
21024 if (PyErr_Occurred()) SWIG_fail;
21025 }
21026 Py_INCREF(Py_None); resultobj = Py_None;
21027 return resultobj;
21028 fail:
21029 return NULL;
21030 }
21031
21032
21033 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21034 PyObject *resultobj;
21035 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21036 bool result;
21037 PyObject * obj0 = 0 ;
21038 char *kwnames[] = {
21039 (char *) "self", NULL
21040 };
21041
21042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21044 if (SWIG_arg_fail(1)) SWIG_fail;
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21048
21049 wxPyEndAllowThreads(__tstate);
21050 if (PyErr_Occurred()) SWIG_fail;
21051 }
21052 {
21053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21054 }
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21062 PyObject *obj;
21063 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21064 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21065 Py_INCREF(obj);
21066 return Py_BuildValue((char *)"");
21067 }
21068 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21069 PyObject *resultobj;
21070 int arg1 = (int) 0 ;
21071 bool arg2 = (bool) false ;
21072 wxShowEvent *result;
21073 PyObject * obj0 = 0 ;
21074 PyObject * obj1 = 0 ;
21075 char *kwnames[] = {
21076 (char *) "winid",(char *) "show", NULL
21077 };
21078
21079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21080 if (obj0) {
21081 {
21082 arg1 = (int)(SWIG_As_int(obj0));
21083 if (SWIG_arg_fail(1)) SWIG_fail;
21084 }
21085 }
21086 if (obj1) {
21087 {
21088 arg2 = (bool)(SWIG_As_bool(obj1));
21089 if (SWIG_arg_fail(2)) SWIG_fail;
21090 }
21091 }
21092 {
21093 PyThreadState* __tstate = wxPyBeginAllowThreads();
21094 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21095
21096 wxPyEndAllowThreads(__tstate);
21097 if (PyErr_Occurred()) SWIG_fail;
21098 }
21099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21100 return resultobj;
21101 fail:
21102 return NULL;
21103 }
21104
21105
21106 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21107 PyObject *resultobj;
21108 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21109 bool arg2 ;
21110 PyObject * obj0 = 0 ;
21111 PyObject * obj1 = 0 ;
21112 char *kwnames[] = {
21113 (char *) "self",(char *) "show", NULL
21114 };
21115
21116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21118 if (SWIG_arg_fail(1)) SWIG_fail;
21119 {
21120 arg2 = (bool)(SWIG_As_bool(obj1));
21121 if (SWIG_arg_fail(2)) SWIG_fail;
21122 }
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 (arg1)->SetShow(arg2);
21126
21127 wxPyEndAllowThreads(__tstate);
21128 if (PyErr_Occurred()) SWIG_fail;
21129 }
21130 Py_INCREF(Py_None); resultobj = Py_None;
21131 return resultobj;
21132 fail:
21133 return NULL;
21134 }
21135
21136
21137 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21138 PyObject *resultobj;
21139 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21140 bool result;
21141 PyObject * obj0 = 0 ;
21142 char *kwnames[] = {
21143 (char *) "self", NULL
21144 };
21145
21146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21148 if (SWIG_arg_fail(1)) SWIG_fail;
21149 {
21150 PyThreadState* __tstate = wxPyBeginAllowThreads();
21151 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21152
21153 wxPyEndAllowThreads(__tstate);
21154 if (PyErr_Occurred()) SWIG_fail;
21155 }
21156 {
21157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21158 }
21159 return resultobj;
21160 fail:
21161 return NULL;
21162 }
21163
21164
21165 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21166 PyObject *obj;
21167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21168 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21169 Py_INCREF(obj);
21170 return Py_BuildValue((char *)"");
21171 }
21172 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21173 PyObject *resultobj;
21174 int arg1 = (int) 0 ;
21175 bool arg2 = (bool) true ;
21176 wxIconizeEvent *result;
21177 PyObject * obj0 = 0 ;
21178 PyObject * obj1 = 0 ;
21179 char *kwnames[] = {
21180 (char *) "id",(char *) "iconized", NULL
21181 };
21182
21183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21184 if (obj0) {
21185 {
21186 arg1 = (int)(SWIG_As_int(obj0));
21187 if (SWIG_arg_fail(1)) SWIG_fail;
21188 }
21189 }
21190 if (obj1) {
21191 {
21192 arg2 = (bool)(SWIG_As_bool(obj1));
21193 if (SWIG_arg_fail(2)) SWIG_fail;
21194 }
21195 }
21196 {
21197 PyThreadState* __tstate = wxPyBeginAllowThreads();
21198 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21199
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21204 return resultobj;
21205 fail:
21206 return NULL;
21207 }
21208
21209
21210 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21211 PyObject *resultobj;
21212 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21213 bool result;
21214 PyObject * obj0 = 0 ;
21215 char *kwnames[] = {
21216 (char *) "self", NULL
21217 };
21218
21219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21221 if (SWIG_arg_fail(1)) SWIG_fail;
21222 {
21223 PyThreadState* __tstate = wxPyBeginAllowThreads();
21224 result = (bool)(arg1)->Iconized();
21225
21226 wxPyEndAllowThreads(__tstate);
21227 if (PyErr_Occurred()) SWIG_fail;
21228 }
21229 {
21230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21231 }
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21239 PyObject *obj;
21240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21241 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21242 Py_INCREF(obj);
21243 return Py_BuildValue((char *)"");
21244 }
21245 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21246 PyObject *resultobj;
21247 int arg1 = (int) 0 ;
21248 wxMaximizeEvent *result;
21249 PyObject * obj0 = 0 ;
21250 char *kwnames[] = {
21251 (char *) "id", NULL
21252 };
21253
21254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21255 if (obj0) {
21256 {
21257 arg1 = (int)(SWIG_As_int(obj0));
21258 if (SWIG_arg_fail(1)) SWIG_fail;
21259 }
21260 }
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21264
21265 wxPyEndAllowThreads(__tstate);
21266 if (PyErr_Occurred()) SWIG_fail;
21267 }
21268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21269 return resultobj;
21270 fail:
21271 return NULL;
21272 }
21273
21274
21275 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21276 PyObject *obj;
21277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21278 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21279 Py_INCREF(obj);
21280 return Py_BuildValue((char *)"");
21281 }
21282 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21283 PyObject *resultobj;
21284 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21285 wxPoint result;
21286 PyObject * obj0 = 0 ;
21287 char *kwnames[] = {
21288 (char *) "self", NULL
21289 };
21290
21291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21293 if (SWIG_arg_fail(1)) SWIG_fail;
21294 {
21295 PyThreadState* __tstate = wxPyBeginAllowThreads();
21296 result = (arg1)->GetPosition();
21297
21298 wxPyEndAllowThreads(__tstate);
21299 if (PyErr_Occurred()) SWIG_fail;
21300 }
21301 {
21302 wxPoint * resultptr;
21303 resultptr = new wxPoint((wxPoint &)(result));
21304 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21305 }
21306 return resultobj;
21307 fail:
21308 return NULL;
21309 }
21310
21311
21312 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21313 PyObject *resultobj;
21314 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21315 int result;
21316 PyObject * obj0 = 0 ;
21317 char *kwnames[] = {
21318 (char *) "self", NULL
21319 };
21320
21321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21323 if (SWIG_arg_fail(1)) SWIG_fail;
21324 {
21325 PyThreadState* __tstate = wxPyBeginAllowThreads();
21326 result = (int)(arg1)->GetNumberOfFiles();
21327
21328 wxPyEndAllowThreads(__tstate);
21329 if (PyErr_Occurred()) SWIG_fail;
21330 }
21331 {
21332 resultobj = SWIG_From_int((int)(result));
21333 }
21334 return resultobj;
21335 fail:
21336 return NULL;
21337 }
21338
21339
21340 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21341 PyObject *resultobj;
21342 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21343 PyObject *result;
21344 PyObject * obj0 = 0 ;
21345 char *kwnames[] = {
21346 (char *) "self", NULL
21347 };
21348
21349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21351 if (SWIG_arg_fail(1)) SWIG_fail;
21352 {
21353 PyThreadState* __tstate = wxPyBeginAllowThreads();
21354 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21355
21356 wxPyEndAllowThreads(__tstate);
21357 if (PyErr_Occurred()) SWIG_fail;
21358 }
21359 resultobj = result;
21360 return resultobj;
21361 fail:
21362 return NULL;
21363 }
21364
21365
21366 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21367 PyObject *obj;
21368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21369 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21370 Py_INCREF(obj);
21371 return Py_BuildValue((char *)"");
21372 }
21373 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21374 PyObject *resultobj;
21375 int arg1 = (int) 0 ;
21376 wxUpdateUIEvent *result;
21377 PyObject * obj0 = 0 ;
21378 char *kwnames[] = {
21379 (char *) "commandId", NULL
21380 };
21381
21382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21383 if (obj0) {
21384 {
21385 arg1 = (int)(SWIG_As_int(obj0));
21386 if (SWIG_arg_fail(1)) SWIG_fail;
21387 }
21388 }
21389 {
21390 PyThreadState* __tstate = wxPyBeginAllowThreads();
21391 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21392
21393 wxPyEndAllowThreads(__tstate);
21394 if (PyErr_Occurred()) SWIG_fail;
21395 }
21396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21397 return resultobj;
21398 fail:
21399 return NULL;
21400 }
21401
21402
21403 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21404 PyObject *resultobj;
21405 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21406 bool result;
21407 PyObject * obj0 = 0 ;
21408 char *kwnames[] = {
21409 (char *) "self", NULL
21410 };
21411
21412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21414 if (SWIG_arg_fail(1)) SWIG_fail;
21415 {
21416 PyThreadState* __tstate = wxPyBeginAllowThreads();
21417 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21418
21419 wxPyEndAllowThreads(__tstate);
21420 if (PyErr_Occurred()) SWIG_fail;
21421 }
21422 {
21423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21424 }
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21432 PyObject *resultobj;
21433 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21434 bool result;
21435 PyObject * obj0 = 0 ;
21436 char *kwnames[] = {
21437 (char *) "self", NULL
21438 };
21439
21440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21442 if (SWIG_arg_fail(1)) SWIG_fail;
21443 {
21444 PyThreadState* __tstate = wxPyBeginAllowThreads();
21445 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21446
21447 wxPyEndAllowThreads(__tstate);
21448 if (PyErr_Occurred()) SWIG_fail;
21449 }
21450 {
21451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21452 }
21453 return resultobj;
21454 fail:
21455 return NULL;
21456 }
21457
21458
21459 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21460 PyObject *resultobj;
21461 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21462 wxString result;
21463 PyObject * obj0 = 0 ;
21464 char *kwnames[] = {
21465 (char *) "self", NULL
21466 };
21467
21468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21470 if (SWIG_arg_fail(1)) SWIG_fail;
21471 {
21472 PyThreadState* __tstate = wxPyBeginAllowThreads();
21473 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21474
21475 wxPyEndAllowThreads(__tstate);
21476 if (PyErr_Occurred()) SWIG_fail;
21477 }
21478 {
21479 #if wxUSE_UNICODE
21480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21481 #else
21482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21483 #endif
21484 }
21485 return resultobj;
21486 fail:
21487 return NULL;
21488 }
21489
21490
21491 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21492 PyObject *resultobj;
21493 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21494 bool result;
21495 PyObject * obj0 = 0 ;
21496 char *kwnames[] = {
21497 (char *) "self", NULL
21498 };
21499
21500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21502 if (SWIG_arg_fail(1)) SWIG_fail;
21503 {
21504 PyThreadState* __tstate = wxPyBeginAllowThreads();
21505 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21506
21507 wxPyEndAllowThreads(__tstate);
21508 if (PyErr_Occurred()) SWIG_fail;
21509 }
21510 {
21511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21512 }
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21520 PyObject *resultobj;
21521 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21522 bool result;
21523 PyObject * obj0 = 0 ;
21524 char *kwnames[] = {
21525 (char *) "self", NULL
21526 };
21527
21528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21530 if (SWIG_arg_fail(1)) SWIG_fail;
21531 {
21532 PyThreadState* __tstate = wxPyBeginAllowThreads();
21533 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21534
21535 wxPyEndAllowThreads(__tstate);
21536 if (PyErr_Occurred()) SWIG_fail;
21537 }
21538 {
21539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21540 }
21541 return resultobj;
21542 fail:
21543 return NULL;
21544 }
21545
21546
21547 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21548 PyObject *resultobj;
21549 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21550 bool result;
21551 PyObject * obj0 = 0 ;
21552 char *kwnames[] = {
21553 (char *) "self", NULL
21554 };
21555
21556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21558 if (SWIG_arg_fail(1)) SWIG_fail;
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21562
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 {
21567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21568 }
21569 return resultobj;
21570 fail:
21571 return NULL;
21572 }
21573
21574
21575 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21576 PyObject *resultobj;
21577 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21578 bool arg2 ;
21579 PyObject * obj0 = 0 ;
21580 PyObject * obj1 = 0 ;
21581 char *kwnames[] = {
21582 (char *) "self",(char *) "check", NULL
21583 };
21584
21585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21587 if (SWIG_arg_fail(1)) SWIG_fail;
21588 {
21589 arg2 = (bool)(SWIG_As_bool(obj1));
21590 if (SWIG_arg_fail(2)) SWIG_fail;
21591 }
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 (arg1)->Check(arg2);
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 Py_INCREF(Py_None); resultobj = Py_None;
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21607 PyObject *resultobj;
21608 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21609 bool arg2 ;
21610 PyObject * obj0 = 0 ;
21611 PyObject * obj1 = 0 ;
21612 char *kwnames[] = {
21613 (char *) "self",(char *) "enable", NULL
21614 };
21615
21616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21618 if (SWIG_arg_fail(1)) SWIG_fail;
21619 {
21620 arg2 = (bool)(SWIG_As_bool(obj1));
21621 if (SWIG_arg_fail(2)) SWIG_fail;
21622 }
21623 {
21624 PyThreadState* __tstate = wxPyBeginAllowThreads();
21625 (arg1)->Enable(arg2);
21626
21627 wxPyEndAllowThreads(__tstate);
21628 if (PyErr_Occurred()) SWIG_fail;
21629 }
21630 Py_INCREF(Py_None); resultobj = Py_None;
21631 return resultobj;
21632 fail:
21633 return NULL;
21634 }
21635
21636
21637 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21638 PyObject *resultobj;
21639 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21640 wxString *arg2 = 0 ;
21641 bool temp2 = false ;
21642 PyObject * obj0 = 0 ;
21643 PyObject * obj1 = 0 ;
21644 char *kwnames[] = {
21645 (char *) "self",(char *) "text", NULL
21646 };
21647
21648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21650 if (SWIG_arg_fail(1)) SWIG_fail;
21651 {
21652 arg2 = wxString_in_helper(obj1);
21653 if (arg2 == NULL) SWIG_fail;
21654 temp2 = true;
21655 }
21656 {
21657 PyThreadState* __tstate = wxPyBeginAllowThreads();
21658 (arg1)->SetText((wxString const &)*arg2);
21659
21660 wxPyEndAllowThreads(__tstate);
21661 if (PyErr_Occurred()) SWIG_fail;
21662 }
21663 Py_INCREF(Py_None); resultobj = Py_None;
21664 {
21665 if (temp2)
21666 delete arg2;
21667 }
21668 return resultobj;
21669 fail:
21670 {
21671 if (temp2)
21672 delete arg2;
21673 }
21674 return NULL;
21675 }
21676
21677
21678 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj;
21680 long arg1 ;
21681 PyObject * obj0 = 0 ;
21682 char *kwnames[] = {
21683 (char *) "updateInterval", NULL
21684 };
21685
21686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21687 {
21688 arg1 = (long)(SWIG_As_long(obj0));
21689 if (SWIG_arg_fail(1)) SWIG_fail;
21690 }
21691 {
21692 PyThreadState* __tstate = wxPyBeginAllowThreads();
21693 wxUpdateUIEvent::SetUpdateInterval(arg1);
21694
21695 wxPyEndAllowThreads(__tstate);
21696 if (PyErr_Occurred()) SWIG_fail;
21697 }
21698 Py_INCREF(Py_None); resultobj = Py_None;
21699 return resultobj;
21700 fail:
21701 return NULL;
21702 }
21703
21704
21705 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21706 PyObject *resultobj;
21707 long result;
21708 char *kwnames[] = {
21709 NULL
21710 };
21711
21712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21713 {
21714 PyThreadState* __tstate = wxPyBeginAllowThreads();
21715 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21716
21717 wxPyEndAllowThreads(__tstate);
21718 if (PyErr_Occurred()) SWIG_fail;
21719 }
21720 {
21721 resultobj = SWIG_From_long((long)(result));
21722 }
21723 return resultobj;
21724 fail:
21725 return NULL;
21726 }
21727
21728
21729 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21730 PyObject *resultobj;
21731 wxWindow *arg1 = (wxWindow *) 0 ;
21732 bool result;
21733 PyObject * obj0 = 0 ;
21734 char *kwnames[] = {
21735 (char *) "win", NULL
21736 };
21737
21738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21740 if (SWIG_arg_fail(1)) SWIG_fail;
21741 {
21742 PyThreadState* __tstate = wxPyBeginAllowThreads();
21743 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21744
21745 wxPyEndAllowThreads(__tstate);
21746 if (PyErr_Occurred()) SWIG_fail;
21747 }
21748 {
21749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21750 }
21751 return resultobj;
21752 fail:
21753 return NULL;
21754 }
21755
21756
21757 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21758 PyObject *resultobj;
21759 char *kwnames[] = {
21760 NULL
21761 };
21762
21763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 wxUpdateUIEvent::ResetUpdateTime();
21767
21768 wxPyEndAllowThreads(__tstate);
21769 if (PyErr_Occurred()) SWIG_fail;
21770 }
21771 Py_INCREF(Py_None); resultobj = Py_None;
21772 return resultobj;
21773 fail:
21774 return NULL;
21775 }
21776
21777
21778 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21779 PyObject *resultobj;
21780 wxUpdateUIMode arg1 ;
21781 PyObject * obj0 = 0 ;
21782 char *kwnames[] = {
21783 (char *) "mode", NULL
21784 };
21785
21786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21787 {
21788 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21789 if (SWIG_arg_fail(1)) SWIG_fail;
21790 }
21791 {
21792 PyThreadState* __tstate = wxPyBeginAllowThreads();
21793 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21794
21795 wxPyEndAllowThreads(__tstate);
21796 if (PyErr_Occurred()) SWIG_fail;
21797 }
21798 Py_INCREF(Py_None); resultobj = Py_None;
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21806 PyObject *resultobj;
21807 wxUpdateUIMode result;
21808 char *kwnames[] = {
21809 NULL
21810 };
21811
21812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21813 {
21814 PyThreadState* __tstate = wxPyBeginAllowThreads();
21815 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21816
21817 wxPyEndAllowThreads(__tstate);
21818 if (PyErr_Occurred()) SWIG_fail;
21819 }
21820 resultobj = SWIG_From_int((result));
21821 return resultobj;
21822 fail:
21823 return NULL;
21824 }
21825
21826
21827 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21828 PyObject *obj;
21829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21830 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21831 Py_INCREF(obj);
21832 return Py_BuildValue((char *)"");
21833 }
21834 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21835 PyObject *resultobj;
21836 wxSysColourChangedEvent *result;
21837 char *kwnames[] = {
21838 NULL
21839 };
21840
21841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21842 {
21843 PyThreadState* __tstate = wxPyBeginAllowThreads();
21844 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21845
21846 wxPyEndAllowThreads(__tstate);
21847 if (PyErr_Occurred()) SWIG_fail;
21848 }
21849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21850 return resultobj;
21851 fail:
21852 return NULL;
21853 }
21854
21855
21856 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21857 PyObject *obj;
21858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21859 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21860 Py_INCREF(obj);
21861 return Py_BuildValue((char *)"");
21862 }
21863 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21864 PyObject *resultobj;
21865 int arg1 = (int) 0 ;
21866 wxWindow *arg2 = (wxWindow *) NULL ;
21867 wxMouseCaptureChangedEvent *result;
21868 PyObject * obj0 = 0 ;
21869 PyObject * obj1 = 0 ;
21870 char *kwnames[] = {
21871 (char *) "winid",(char *) "gainedCapture", NULL
21872 };
21873
21874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21875 if (obj0) {
21876 {
21877 arg1 = (int)(SWIG_As_int(obj0));
21878 if (SWIG_arg_fail(1)) SWIG_fail;
21879 }
21880 }
21881 if (obj1) {
21882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21883 if (SWIG_arg_fail(2)) SWIG_fail;
21884 }
21885 {
21886 PyThreadState* __tstate = wxPyBeginAllowThreads();
21887 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21888
21889 wxPyEndAllowThreads(__tstate);
21890 if (PyErr_Occurred()) SWIG_fail;
21891 }
21892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21893 return resultobj;
21894 fail:
21895 return NULL;
21896 }
21897
21898
21899 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21900 PyObject *resultobj;
21901 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21902 wxWindow *result;
21903 PyObject * obj0 = 0 ;
21904 char *kwnames[] = {
21905 (char *) "self", NULL
21906 };
21907
21908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21910 if (SWIG_arg_fail(1)) SWIG_fail;
21911 {
21912 PyThreadState* __tstate = wxPyBeginAllowThreads();
21913 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21914
21915 wxPyEndAllowThreads(__tstate);
21916 if (PyErr_Occurred()) SWIG_fail;
21917 }
21918 {
21919 resultobj = wxPyMake_wxObject(result, 0);
21920 }
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21928 PyObject *obj;
21929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21930 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21931 Py_INCREF(obj);
21932 return Py_BuildValue((char *)"");
21933 }
21934 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21935 PyObject *resultobj;
21936 wxDisplayChangedEvent *result;
21937 char *kwnames[] = {
21938 NULL
21939 };
21940
21941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21945
21946 wxPyEndAllowThreads(__tstate);
21947 if (PyErr_Occurred()) SWIG_fail;
21948 }
21949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21950 return resultobj;
21951 fail:
21952 return NULL;
21953 }
21954
21955
21956 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21957 PyObject *obj;
21958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21959 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21960 Py_INCREF(obj);
21961 return Py_BuildValue((char *)"");
21962 }
21963 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21964 PyObject *resultobj;
21965 int arg1 = (int) 0 ;
21966 wxPaletteChangedEvent *result;
21967 PyObject * obj0 = 0 ;
21968 char *kwnames[] = {
21969 (char *) "id", NULL
21970 };
21971
21972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21973 if (obj0) {
21974 {
21975 arg1 = (int)(SWIG_As_int(obj0));
21976 if (SWIG_arg_fail(1)) SWIG_fail;
21977 }
21978 }
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21982
21983 wxPyEndAllowThreads(__tstate);
21984 if (PyErr_Occurred()) SWIG_fail;
21985 }
21986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21987 return resultobj;
21988 fail:
21989 return NULL;
21990 }
21991
21992
21993 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21994 PyObject *resultobj;
21995 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21996 wxWindow *arg2 = (wxWindow *) 0 ;
21997 PyObject * obj0 = 0 ;
21998 PyObject * obj1 = 0 ;
21999 char *kwnames[] = {
22000 (char *) "self",(char *) "win", NULL
22001 };
22002
22003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22005 if (SWIG_arg_fail(1)) SWIG_fail;
22006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22007 if (SWIG_arg_fail(2)) SWIG_fail;
22008 {
22009 PyThreadState* __tstate = wxPyBeginAllowThreads();
22010 (arg1)->SetChangedWindow(arg2);
22011
22012 wxPyEndAllowThreads(__tstate);
22013 if (PyErr_Occurred()) SWIG_fail;
22014 }
22015 Py_INCREF(Py_None); resultobj = Py_None;
22016 return resultobj;
22017 fail:
22018 return NULL;
22019 }
22020
22021
22022 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22023 PyObject *resultobj;
22024 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22025 wxWindow *result;
22026 PyObject * obj0 = 0 ;
22027 char *kwnames[] = {
22028 (char *) "self", NULL
22029 };
22030
22031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22033 if (SWIG_arg_fail(1)) SWIG_fail;
22034 {
22035 PyThreadState* __tstate = wxPyBeginAllowThreads();
22036 result = (wxWindow *)(arg1)->GetChangedWindow();
22037
22038 wxPyEndAllowThreads(__tstate);
22039 if (PyErr_Occurred()) SWIG_fail;
22040 }
22041 {
22042 resultobj = wxPyMake_wxObject(result, 0);
22043 }
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22051 PyObject *obj;
22052 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22053 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22054 Py_INCREF(obj);
22055 return Py_BuildValue((char *)"");
22056 }
22057 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22058 PyObject *resultobj;
22059 int arg1 = (int) 0 ;
22060 wxQueryNewPaletteEvent *result;
22061 PyObject * obj0 = 0 ;
22062 char *kwnames[] = {
22063 (char *) "winid", NULL
22064 };
22065
22066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22067 if (obj0) {
22068 {
22069 arg1 = (int)(SWIG_As_int(obj0));
22070 if (SWIG_arg_fail(1)) SWIG_fail;
22071 }
22072 }
22073 {
22074 PyThreadState* __tstate = wxPyBeginAllowThreads();
22075 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22076
22077 wxPyEndAllowThreads(__tstate);
22078 if (PyErr_Occurred()) SWIG_fail;
22079 }
22080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22081 return resultobj;
22082 fail:
22083 return NULL;
22084 }
22085
22086
22087 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22088 PyObject *resultobj;
22089 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22090 bool arg2 ;
22091 PyObject * obj0 = 0 ;
22092 PyObject * obj1 = 0 ;
22093 char *kwnames[] = {
22094 (char *) "self",(char *) "realized", NULL
22095 };
22096
22097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22099 if (SWIG_arg_fail(1)) SWIG_fail;
22100 {
22101 arg2 = (bool)(SWIG_As_bool(obj1));
22102 if (SWIG_arg_fail(2)) SWIG_fail;
22103 }
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 (arg1)->SetPaletteRealized(arg2);
22107
22108 wxPyEndAllowThreads(__tstate);
22109 if (PyErr_Occurred()) SWIG_fail;
22110 }
22111 Py_INCREF(Py_None); resultobj = Py_None;
22112 return resultobj;
22113 fail:
22114 return NULL;
22115 }
22116
22117
22118 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22119 PyObject *resultobj;
22120 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22121 bool result;
22122 PyObject * obj0 = 0 ;
22123 char *kwnames[] = {
22124 (char *) "self", NULL
22125 };
22126
22127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22129 if (SWIG_arg_fail(1)) SWIG_fail;
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22133
22134 wxPyEndAllowThreads(__tstate);
22135 if (PyErr_Occurred()) SWIG_fail;
22136 }
22137 {
22138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22139 }
22140 return resultobj;
22141 fail:
22142 return NULL;
22143 }
22144
22145
22146 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22147 PyObject *obj;
22148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22149 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22150 Py_INCREF(obj);
22151 return Py_BuildValue((char *)"");
22152 }
22153 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22154 PyObject *resultobj;
22155 wxNavigationKeyEvent *result;
22156 char *kwnames[] = {
22157 NULL
22158 };
22159
22160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22161 {
22162 PyThreadState* __tstate = wxPyBeginAllowThreads();
22163 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22164
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22169 return resultobj;
22170 fail:
22171 return NULL;
22172 }
22173
22174
22175 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22176 PyObject *resultobj;
22177 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22178 bool result;
22179 PyObject * obj0 = 0 ;
22180 char *kwnames[] = {
22181 (char *) "self", NULL
22182 };
22183
22184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22186 if (SWIG_arg_fail(1)) SWIG_fail;
22187 {
22188 PyThreadState* __tstate = wxPyBeginAllowThreads();
22189 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22190
22191 wxPyEndAllowThreads(__tstate);
22192 if (PyErr_Occurred()) SWIG_fail;
22193 }
22194 {
22195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22196 }
22197 return resultobj;
22198 fail:
22199 return NULL;
22200 }
22201
22202
22203 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22204 PyObject *resultobj;
22205 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22206 bool arg2 ;
22207 PyObject * obj0 = 0 ;
22208 PyObject * obj1 = 0 ;
22209 char *kwnames[] = {
22210 (char *) "self",(char *) "forward", NULL
22211 };
22212
22213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22215 if (SWIG_arg_fail(1)) SWIG_fail;
22216 {
22217 arg2 = (bool)(SWIG_As_bool(obj1));
22218 if (SWIG_arg_fail(2)) SWIG_fail;
22219 }
22220 {
22221 PyThreadState* __tstate = wxPyBeginAllowThreads();
22222 (arg1)->SetDirection(arg2);
22223
22224 wxPyEndAllowThreads(__tstate);
22225 if (PyErr_Occurred()) SWIG_fail;
22226 }
22227 Py_INCREF(Py_None); resultobj = Py_None;
22228 return resultobj;
22229 fail:
22230 return NULL;
22231 }
22232
22233
22234 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22235 PyObject *resultobj;
22236 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22237 bool result;
22238 PyObject * obj0 = 0 ;
22239 char *kwnames[] = {
22240 (char *) "self", NULL
22241 };
22242
22243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22245 if (SWIG_arg_fail(1)) SWIG_fail;
22246 {
22247 PyThreadState* __tstate = wxPyBeginAllowThreads();
22248 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22249
22250 wxPyEndAllowThreads(__tstate);
22251 if (PyErr_Occurred()) SWIG_fail;
22252 }
22253 {
22254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22255 }
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22263 PyObject *resultobj;
22264 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22265 bool arg2 ;
22266 PyObject * obj0 = 0 ;
22267 PyObject * obj1 = 0 ;
22268 char *kwnames[] = {
22269 (char *) "self",(char *) "ischange", NULL
22270 };
22271
22272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22274 if (SWIG_arg_fail(1)) SWIG_fail;
22275 {
22276 arg2 = (bool)(SWIG_As_bool(obj1));
22277 if (SWIG_arg_fail(2)) SWIG_fail;
22278 }
22279 {
22280 PyThreadState* __tstate = wxPyBeginAllowThreads();
22281 (arg1)->SetWindowChange(arg2);
22282
22283 wxPyEndAllowThreads(__tstate);
22284 if (PyErr_Occurred()) SWIG_fail;
22285 }
22286 Py_INCREF(Py_None); resultobj = Py_None;
22287 return resultobj;
22288 fail:
22289 return NULL;
22290 }
22291
22292
22293 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22294 PyObject *resultobj;
22295 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22296 bool result;
22297 PyObject * obj0 = 0 ;
22298 char *kwnames[] = {
22299 (char *) "self", NULL
22300 };
22301
22302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22304 if (SWIG_arg_fail(1)) SWIG_fail;
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22308
22309 wxPyEndAllowThreads(__tstate);
22310 if (PyErr_Occurred()) SWIG_fail;
22311 }
22312 {
22313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22314 }
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22322 PyObject *resultobj;
22323 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22324 bool arg2 ;
22325 PyObject * obj0 = 0 ;
22326 PyObject * obj1 = 0 ;
22327 char *kwnames[] = {
22328 (char *) "self",(char *) "bIs", NULL
22329 };
22330
22331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22333 if (SWIG_arg_fail(1)) SWIG_fail;
22334 {
22335 arg2 = (bool)(SWIG_As_bool(obj1));
22336 if (SWIG_arg_fail(2)) SWIG_fail;
22337 }
22338 {
22339 PyThreadState* __tstate = wxPyBeginAllowThreads();
22340 (arg1)->SetFromTab(arg2);
22341
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 Py_INCREF(Py_None); resultobj = Py_None;
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22355 long arg2 ;
22356 PyObject * obj0 = 0 ;
22357 PyObject * obj1 = 0 ;
22358 char *kwnames[] = {
22359 (char *) "self",(char *) "flags", NULL
22360 };
22361
22362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22364 if (SWIG_arg_fail(1)) SWIG_fail;
22365 {
22366 arg2 = (long)(SWIG_As_long(obj1));
22367 if (SWIG_arg_fail(2)) SWIG_fail;
22368 }
22369 {
22370 PyThreadState* __tstate = wxPyBeginAllowThreads();
22371 (arg1)->SetFlags(arg2);
22372
22373 wxPyEndAllowThreads(__tstate);
22374 if (PyErr_Occurred()) SWIG_fail;
22375 }
22376 Py_INCREF(Py_None); resultobj = Py_None;
22377 return resultobj;
22378 fail:
22379 return NULL;
22380 }
22381
22382
22383 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22384 PyObject *resultobj;
22385 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22386 wxWindow *result;
22387 PyObject * obj0 = 0 ;
22388 char *kwnames[] = {
22389 (char *) "self", NULL
22390 };
22391
22392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22394 if (SWIG_arg_fail(1)) SWIG_fail;
22395 {
22396 PyThreadState* __tstate = wxPyBeginAllowThreads();
22397 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22398
22399 wxPyEndAllowThreads(__tstate);
22400 if (PyErr_Occurred()) SWIG_fail;
22401 }
22402 {
22403 resultobj = wxPyMake_wxObject(result, 0);
22404 }
22405 return resultobj;
22406 fail:
22407 return NULL;
22408 }
22409
22410
22411 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22412 PyObject *resultobj;
22413 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22414 wxWindow *arg2 = (wxWindow *) 0 ;
22415 PyObject * obj0 = 0 ;
22416 PyObject * obj1 = 0 ;
22417 char *kwnames[] = {
22418 (char *) "self",(char *) "win", NULL
22419 };
22420
22421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22423 if (SWIG_arg_fail(1)) SWIG_fail;
22424 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22425 if (SWIG_arg_fail(2)) SWIG_fail;
22426 {
22427 PyThreadState* __tstate = wxPyBeginAllowThreads();
22428 (arg1)->SetCurrentFocus(arg2);
22429
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 Py_INCREF(Py_None); resultobj = Py_None;
22434 return resultobj;
22435 fail:
22436 return NULL;
22437 }
22438
22439
22440 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22441 PyObject *obj;
22442 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22443 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22444 Py_INCREF(obj);
22445 return Py_BuildValue((char *)"");
22446 }
22447 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22448 PyObject *resultobj;
22449 wxWindow *arg1 = (wxWindow *) NULL ;
22450 wxWindowCreateEvent *result;
22451 PyObject * obj0 = 0 ;
22452 char *kwnames[] = {
22453 (char *) "win", NULL
22454 };
22455
22456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22457 if (obj0) {
22458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22459 if (SWIG_arg_fail(1)) SWIG_fail;
22460 }
22461 {
22462 PyThreadState* __tstate = wxPyBeginAllowThreads();
22463 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22464
22465 wxPyEndAllowThreads(__tstate);
22466 if (PyErr_Occurred()) SWIG_fail;
22467 }
22468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22469 return resultobj;
22470 fail:
22471 return NULL;
22472 }
22473
22474
22475 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22476 PyObject *resultobj;
22477 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22478 wxWindow *result;
22479 PyObject * obj0 = 0 ;
22480 char *kwnames[] = {
22481 (char *) "self", NULL
22482 };
22483
22484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22486 if (SWIG_arg_fail(1)) SWIG_fail;
22487 {
22488 PyThreadState* __tstate = wxPyBeginAllowThreads();
22489 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22490
22491 wxPyEndAllowThreads(__tstate);
22492 if (PyErr_Occurred()) SWIG_fail;
22493 }
22494 {
22495 resultobj = wxPyMake_wxObject(result, 0);
22496 }
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22504 PyObject *obj;
22505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22506 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22507 Py_INCREF(obj);
22508 return Py_BuildValue((char *)"");
22509 }
22510 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22511 PyObject *resultobj;
22512 wxWindow *arg1 = (wxWindow *) NULL ;
22513 wxWindowDestroyEvent *result;
22514 PyObject * obj0 = 0 ;
22515 char *kwnames[] = {
22516 (char *) "win", NULL
22517 };
22518
22519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22520 if (obj0) {
22521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22522 if (SWIG_arg_fail(1)) SWIG_fail;
22523 }
22524 {
22525 PyThreadState* __tstate = wxPyBeginAllowThreads();
22526 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22527
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22532 return resultobj;
22533 fail:
22534 return NULL;
22535 }
22536
22537
22538 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22539 PyObject *resultobj;
22540 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22541 wxWindow *result;
22542 PyObject * obj0 = 0 ;
22543 char *kwnames[] = {
22544 (char *) "self", NULL
22545 };
22546
22547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22549 if (SWIG_arg_fail(1)) SWIG_fail;
22550 {
22551 PyThreadState* __tstate = wxPyBeginAllowThreads();
22552 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22553
22554 wxPyEndAllowThreads(__tstate);
22555 if (PyErr_Occurred()) SWIG_fail;
22556 }
22557 {
22558 resultobj = wxPyMake_wxObject(result, 0);
22559 }
22560 return resultobj;
22561 fail:
22562 return NULL;
22563 }
22564
22565
22566 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22567 PyObject *obj;
22568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22569 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22570 Py_INCREF(obj);
22571 return Py_BuildValue((char *)"");
22572 }
22573 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22574 PyObject *resultobj;
22575 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22576 int arg2 = (int) 0 ;
22577 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22578 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22579 wxContextMenuEvent *result;
22580 wxPoint temp3 ;
22581 PyObject * obj0 = 0 ;
22582 PyObject * obj1 = 0 ;
22583 PyObject * obj2 = 0 ;
22584 char *kwnames[] = {
22585 (char *) "type",(char *) "winid",(char *) "pt", NULL
22586 };
22587
22588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22589 if (obj0) {
22590 {
22591 arg1 = (wxEventType)(SWIG_As_int(obj0));
22592 if (SWIG_arg_fail(1)) SWIG_fail;
22593 }
22594 }
22595 if (obj1) {
22596 {
22597 arg2 = (int)(SWIG_As_int(obj1));
22598 if (SWIG_arg_fail(2)) SWIG_fail;
22599 }
22600 }
22601 if (obj2) {
22602 {
22603 arg3 = &temp3;
22604 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22605 }
22606 }
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22610
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22622 PyObject *resultobj;
22623 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22624 wxPoint *result;
22625 PyObject * obj0 = 0 ;
22626 char *kwnames[] = {
22627 (char *) "self", NULL
22628 };
22629
22630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22632 if (SWIG_arg_fail(1)) SWIG_fail;
22633 {
22634 PyThreadState* __tstate = wxPyBeginAllowThreads();
22635 {
22636 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22637 result = (wxPoint *) &_result_ref;
22638 }
22639
22640 wxPyEndAllowThreads(__tstate);
22641 if (PyErr_Occurred()) SWIG_fail;
22642 }
22643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22651 PyObject *resultobj;
22652 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22653 wxPoint *arg2 = 0 ;
22654 wxPoint temp2 ;
22655 PyObject * obj0 = 0 ;
22656 PyObject * obj1 = 0 ;
22657 char *kwnames[] = {
22658 (char *) "self",(char *) "pos", NULL
22659 };
22660
22661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 {
22665 arg2 = &temp2;
22666 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22667 }
22668 {
22669 PyThreadState* __tstate = wxPyBeginAllowThreads();
22670 (arg1)->SetPosition((wxPoint const &)*arg2);
22671
22672 wxPyEndAllowThreads(__tstate);
22673 if (PyErr_Occurred()) SWIG_fail;
22674 }
22675 Py_INCREF(Py_None); resultobj = Py_None;
22676 return resultobj;
22677 fail:
22678 return NULL;
22679 }
22680
22681
22682 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22683 PyObject *obj;
22684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22685 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22686 Py_INCREF(obj);
22687 return Py_BuildValue((char *)"");
22688 }
22689 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22690 PyObject *resultobj;
22691 wxIdleEvent *result;
22692 char *kwnames[] = {
22693 NULL
22694 };
22695
22696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22697 {
22698 PyThreadState* __tstate = wxPyBeginAllowThreads();
22699 result = (wxIdleEvent *)new wxIdleEvent();
22700
22701 wxPyEndAllowThreads(__tstate);
22702 if (PyErr_Occurred()) SWIG_fail;
22703 }
22704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22705 return resultobj;
22706 fail:
22707 return NULL;
22708 }
22709
22710
22711 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22712 PyObject *resultobj;
22713 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22714 bool arg2 = (bool) true ;
22715 PyObject * obj0 = 0 ;
22716 PyObject * obj1 = 0 ;
22717 char *kwnames[] = {
22718 (char *) "self",(char *) "needMore", NULL
22719 };
22720
22721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22723 if (SWIG_arg_fail(1)) SWIG_fail;
22724 if (obj1) {
22725 {
22726 arg2 = (bool)(SWIG_As_bool(obj1));
22727 if (SWIG_arg_fail(2)) SWIG_fail;
22728 }
22729 }
22730 {
22731 PyThreadState* __tstate = wxPyBeginAllowThreads();
22732 (arg1)->RequestMore(arg2);
22733
22734 wxPyEndAllowThreads(__tstate);
22735 if (PyErr_Occurred()) SWIG_fail;
22736 }
22737 Py_INCREF(Py_None); resultobj = Py_None;
22738 return resultobj;
22739 fail:
22740 return NULL;
22741 }
22742
22743
22744 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22745 PyObject *resultobj;
22746 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22747 bool result;
22748 PyObject * obj0 = 0 ;
22749 char *kwnames[] = {
22750 (char *) "self", NULL
22751 };
22752
22753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22755 if (SWIG_arg_fail(1)) SWIG_fail;
22756 {
22757 PyThreadState* __tstate = wxPyBeginAllowThreads();
22758 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22759
22760 wxPyEndAllowThreads(__tstate);
22761 if (PyErr_Occurred()) SWIG_fail;
22762 }
22763 {
22764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22765 }
22766 return resultobj;
22767 fail:
22768 return NULL;
22769 }
22770
22771
22772 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22773 PyObject *resultobj;
22774 wxIdleMode arg1 ;
22775 PyObject * obj0 = 0 ;
22776 char *kwnames[] = {
22777 (char *) "mode", NULL
22778 };
22779
22780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22781 {
22782 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22783 if (SWIG_arg_fail(1)) SWIG_fail;
22784 }
22785 {
22786 PyThreadState* __tstate = wxPyBeginAllowThreads();
22787 wxIdleEvent::SetMode((wxIdleMode )arg1);
22788
22789 wxPyEndAllowThreads(__tstate);
22790 if (PyErr_Occurred()) SWIG_fail;
22791 }
22792 Py_INCREF(Py_None); resultobj = Py_None;
22793 return resultobj;
22794 fail:
22795 return NULL;
22796 }
22797
22798
22799 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22800 PyObject *resultobj;
22801 wxIdleMode result;
22802 char *kwnames[] = {
22803 NULL
22804 };
22805
22806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22807 {
22808 PyThreadState* __tstate = wxPyBeginAllowThreads();
22809 result = (wxIdleMode)wxIdleEvent::GetMode();
22810
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 resultobj = SWIG_From_int((result));
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22822 PyObject *resultobj;
22823 wxWindow *arg1 = (wxWindow *) 0 ;
22824 bool result;
22825 PyObject * obj0 = 0 ;
22826 char *kwnames[] = {
22827 (char *) "win", NULL
22828 };
22829
22830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22832 if (SWIG_arg_fail(1)) SWIG_fail;
22833 {
22834 PyThreadState* __tstate = wxPyBeginAllowThreads();
22835 result = (bool)wxIdleEvent::CanSend(arg1);
22836
22837 wxPyEndAllowThreads(__tstate);
22838 if (PyErr_Occurred()) SWIG_fail;
22839 }
22840 {
22841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22842 }
22843 return resultobj;
22844 fail:
22845 return NULL;
22846 }
22847
22848
22849 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22850 PyObject *obj;
22851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22852 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22853 Py_INCREF(obj);
22854 return Py_BuildValue((char *)"");
22855 }
22856 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22857 PyObject *resultobj;
22858 int arg1 = (int) 0 ;
22859 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22860 wxPyEvent *result;
22861 PyObject * obj0 = 0 ;
22862 PyObject * obj1 = 0 ;
22863 char *kwnames[] = {
22864 (char *) "winid",(char *) "eventType", NULL
22865 };
22866
22867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22868 if (obj0) {
22869 {
22870 arg1 = (int)(SWIG_As_int(obj0));
22871 if (SWIG_arg_fail(1)) SWIG_fail;
22872 }
22873 }
22874 if (obj1) {
22875 {
22876 arg2 = (wxEventType)(SWIG_As_int(obj1));
22877 if (SWIG_arg_fail(2)) SWIG_fail;
22878 }
22879 }
22880 {
22881 PyThreadState* __tstate = wxPyBeginAllowThreads();
22882 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22883
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22888 return resultobj;
22889 fail:
22890 return NULL;
22891 }
22892
22893
22894 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22895 PyObject *resultobj;
22896 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22897 PyObject * obj0 = 0 ;
22898 char *kwnames[] = {
22899 (char *) "self", NULL
22900 };
22901
22902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22904 if (SWIG_arg_fail(1)) SWIG_fail;
22905 {
22906 PyThreadState* __tstate = wxPyBeginAllowThreads();
22907 delete arg1;
22908
22909 wxPyEndAllowThreads(__tstate);
22910 if (PyErr_Occurred()) SWIG_fail;
22911 }
22912 Py_INCREF(Py_None); resultobj = Py_None;
22913 return resultobj;
22914 fail:
22915 return NULL;
22916 }
22917
22918
22919 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22920 PyObject *resultobj;
22921 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22922 PyObject *arg2 = (PyObject *) 0 ;
22923 PyObject * obj0 = 0 ;
22924 PyObject * obj1 = 0 ;
22925 char *kwnames[] = {
22926 (char *) "self",(char *) "self", NULL
22927 };
22928
22929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22931 if (SWIG_arg_fail(1)) SWIG_fail;
22932 arg2 = obj1;
22933 {
22934 PyThreadState* __tstate = wxPyBeginAllowThreads();
22935 (arg1)->SetSelf(arg2);
22936
22937 wxPyEndAllowThreads(__tstate);
22938 if (PyErr_Occurred()) SWIG_fail;
22939 }
22940 Py_INCREF(Py_None); resultobj = Py_None;
22941 return resultobj;
22942 fail:
22943 return NULL;
22944 }
22945
22946
22947 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22948 PyObject *resultobj;
22949 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22950 PyObject *result;
22951 PyObject * obj0 = 0 ;
22952 char *kwnames[] = {
22953 (char *) "self", NULL
22954 };
22955
22956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22958 if (SWIG_arg_fail(1)) SWIG_fail;
22959 {
22960 PyThreadState* __tstate = wxPyBeginAllowThreads();
22961 result = (PyObject *)(arg1)->GetSelf();
22962
22963 wxPyEndAllowThreads(__tstate);
22964 if (PyErr_Occurred()) SWIG_fail;
22965 }
22966 resultobj = result;
22967 return resultobj;
22968 fail:
22969 return NULL;
22970 }
22971
22972
22973 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22974 PyObject *obj;
22975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22976 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22977 Py_INCREF(obj);
22978 return Py_BuildValue((char *)"");
22979 }
22980 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22981 PyObject *resultobj;
22982 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22983 int arg2 = (int) 0 ;
22984 wxPyCommandEvent *result;
22985 PyObject * obj0 = 0 ;
22986 PyObject * obj1 = 0 ;
22987 char *kwnames[] = {
22988 (char *) "eventType",(char *) "id", NULL
22989 };
22990
22991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22992 if (obj0) {
22993 {
22994 arg1 = (wxEventType)(SWIG_As_int(obj0));
22995 if (SWIG_arg_fail(1)) SWIG_fail;
22996 }
22997 }
22998 if (obj1) {
22999 {
23000 arg2 = (int)(SWIG_As_int(obj1));
23001 if (SWIG_arg_fail(2)) SWIG_fail;
23002 }
23003 }
23004 {
23005 PyThreadState* __tstate = wxPyBeginAllowThreads();
23006 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23007
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23012 return resultobj;
23013 fail:
23014 return NULL;
23015 }
23016
23017
23018 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23019 PyObject *resultobj;
23020 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23021 PyObject * obj0 = 0 ;
23022 char *kwnames[] = {
23023 (char *) "self", NULL
23024 };
23025
23026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23028 if (SWIG_arg_fail(1)) SWIG_fail;
23029 {
23030 PyThreadState* __tstate = wxPyBeginAllowThreads();
23031 delete arg1;
23032
23033 wxPyEndAllowThreads(__tstate);
23034 if (PyErr_Occurred()) SWIG_fail;
23035 }
23036 Py_INCREF(Py_None); resultobj = Py_None;
23037 return resultobj;
23038 fail:
23039 return NULL;
23040 }
23041
23042
23043 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23044 PyObject *resultobj;
23045 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23046 PyObject *arg2 = (PyObject *) 0 ;
23047 PyObject * obj0 = 0 ;
23048 PyObject * obj1 = 0 ;
23049 char *kwnames[] = {
23050 (char *) "self",(char *) "self", NULL
23051 };
23052
23053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23055 if (SWIG_arg_fail(1)) SWIG_fail;
23056 arg2 = obj1;
23057 {
23058 PyThreadState* __tstate = wxPyBeginAllowThreads();
23059 (arg1)->SetSelf(arg2);
23060
23061 wxPyEndAllowThreads(__tstate);
23062 if (PyErr_Occurred()) SWIG_fail;
23063 }
23064 Py_INCREF(Py_None); resultobj = Py_None;
23065 return resultobj;
23066 fail:
23067 return NULL;
23068 }
23069
23070
23071 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23072 PyObject *resultobj;
23073 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23074 PyObject *result;
23075 PyObject * obj0 = 0 ;
23076 char *kwnames[] = {
23077 (char *) "self", NULL
23078 };
23079
23080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23082 if (SWIG_arg_fail(1)) SWIG_fail;
23083 {
23084 PyThreadState* __tstate = wxPyBeginAllowThreads();
23085 result = (PyObject *)(arg1)->GetSelf();
23086
23087 wxPyEndAllowThreads(__tstate);
23088 if (PyErr_Occurred()) SWIG_fail;
23089 }
23090 resultobj = result;
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23098 PyObject *obj;
23099 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23100 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23101 Py_INCREF(obj);
23102 return Py_BuildValue((char *)"");
23103 }
23104 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23105 PyObject *resultobj;
23106 wxWindow *arg1 = (wxWindow *) 0 ;
23107 wxDateTime *arg2 = 0 ;
23108 wxEventType arg3 ;
23109 wxDateEvent *result;
23110 PyObject * obj0 = 0 ;
23111 PyObject * obj1 = 0 ;
23112 PyObject * obj2 = 0 ;
23113 char *kwnames[] = {
23114 (char *) "win",(char *) "dt",(char *) "type", NULL
23115 };
23116
23117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23119 if (SWIG_arg_fail(1)) SWIG_fail;
23120 {
23121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23122 if (SWIG_arg_fail(2)) SWIG_fail;
23123 if (arg2 == NULL) {
23124 SWIG_null_ref("wxDateTime");
23125 }
23126 if (SWIG_arg_fail(2)) SWIG_fail;
23127 }
23128 {
23129 arg3 = (wxEventType)(SWIG_As_int(obj2));
23130 if (SWIG_arg_fail(3)) SWIG_fail;
23131 }
23132 {
23133 PyThreadState* __tstate = wxPyBeginAllowThreads();
23134 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23135
23136 wxPyEndAllowThreads(__tstate);
23137 if (PyErr_Occurred()) SWIG_fail;
23138 }
23139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23140 return resultobj;
23141 fail:
23142 return NULL;
23143 }
23144
23145
23146 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23147 PyObject *resultobj;
23148 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23149 wxDateTime *result;
23150 PyObject * obj0 = 0 ;
23151 char *kwnames[] = {
23152 (char *) "self", NULL
23153 };
23154
23155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23157 if (SWIG_arg_fail(1)) SWIG_fail;
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 {
23161 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23162 result = (wxDateTime *) &_result_ref;
23163 }
23164
23165 wxPyEndAllowThreads(__tstate);
23166 if (PyErr_Occurred()) SWIG_fail;
23167 }
23168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23169 return resultobj;
23170 fail:
23171 return NULL;
23172 }
23173
23174
23175 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23176 PyObject *resultobj;
23177 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23178 wxDateTime *arg2 = 0 ;
23179 PyObject * obj0 = 0 ;
23180 PyObject * obj1 = 0 ;
23181 char *kwnames[] = {
23182 (char *) "self",(char *) "date", NULL
23183 };
23184
23185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23187 if (SWIG_arg_fail(1)) SWIG_fail;
23188 {
23189 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23190 if (SWIG_arg_fail(2)) SWIG_fail;
23191 if (arg2 == NULL) {
23192 SWIG_null_ref("wxDateTime");
23193 }
23194 if (SWIG_arg_fail(2)) SWIG_fail;
23195 }
23196 {
23197 PyThreadState* __tstate = wxPyBeginAllowThreads();
23198 (arg1)->SetDate((wxDateTime const &)*arg2);
23199
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 Py_INCREF(Py_None); resultobj = Py_None;
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23211 PyObject *obj;
23212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23213 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23214 Py_INCREF(obj);
23215 return Py_BuildValue((char *)"");
23216 }
23217 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23218 PyObject *resultobj;
23219 wxPyApp *result;
23220 char *kwnames[] = {
23221 NULL
23222 };
23223
23224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23225 {
23226 PyThreadState* __tstate = wxPyBeginAllowThreads();
23227 result = (wxPyApp *)new_wxPyApp();
23228
23229 wxPyEndAllowThreads(__tstate);
23230 if (PyErr_Occurred()) SWIG_fail;
23231 }
23232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23233 return resultobj;
23234 fail:
23235 return NULL;
23236 }
23237
23238
23239 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23240 PyObject *resultobj;
23241 wxPyApp *arg1 = (wxPyApp *) 0 ;
23242 PyObject * obj0 = 0 ;
23243 char *kwnames[] = {
23244 (char *) "self", NULL
23245 };
23246
23247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23249 if (SWIG_arg_fail(1)) SWIG_fail;
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 delete arg1;
23253
23254 wxPyEndAllowThreads(__tstate);
23255 if (PyErr_Occurred()) SWIG_fail;
23256 }
23257 Py_INCREF(Py_None); resultobj = Py_None;
23258 return resultobj;
23259 fail:
23260 return NULL;
23261 }
23262
23263
23264 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23265 PyObject *resultobj;
23266 wxPyApp *arg1 = (wxPyApp *) 0 ;
23267 PyObject *arg2 = (PyObject *) 0 ;
23268 PyObject *arg3 = (PyObject *) 0 ;
23269 bool arg4 ;
23270 PyObject * obj0 = 0 ;
23271 PyObject * obj1 = 0 ;
23272 PyObject * obj2 = 0 ;
23273 PyObject * obj3 = 0 ;
23274 char *kwnames[] = {
23275 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23276 };
23277
23278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23280 if (SWIG_arg_fail(1)) SWIG_fail;
23281 arg2 = obj1;
23282 arg3 = obj2;
23283 {
23284 arg4 = (bool)(SWIG_As_bool(obj3));
23285 if (SWIG_arg_fail(4)) SWIG_fail;
23286 }
23287 {
23288 PyThreadState* __tstate = wxPyBeginAllowThreads();
23289 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23290
23291 wxPyEndAllowThreads(__tstate);
23292 if (PyErr_Occurred()) SWIG_fail;
23293 }
23294 Py_INCREF(Py_None); resultobj = Py_None;
23295 return resultobj;
23296 fail:
23297 return NULL;
23298 }
23299
23300
23301 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23302 PyObject *resultobj;
23303 wxPyApp *arg1 = (wxPyApp *) 0 ;
23304 wxString result;
23305 PyObject * obj0 = 0 ;
23306 char *kwnames[] = {
23307 (char *) "self", NULL
23308 };
23309
23310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23312 if (SWIG_arg_fail(1)) SWIG_fail;
23313 {
23314 PyThreadState* __tstate = wxPyBeginAllowThreads();
23315 result = ((wxPyApp const *)arg1)->GetAppName();
23316
23317 wxPyEndAllowThreads(__tstate);
23318 if (PyErr_Occurred()) SWIG_fail;
23319 }
23320 {
23321 #if wxUSE_UNICODE
23322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23323 #else
23324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23325 #endif
23326 }
23327 return resultobj;
23328 fail:
23329 return NULL;
23330 }
23331
23332
23333 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23334 PyObject *resultobj;
23335 wxPyApp *arg1 = (wxPyApp *) 0 ;
23336 wxString *arg2 = 0 ;
23337 bool temp2 = false ;
23338 PyObject * obj0 = 0 ;
23339 PyObject * obj1 = 0 ;
23340 char *kwnames[] = {
23341 (char *) "self",(char *) "name", NULL
23342 };
23343
23344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23346 if (SWIG_arg_fail(1)) SWIG_fail;
23347 {
23348 arg2 = wxString_in_helper(obj1);
23349 if (arg2 == NULL) SWIG_fail;
23350 temp2 = true;
23351 }
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 (arg1)->SetAppName((wxString const &)*arg2);
23355
23356 wxPyEndAllowThreads(__tstate);
23357 if (PyErr_Occurred()) SWIG_fail;
23358 }
23359 Py_INCREF(Py_None); resultobj = Py_None;
23360 {
23361 if (temp2)
23362 delete arg2;
23363 }
23364 return resultobj;
23365 fail:
23366 {
23367 if (temp2)
23368 delete arg2;
23369 }
23370 return NULL;
23371 }
23372
23373
23374 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23375 PyObject *resultobj;
23376 wxPyApp *arg1 = (wxPyApp *) 0 ;
23377 wxString result;
23378 PyObject * obj0 = 0 ;
23379 char *kwnames[] = {
23380 (char *) "self", NULL
23381 };
23382
23383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23385 if (SWIG_arg_fail(1)) SWIG_fail;
23386 {
23387 PyThreadState* __tstate = wxPyBeginAllowThreads();
23388 result = ((wxPyApp const *)arg1)->GetClassName();
23389
23390 wxPyEndAllowThreads(__tstate);
23391 if (PyErr_Occurred()) SWIG_fail;
23392 }
23393 {
23394 #if wxUSE_UNICODE
23395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23396 #else
23397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23398 #endif
23399 }
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj;
23408 wxPyApp *arg1 = (wxPyApp *) 0 ;
23409 wxString *arg2 = 0 ;
23410 bool temp2 = false ;
23411 PyObject * obj0 = 0 ;
23412 PyObject * obj1 = 0 ;
23413 char *kwnames[] = {
23414 (char *) "self",(char *) "name", NULL
23415 };
23416
23417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23419 if (SWIG_arg_fail(1)) SWIG_fail;
23420 {
23421 arg2 = wxString_in_helper(obj1);
23422 if (arg2 == NULL) SWIG_fail;
23423 temp2 = true;
23424 }
23425 {
23426 PyThreadState* __tstate = wxPyBeginAllowThreads();
23427 (arg1)->SetClassName((wxString const &)*arg2);
23428
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 Py_INCREF(Py_None); resultobj = Py_None;
23433 {
23434 if (temp2)
23435 delete arg2;
23436 }
23437 return resultobj;
23438 fail:
23439 {
23440 if (temp2)
23441 delete arg2;
23442 }
23443 return NULL;
23444 }
23445
23446
23447 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23448 PyObject *resultobj;
23449 wxPyApp *arg1 = (wxPyApp *) 0 ;
23450 wxString *result;
23451 PyObject * obj0 = 0 ;
23452 char *kwnames[] = {
23453 (char *) "self", NULL
23454 };
23455
23456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23458 if (SWIG_arg_fail(1)) SWIG_fail;
23459 {
23460 PyThreadState* __tstate = wxPyBeginAllowThreads();
23461 {
23462 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23463 result = (wxString *) &_result_ref;
23464 }
23465
23466 wxPyEndAllowThreads(__tstate);
23467 if (PyErr_Occurred()) SWIG_fail;
23468 }
23469 {
23470 #if wxUSE_UNICODE
23471 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23472 #else
23473 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23474 #endif
23475 }
23476 return resultobj;
23477 fail:
23478 return NULL;
23479 }
23480
23481
23482 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23483 PyObject *resultobj;
23484 wxPyApp *arg1 = (wxPyApp *) 0 ;
23485 wxString *arg2 = 0 ;
23486 bool temp2 = false ;
23487 PyObject * obj0 = 0 ;
23488 PyObject * obj1 = 0 ;
23489 char *kwnames[] = {
23490 (char *) "self",(char *) "name", NULL
23491 };
23492
23493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23495 if (SWIG_arg_fail(1)) SWIG_fail;
23496 {
23497 arg2 = wxString_in_helper(obj1);
23498 if (arg2 == NULL) SWIG_fail;
23499 temp2 = true;
23500 }
23501 {
23502 PyThreadState* __tstate = wxPyBeginAllowThreads();
23503 (arg1)->SetVendorName((wxString const &)*arg2);
23504
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 Py_INCREF(Py_None); resultobj = Py_None;
23509 {
23510 if (temp2)
23511 delete arg2;
23512 }
23513 return resultobj;
23514 fail:
23515 {
23516 if (temp2)
23517 delete arg2;
23518 }
23519 return NULL;
23520 }
23521
23522
23523 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23524 PyObject *resultobj;
23525 wxPyApp *arg1 = (wxPyApp *) 0 ;
23526 wxAppTraits *result;
23527 PyObject * obj0 = 0 ;
23528 char *kwnames[] = {
23529 (char *) "self", NULL
23530 };
23531
23532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23534 if (SWIG_arg_fail(1)) SWIG_fail;
23535 {
23536 PyThreadState* __tstate = wxPyBeginAllowThreads();
23537 result = (wxAppTraits *)(arg1)->GetTraits();
23538
23539 wxPyEndAllowThreads(__tstate);
23540 if (PyErr_Occurred()) SWIG_fail;
23541 }
23542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23543 return resultobj;
23544 fail:
23545 return NULL;
23546 }
23547
23548
23549 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23550 PyObject *resultobj;
23551 wxPyApp *arg1 = (wxPyApp *) 0 ;
23552 PyObject * obj0 = 0 ;
23553 char *kwnames[] = {
23554 (char *) "self", NULL
23555 };
23556
23557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23559 if (SWIG_arg_fail(1)) SWIG_fail;
23560 {
23561 PyThreadState* __tstate = wxPyBeginAllowThreads();
23562 (arg1)->ProcessPendingEvents();
23563
23564 wxPyEndAllowThreads(__tstate);
23565 if (PyErr_Occurred()) SWIG_fail;
23566 }
23567 Py_INCREF(Py_None); resultobj = Py_None;
23568 return resultobj;
23569 fail:
23570 return NULL;
23571 }
23572
23573
23574 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23575 PyObject *resultobj;
23576 wxPyApp *arg1 = (wxPyApp *) 0 ;
23577 bool arg2 = (bool) false ;
23578 bool result;
23579 PyObject * obj0 = 0 ;
23580 PyObject * obj1 = 0 ;
23581 char *kwnames[] = {
23582 (char *) "self",(char *) "onlyIfNeeded", NULL
23583 };
23584
23585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23587 if (SWIG_arg_fail(1)) SWIG_fail;
23588 if (obj1) {
23589 {
23590 arg2 = (bool)(SWIG_As_bool(obj1));
23591 if (SWIG_arg_fail(2)) SWIG_fail;
23592 }
23593 }
23594 {
23595 PyThreadState* __tstate = wxPyBeginAllowThreads();
23596 result = (bool)(arg1)->Yield(arg2);
23597
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 {
23602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23603 }
23604 return resultobj;
23605 fail:
23606 return NULL;
23607 }
23608
23609
23610 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23611 PyObject *resultobj;
23612 wxPyApp *arg1 = (wxPyApp *) 0 ;
23613 PyObject * obj0 = 0 ;
23614 char *kwnames[] = {
23615 (char *) "self", NULL
23616 };
23617
23618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23620 if (SWIG_arg_fail(1)) SWIG_fail;
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 (arg1)->WakeUpIdle();
23624
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 Py_INCREF(Py_None); resultobj = Py_None;
23629 return resultobj;
23630 fail:
23631 return NULL;
23632 }
23633
23634
23635 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23636 PyObject *resultobj;
23637 bool result;
23638 char *kwnames[] = {
23639 NULL
23640 };
23641
23642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23643 {
23644 PyThreadState* __tstate = wxPyBeginAllowThreads();
23645 result = (bool)wxPyApp::IsMainLoopRunning();
23646
23647 wxPyEndAllowThreads(__tstate);
23648 if (PyErr_Occurred()) SWIG_fail;
23649 }
23650 {
23651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23652 }
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23660 PyObject *resultobj;
23661 wxPyApp *arg1 = (wxPyApp *) 0 ;
23662 int result;
23663 PyObject * obj0 = 0 ;
23664 char *kwnames[] = {
23665 (char *) "self", NULL
23666 };
23667
23668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23670 if (SWIG_arg_fail(1)) SWIG_fail;
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 result = (int)(arg1)->MainLoop();
23674
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 {
23679 resultobj = SWIG_From_int((int)(result));
23680 }
23681 return resultobj;
23682 fail:
23683 return NULL;
23684 }
23685
23686
23687 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23688 PyObject *resultobj;
23689 wxPyApp *arg1 = (wxPyApp *) 0 ;
23690 PyObject * obj0 = 0 ;
23691 char *kwnames[] = {
23692 (char *) "self", NULL
23693 };
23694
23695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23697 if (SWIG_arg_fail(1)) SWIG_fail;
23698 {
23699 PyThreadState* __tstate = wxPyBeginAllowThreads();
23700 (arg1)->Exit();
23701
23702 wxPyEndAllowThreads(__tstate);
23703 if (PyErr_Occurred()) SWIG_fail;
23704 }
23705 Py_INCREF(Py_None); resultobj = Py_None;
23706 return resultobj;
23707 fail:
23708 return NULL;
23709 }
23710
23711
23712 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23713 PyObject *resultobj;
23714 wxPyApp *arg1 = (wxPyApp *) 0 ;
23715 PyObject * obj0 = 0 ;
23716 char *kwnames[] = {
23717 (char *) "self", NULL
23718 };
23719
23720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23722 if (SWIG_arg_fail(1)) SWIG_fail;
23723 {
23724 PyThreadState* __tstate = wxPyBeginAllowThreads();
23725 (arg1)->ExitMainLoop();
23726
23727 wxPyEndAllowThreads(__tstate);
23728 if (PyErr_Occurred()) SWIG_fail;
23729 }
23730 Py_INCREF(Py_None); resultobj = Py_None;
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj;
23739 wxPyApp *arg1 = (wxPyApp *) 0 ;
23740 bool result;
23741 PyObject * obj0 = 0 ;
23742 char *kwnames[] = {
23743 (char *) "self", NULL
23744 };
23745
23746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23748 if (SWIG_arg_fail(1)) SWIG_fail;
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 result = (bool)(arg1)->Pending();
23752
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 {
23757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23758 }
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23766 PyObject *resultobj;
23767 wxPyApp *arg1 = (wxPyApp *) 0 ;
23768 bool result;
23769 PyObject * obj0 = 0 ;
23770 char *kwnames[] = {
23771 (char *) "self", NULL
23772 };
23773
23774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23776 if (SWIG_arg_fail(1)) SWIG_fail;
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = (bool)(arg1)->Dispatch();
23780
23781 wxPyEndAllowThreads(__tstate);
23782 if (PyErr_Occurred()) SWIG_fail;
23783 }
23784 {
23785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23786 }
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23794 PyObject *resultobj;
23795 wxPyApp *arg1 = (wxPyApp *) 0 ;
23796 bool result;
23797 PyObject * obj0 = 0 ;
23798 char *kwnames[] = {
23799 (char *) "self", NULL
23800 };
23801
23802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23804 if (SWIG_arg_fail(1)) SWIG_fail;
23805 {
23806 PyThreadState* __tstate = wxPyBeginAllowThreads();
23807 result = (bool)(arg1)->ProcessIdle();
23808
23809 wxPyEndAllowThreads(__tstate);
23810 if (PyErr_Occurred()) SWIG_fail;
23811 }
23812 {
23813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23814 }
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj;
23823 wxPyApp *arg1 = (wxPyApp *) 0 ;
23824 wxWindow *arg2 = (wxWindow *) 0 ;
23825 wxIdleEvent *arg3 = 0 ;
23826 bool result;
23827 PyObject * obj0 = 0 ;
23828 PyObject * obj1 = 0 ;
23829 PyObject * obj2 = 0 ;
23830 char *kwnames[] = {
23831 (char *) "self",(char *) "win",(char *) "event", NULL
23832 };
23833
23834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23836 if (SWIG_arg_fail(1)) SWIG_fail;
23837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23838 if (SWIG_arg_fail(2)) SWIG_fail;
23839 {
23840 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23841 if (SWIG_arg_fail(3)) SWIG_fail;
23842 if (arg3 == NULL) {
23843 SWIG_null_ref("wxIdleEvent");
23844 }
23845 if (SWIG_arg_fail(3)) SWIG_fail;
23846 }
23847 {
23848 PyThreadState* __tstate = wxPyBeginAllowThreads();
23849 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23850
23851 wxPyEndAllowThreads(__tstate);
23852 if (PyErr_Occurred()) SWIG_fail;
23853 }
23854 {
23855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23856 }
23857 return resultobj;
23858 fail:
23859 return NULL;
23860 }
23861
23862
23863 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23864 PyObject *resultobj;
23865 wxPyApp *arg1 = (wxPyApp *) 0 ;
23866 bool result;
23867 PyObject * obj0 = 0 ;
23868 char *kwnames[] = {
23869 (char *) "self", NULL
23870 };
23871
23872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23874 if (SWIG_arg_fail(1)) SWIG_fail;
23875 {
23876 PyThreadState* __tstate = wxPyBeginAllowThreads();
23877 result = (bool)((wxPyApp const *)arg1)->IsActive();
23878
23879 wxPyEndAllowThreads(__tstate);
23880 if (PyErr_Occurred()) SWIG_fail;
23881 }
23882 {
23883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23884 }
23885 return resultobj;
23886 fail:
23887 return NULL;
23888 }
23889
23890
23891 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23892 PyObject *resultobj;
23893 wxPyApp *arg1 = (wxPyApp *) 0 ;
23894 wxWindow *arg2 = (wxWindow *) 0 ;
23895 PyObject * obj0 = 0 ;
23896 PyObject * obj1 = 0 ;
23897 char *kwnames[] = {
23898 (char *) "self",(char *) "win", NULL
23899 };
23900
23901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23903 if (SWIG_arg_fail(1)) SWIG_fail;
23904 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23905 if (SWIG_arg_fail(2)) SWIG_fail;
23906 {
23907 PyThreadState* __tstate = wxPyBeginAllowThreads();
23908 (arg1)->SetTopWindow(arg2);
23909
23910 wxPyEndAllowThreads(__tstate);
23911 if (PyErr_Occurred()) SWIG_fail;
23912 }
23913 Py_INCREF(Py_None); resultobj = Py_None;
23914 return resultobj;
23915 fail:
23916 return NULL;
23917 }
23918
23919
23920 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23921 PyObject *resultobj;
23922 wxPyApp *arg1 = (wxPyApp *) 0 ;
23923 wxWindow *result;
23924 PyObject * obj0 = 0 ;
23925 char *kwnames[] = {
23926 (char *) "self", NULL
23927 };
23928
23929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23931 if (SWIG_arg_fail(1)) SWIG_fail;
23932 {
23933 PyThreadState* __tstate = wxPyBeginAllowThreads();
23934 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23935
23936 wxPyEndAllowThreads(__tstate);
23937 if (PyErr_Occurred()) SWIG_fail;
23938 }
23939 {
23940 resultobj = wxPyMake_wxObject(result, 0);
23941 }
23942 return resultobj;
23943 fail:
23944 return NULL;
23945 }
23946
23947
23948 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23949 PyObject *resultobj;
23950 wxPyApp *arg1 = (wxPyApp *) 0 ;
23951 bool arg2 ;
23952 PyObject * obj0 = 0 ;
23953 PyObject * obj1 = 0 ;
23954 char *kwnames[] = {
23955 (char *) "self",(char *) "flag", NULL
23956 };
23957
23958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23960 if (SWIG_arg_fail(1)) SWIG_fail;
23961 {
23962 arg2 = (bool)(SWIG_As_bool(obj1));
23963 if (SWIG_arg_fail(2)) SWIG_fail;
23964 }
23965 {
23966 PyThreadState* __tstate = wxPyBeginAllowThreads();
23967 (arg1)->SetExitOnFrameDelete(arg2);
23968
23969 wxPyEndAllowThreads(__tstate);
23970 if (PyErr_Occurred()) SWIG_fail;
23971 }
23972 Py_INCREF(Py_None); resultobj = Py_None;
23973 return resultobj;
23974 fail:
23975 return NULL;
23976 }
23977
23978
23979 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23980 PyObject *resultobj;
23981 wxPyApp *arg1 = (wxPyApp *) 0 ;
23982 bool result;
23983 PyObject * obj0 = 0 ;
23984 char *kwnames[] = {
23985 (char *) "self", NULL
23986 };
23987
23988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23990 if (SWIG_arg_fail(1)) SWIG_fail;
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23994
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 {
23999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24000 }
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24008 PyObject *resultobj;
24009 wxPyApp *arg1 = (wxPyApp *) 0 ;
24010 bool arg2 ;
24011 PyObject * obj0 = 0 ;
24012 PyObject * obj1 = 0 ;
24013 char *kwnames[] = {
24014 (char *) "self",(char *) "flag", NULL
24015 };
24016
24017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24019 if (SWIG_arg_fail(1)) SWIG_fail;
24020 {
24021 arg2 = (bool)(SWIG_As_bool(obj1));
24022 if (SWIG_arg_fail(2)) SWIG_fail;
24023 }
24024 {
24025 PyThreadState* __tstate = wxPyBeginAllowThreads();
24026 (arg1)->SetUseBestVisual(arg2);
24027
24028 wxPyEndAllowThreads(__tstate);
24029 if (PyErr_Occurred()) SWIG_fail;
24030 }
24031 Py_INCREF(Py_None); resultobj = Py_None;
24032 return resultobj;
24033 fail:
24034 return NULL;
24035 }
24036
24037
24038 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24039 PyObject *resultobj;
24040 wxPyApp *arg1 = (wxPyApp *) 0 ;
24041 bool result;
24042 PyObject * obj0 = 0 ;
24043 char *kwnames[] = {
24044 (char *) "self", NULL
24045 };
24046
24047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24049 if (SWIG_arg_fail(1)) SWIG_fail;
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24053
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 {
24058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24059 }
24060 return resultobj;
24061 fail:
24062 return NULL;
24063 }
24064
24065
24066 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24067 PyObject *resultobj;
24068 wxPyApp *arg1 = (wxPyApp *) 0 ;
24069 int arg2 ;
24070 PyObject * obj0 = 0 ;
24071 PyObject * obj1 = 0 ;
24072 char *kwnames[] = {
24073 (char *) "self",(char *) "mode", NULL
24074 };
24075
24076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24078 if (SWIG_arg_fail(1)) SWIG_fail;
24079 {
24080 arg2 = (int)(SWIG_As_int(obj1));
24081 if (SWIG_arg_fail(2)) SWIG_fail;
24082 }
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 (arg1)->SetPrintMode(arg2);
24086
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 Py_INCREF(Py_None); resultobj = Py_None;
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj;
24099 wxPyApp *arg1 = (wxPyApp *) 0 ;
24100 int result;
24101 PyObject * obj0 = 0 ;
24102 char *kwnames[] = {
24103 (char *) "self", NULL
24104 };
24105
24106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24108 if (SWIG_arg_fail(1)) SWIG_fail;
24109 {
24110 PyThreadState* __tstate = wxPyBeginAllowThreads();
24111 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24112
24113 wxPyEndAllowThreads(__tstate);
24114 if (PyErr_Occurred()) SWIG_fail;
24115 }
24116 {
24117 resultobj = SWIG_From_int((int)(result));
24118 }
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24126 PyObject *resultobj;
24127 wxPyApp *arg1 = (wxPyApp *) 0 ;
24128 int arg2 ;
24129 PyObject * obj0 = 0 ;
24130 PyObject * obj1 = 0 ;
24131 char *kwnames[] = {
24132 (char *) "self",(char *) "mode", NULL
24133 };
24134
24135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24137 if (SWIG_arg_fail(1)) SWIG_fail;
24138 {
24139 arg2 = (int)(SWIG_As_int(obj1));
24140 if (SWIG_arg_fail(2)) SWIG_fail;
24141 }
24142 {
24143 PyThreadState* __tstate = wxPyBeginAllowThreads();
24144 (arg1)->SetAssertMode(arg2);
24145
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 Py_INCREF(Py_None); resultobj = Py_None;
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24157 PyObject *resultobj;
24158 wxPyApp *arg1 = (wxPyApp *) 0 ;
24159 int result;
24160 PyObject * obj0 = 0 ;
24161 char *kwnames[] = {
24162 (char *) "self", NULL
24163 };
24164
24165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24167 if (SWIG_arg_fail(1)) SWIG_fail;
24168 {
24169 PyThreadState* __tstate = wxPyBeginAllowThreads();
24170 result = (int)(arg1)->GetAssertMode();
24171
24172 wxPyEndAllowThreads(__tstate);
24173 if (PyErr_Occurred()) SWIG_fail;
24174 }
24175 {
24176 resultobj = SWIG_From_int((int)(result));
24177 }
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24185 PyObject *resultobj;
24186 bool result;
24187 char *kwnames[] = {
24188 NULL
24189 };
24190
24191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24192 {
24193 PyThreadState* __tstate = wxPyBeginAllowThreads();
24194 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24195
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 {
24200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24201 }
24202 return resultobj;
24203 fail:
24204 return NULL;
24205 }
24206
24207
24208 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24209 PyObject *resultobj;
24210 long result;
24211 char *kwnames[] = {
24212 NULL
24213 };
24214
24215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 result = (long)wxPyApp::GetMacAboutMenuItemId();
24219
24220 wxPyEndAllowThreads(__tstate);
24221 if (PyErr_Occurred()) SWIG_fail;
24222 }
24223 {
24224 resultobj = SWIG_From_long((long)(result));
24225 }
24226 return resultobj;
24227 fail:
24228 return NULL;
24229 }
24230
24231
24232 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24233 PyObject *resultobj;
24234 long result;
24235 char *kwnames[] = {
24236 NULL
24237 };
24238
24239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24240 {
24241 PyThreadState* __tstate = wxPyBeginAllowThreads();
24242 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24243
24244 wxPyEndAllowThreads(__tstate);
24245 if (PyErr_Occurred()) SWIG_fail;
24246 }
24247 {
24248 resultobj = SWIG_From_long((long)(result));
24249 }
24250 return resultobj;
24251 fail:
24252 return NULL;
24253 }
24254
24255
24256 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24257 PyObject *resultobj;
24258 long result;
24259 char *kwnames[] = {
24260 NULL
24261 };
24262
24263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 result = (long)wxPyApp::GetMacExitMenuItemId();
24267
24268 wxPyEndAllowThreads(__tstate);
24269 if (PyErr_Occurred()) SWIG_fail;
24270 }
24271 {
24272 resultobj = SWIG_From_long((long)(result));
24273 }
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24281 PyObject *resultobj;
24282 wxString result;
24283 char *kwnames[] = {
24284 NULL
24285 };
24286
24287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24288 {
24289 PyThreadState* __tstate = wxPyBeginAllowThreads();
24290 result = wxPyApp::GetMacHelpMenuTitleName();
24291
24292 wxPyEndAllowThreads(__tstate);
24293 if (PyErr_Occurred()) SWIG_fail;
24294 }
24295 {
24296 #if wxUSE_UNICODE
24297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24298 #else
24299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24300 #endif
24301 }
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24309 PyObject *resultobj;
24310 bool arg1 ;
24311 PyObject * obj0 = 0 ;
24312 char *kwnames[] = {
24313 (char *) "val", NULL
24314 };
24315
24316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24317 {
24318 arg1 = (bool)(SWIG_As_bool(obj0));
24319 if (SWIG_arg_fail(1)) SWIG_fail;
24320 }
24321 {
24322 PyThreadState* __tstate = wxPyBeginAllowThreads();
24323 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24324
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 Py_INCREF(Py_None); resultobj = Py_None;
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj;
24337 long arg1 ;
24338 PyObject * obj0 = 0 ;
24339 char *kwnames[] = {
24340 (char *) "val", NULL
24341 };
24342
24343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24344 {
24345 arg1 = (long)(SWIG_As_long(obj0));
24346 if (SWIG_arg_fail(1)) SWIG_fail;
24347 }
24348 {
24349 PyThreadState* __tstate = wxPyBeginAllowThreads();
24350 wxPyApp::SetMacAboutMenuItemId(arg1);
24351
24352 wxPyEndAllowThreads(__tstate);
24353 if (PyErr_Occurred()) SWIG_fail;
24354 }
24355 Py_INCREF(Py_None); resultobj = Py_None;
24356 return resultobj;
24357 fail:
24358 return NULL;
24359 }
24360
24361
24362 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24363 PyObject *resultobj;
24364 long arg1 ;
24365 PyObject * obj0 = 0 ;
24366 char *kwnames[] = {
24367 (char *) "val", NULL
24368 };
24369
24370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24371 {
24372 arg1 = (long)(SWIG_As_long(obj0));
24373 if (SWIG_arg_fail(1)) SWIG_fail;
24374 }
24375 {
24376 PyThreadState* __tstate = wxPyBeginAllowThreads();
24377 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24378
24379 wxPyEndAllowThreads(__tstate);
24380 if (PyErr_Occurred()) SWIG_fail;
24381 }
24382 Py_INCREF(Py_None); resultobj = Py_None;
24383 return resultobj;
24384 fail:
24385 return NULL;
24386 }
24387
24388
24389 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24390 PyObject *resultobj;
24391 long arg1 ;
24392 PyObject * obj0 = 0 ;
24393 char *kwnames[] = {
24394 (char *) "val", NULL
24395 };
24396
24397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24398 {
24399 arg1 = (long)(SWIG_As_long(obj0));
24400 if (SWIG_arg_fail(1)) SWIG_fail;
24401 }
24402 {
24403 PyThreadState* __tstate = wxPyBeginAllowThreads();
24404 wxPyApp::SetMacExitMenuItemId(arg1);
24405
24406 wxPyEndAllowThreads(__tstate);
24407 if (PyErr_Occurred()) SWIG_fail;
24408 }
24409 Py_INCREF(Py_None); resultobj = Py_None;
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24417 PyObject *resultobj;
24418 wxString *arg1 = 0 ;
24419 bool temp1 = false ;
24420 PyObject * obj0 = 0 ;
24421 char *kwnames[] = {
24422 (char *) "val", NULL
24423 };
24424
24425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24426 {
24427 arg1 = wxString_in_helper(obj0);
24428 if (arg1 == NULL) SWIG_fail;
24429 temp1 = true;
24430 }
24431 {
24432 PyThreadState* __tstate = wxPyBeginAllowThreads();
24433 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24434
24435 wxPyEndAllowThreads(__tstate);
24436 if (PyErr_Occurred()) SWIG_fail;
24437 }
24438 Py_INCREF(Py_None); resultobj = Py_None;
24439 {
24440 if (temp1)
24441 delete arg1;
24442 }
24443 return resultobj;
24444 fail:
24445 {
24446 if (temp1)
24447 delete arg1;
24448 }
24449 return NULL;
24450 }
24451
24452
24453 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24454 PyObject *resultobj;
24455 wxPyApp *arg1 = (wxPyApp *) 0 ;
24456 PyObject * obj0 = 0 ;
24457 char *kwnames[] = {
24458 (char *) "self", NULL
24459 };
24460
24461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24463 if (SWIG_arg_fail(1)) SWIG_fail;
24464 {
24465 PyThreadState* __tstate = wxPyBeginAllowThreads();
24466 (arg1)->_BootstrapApp();
24467
24468 wxPyEndAllowThreads(__tstate);
24469 if (PyErr_Occurred()) SWIG_fail;
24470 }
24471 Py_INCREF(Py_None); resultobj = Py_None;
24472 return resultobj;
24473 fail:
24474 return NULL;
24475 }
24476
24477
24478 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24479 PyObject *resultobj;
24480 int result;
24481 char *kwnames[] = {
24482 NULL
24483 };
24484
24485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24486 {
24487 PyThreadState* __tstate = wxPyBeginAllowThreads();
24488 result = (int)wxPyApp::GetComCtl32Version();
24489
24490 wxPyEndAllowThreads(__tstate);
24491 if (PyErr_Occurred()) SWIG_fail;
24492 }
24493 {
24494 resultobj = SWIG_From_int((int)(result));
24495 }
24496 return resultobj;
24497 fail:
24498 return NULL;
24499 }
24500
24501
24502 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24503 PyObject *obj;
24504 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24505 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24506 Py_INCREF(obj);
24507 return Py_BuildValue((char *)"");
24508 }
24509 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24510 PyObject *resultobj;
24511 char *kwnames[] = {
24512 NULL
24513 };
24514
24515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24516 {
24517 PyThreadState* __tstate = wxPyBeginAllowThreads();
24518 wxExit();
24519
24520 wxPyEndAllowThreads(__tstate);
24521 if (PyErr_Occurred()) SWIG_fail;
24522 }
24523 Py_INCREF(Py_None); resultobj = Py_None;
24524 return resultobj;
24525 fail:
24526 return NULL;
24527 }
24528
24529
24530 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24531 PyObject *resultobj;
24532 bool result;
24533 char *kwnames[] = {
24534 NULL
24535 };
24536
24537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24538 {
24539 PyThreadState* __tstate = wxPyBeginAllowThreads();
24540 result = (bool)wxYield();
24541
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 {
24546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24547 }
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24555 PyObject *resultobj;
24556 bool result;
24557 char *kwnames[] = {
24558 NULL
24559 };
24560
24561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24562 {
24563 PyThreadState* __tstate = wxPyBeginAllowThreads();
24564 result = (bool)wxYieldIfNeeded();
24565
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 {
24570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24571 }
24572 return resultobj;
24573 fail:
24574 return NULL;
24575 }
24576
24577
24578 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24579 PyObject *resultobj;
24580 wxWindow *arg1 = (wxWindow *) NULL ;
24581 bool arg2 = (bool) false ;
24582 bool result;
24583 PyObject * obj0 = 0 ;
24584 PyObject * obj1 = 0 ;
24585 char *kwnames[] = {
24586 (char *) "win",(char *) "onlyIfNeeded", NULL
24587 };
24588
24589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24590 if (obj0) {
24591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24592 if (SWIG_arg_fail(1)) SWIG_fail;
24593 }
24594 if (obj1) {
24595 {
24596 arg2 = (bool)(SWIG_As_bool(obj1));
24597 if (SWIG_arg_fail(2)) SWIG_fail;
24598 }
24599 }
24600 {
24601 PyThreadState* __tstate = wxPyBeginAllowThreads();
24602 result = (bool)wxSafeYield(arg1,arg2);
24603
24604 wxPyEndAllowThreads(__tstate);
24605 if (PyErr_Occurred()) SWIG_fail;
24606 }
24607 {
24608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24609 }
24610 return resultobj;
24611 fail:
24612 return NULL;
24613 }
24614
24615
24616 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj;
24618 char *kwnames[] = {
24619 NULL
24620 };
24621
24622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24623 {
24624 PyThreadState* __tstate = wxPyBeginAllowThreads();
24625 wxWakeUpIdle();
24626
24627 wxPyEndAllowThreads(__tstate);
24628 if (PyErr_Occurred()) SWIG_fail;
24629 }
24630 Py_INCREF(Py_None); resultobj = Py_None;
24631 return resultobj;
24632 fail:
24633 return NULL;
24634 }
24635
24636
24637 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24638 PyObject *resultobj;
24639 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24640 wxEvent *arg2 = 0 ;
24641 PyObject * obj0 = 0 ;
24642 PyObject * obj1 = 0 ;
24643 char *kwnames[] = {
24644 (char *) "dest",(char *) "event", NULL
24645 };
24646
24647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24649 if (SWIG_arg_fail(1)) SWIG_fail;
24650 {
24651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24652 if (SWIG_arg_fail(2)) SWIG_fail;
24653 if (arg2 == NULL) {
24654 SWIG_null_ref("wxEvent");
24655 }
24656 if (SWIG_arg_fail(2)) SWIG_fail;
24657 }
24658 {
24659 PyThreadState* __tstate = wxPyBeginAllowThreads();
24660 wxPostEvent(arg1,*arg2);
24661
24662 wxPyEndAllowThreads(__tstate);
24663 if (PyErr_Occurred()) SWIG_fail;
24664 }
24665 Py_INCREF(Py_None); resultobj = Py_None;
24666 return resultobj;
24667 fail:
24668 return NULL;
24669 }
24670
24671
24672 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24673 PyObject *resultobj;
24674 char *kwnames[] = {
24675 NULL
24676 };
24677
24678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24679 {
24680 PyThreadState* __tstate = wxPyBeginAllowThreads();
24681 wxApp_CleanUp();
24682
24683 wxPyEndAllowThreads(__tstate);
24684 if (PyErr_Occurred()) SWIG_fail;
24685 }
24686 Py_INCREF(Py_None); resultobj = Py_None;
24687 return resultobj;
24688 fail:
24689 return NULL;
24690 }
24691
24692
24693 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24694 PyObject *resultobj;
24695 wxPyApp *result;
24696 char *kwnames[] = {
24697 NULL
24698 };
24699
24700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = (wxPyApp *)wxPyGetApp();
24704
24705 wxPyEndAllowThreads(__tstate);
24706 if (PyErr_Occurred()) SWIG_fail;
24707 }
24708 {
24709 resultobj = wxPyMake_wxObject(result, 0);
24710 }
24711 return resultobj;
24712 fail:
24713 return NULL;
24714 }
24715
24716
24717 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24718 PyObject *resultobj;
24719 char *arg1 = (char *) 0 ;
24720 PyObject * obj0 = 0 ;
24721 char *kwnames[] = {
24722 (char *) "encoding", NULL
24723 };
24724
24725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24726 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24727 SWIG_arg_fail(1);SWIG_fail;
24728 }
24729 {
24730 PyThreadState* __tstate = wxPyBeginAllowThreads();
24731 wxSetDefaultPyEncoding((char const *)arg1);
24732
24733 wxPyEndAllowThreads(__tstate);
24734 if (PyErr_Occurred()) SWIG_fail;
24735 }
24736 Py_INCREF(Py_None); resultobj = Py_None;
24737 return resultobj;
24738 fail:
24739 return NULL;
24740 }
24741
24742
24743 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24744 PyObject *resultobj;
24745 char *result;
24746 char *kwnames[] = {
24747 NULL
24748 };
24749
24750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24751 {
24752 PyThreadState* __tstate = wxPyBeginAllowThreads();
24753 result = (char *)wxGetDefaultPyEncoding();
24754
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 resultobj = SWIG_FromCharPtr(result);
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24766 PyObject *resultobj;
24767 wxEventLoop *result;
24768 char *kwnames[] = {
24769 NULL
24770 };
24771
24772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24773 {
24774 PyThreadState* __tstate = wxPyBeginAllowThreads();
24775 result = (wxEventLoop *)new wxEventLoop();
24776
24777 wxPyEndAllowThreads(__tstate);
24778 if (PyErr_Occurred()) SWIG_fail;
24779 }
24780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24781 return resultobj;
24782 fail:
24783 return NULL;
24784 }
24785
24786
24787 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24788 PyObject *resultobj;
24789 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24790 PyObject * obj0 = 0 ;
24791 char *kwnames[] = {
24792 (char *) "self", NULL
24793 };
24794
24795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24797 if (SWIG_arg_fail(1)) SWIG_fail;
24798 {
24799 PyThreadState* __tstate = wxPyBeginAllowThreads();
24800 delete arg1;
24801
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 Py_INCREF(Py_None); resultobj = Py_None;
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24813 PyObject *resultobj;
24814 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24815 int result;
24816 PyObject * obj0 = 0 ;
24817 char *kwnames[] = {
24818 (char *) "self", NULL
24819 };
24820
24821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24823 if (SWIG_arg_fail(1)) SWIG_fail;
24824 {
24825 PyThreadState* __tstate = wxPyBeginAllowThreads();
24826 result = (int)(arg1)->Run();
24827
24828 wxPyEndAllowThreads(__tstate);
24829 if (PyErr_Occurred()) SWIG_fail;
24830 }
24831 {
24832 resultobj = SWIG_From_int((int)(result));
24833 }
24834 return resultobj;
24835 fail:
24836 return NULL;
24837 }
24838
24839
24840 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24841 PyObject *resultobj;
24842 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24843 int arg2 = (int) 0 ;
24844 PyObject * obj0 = 0 ;
24845 PyObject * obj1 = 0 ;
24846 char *kwnames[] = {
24847 (char *) "self",(char *) "rc", NULL
24848 };
24849
24850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24852 if (SWIG_arg_fail(1)) SWIG_fail;
24853 if (obj1) {
24854 {
24855 arg2 = (int)(SWIG_As_int(obj1));
24856 if (SWIG_arg_fail(2)) SWIG_fail;
24857 }
24858 }
24859 {
24860 PyThreadState* __tstate = wxPyBeginAllowThreads();
24861 (arg1)->Exit(arg2);
24862
24863 wxPyEndAllowThreads(__tstate);
24864 if (PyErr_Occurred()) SWIG_fail;
24865 }
24866 Py_INCREF(Py_None); resultobj = Py_None;
24867 return resultobj;
24868 fail:
24869 return NULL;
24870 }
24871
24872
24873 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24874 PyObject *resultobj;
24875 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24876 bool result;
24877 PyObject * obj0 = 0 ;
24878 char *kwnames[] = {
24879 (char *) "self", NULL
24880 };
24881
24882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24884 if (SWIG_arg_fail(1)) SWIG_fail;
24885 {
24886 PyThreadState* __tstate = wxPyBeginAllowThreads();
24887 result = (bool)((wxEventLoop const *)arg1)->Pending();
24888
24889 wxPyEndAllowThreads(__tstate);
24890 if (PyErr_Occurred()) SWIG_fail;
24891 }
24892 {
24893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24894 }
24895 return resultobj;
24896 fail:
24897 return NULL;
24898 }
24899
24900
24901 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24902 PyObject *resultobj;
24903 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24904 bool result;
24905 PyObject * obj0 = 0 ;
24906 char *kwnames[] = {
24907 (char *) "self", NULL
24908 };
24909
24910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24912 if (SWIG_arg_fail(1)) SWIG_fail;
24913 {
24914 PyThreadState* __tstate = wxPyBeginAllowThreads();
24915 result = (bool)(arg1)->Dispatch();
24916
24917 wxPyEndAllowThreads(__tstate);
24918 if (PyErr_Occurred()) SWIG_fail;
24919 }
24920 {
24921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24922 }
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj;
24931 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24932 bool result;
24933 PyObject * obj0 = 0 ;
24934 char *kwnames[] = {
24935 (char *) "self", NULL
24936 };
24937
24938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24940 if (SWIG_arg_fail(1)) SWIG_fail;
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24944
24945 wxPyEndAllowThreads(__tstate);
24946 if (PyErr_Occurred()) SWIG_fail;
24947 }
24948 {
24949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24950 }
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24958 PyObject *resultobj;
24959 wxEventLoop *result;
24960 char *kwnames[] = {
24961 NULL
24962 };
24963
24964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24965 {
24966 PyThreadState* __tstate = wxPyBeginAllowThreads();
24967 result = (wxEventLoop *)wxEventLoop::GetActive();
24968
24969 wxPyEndAllowThreads(__tstate);
24970 if (PyErr_Occurred()) SWIG_fail;
24971 }
24972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24973 return resultobj;
24974 fail:
24975 return NULL;
24976 }
24977
24978
24979 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24980 PyObject *resultobj;
24981 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24982 PyObject * obj0 = 0 ;
24983 char *kwnames[] = {
24984 (char *) "loop", NULL
24985 };
24986
24987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24989 if (SWIG_arg_fail(1)) SWIG_fail;
24990 {
24991 PyThreadState* __tstate = wxPyBeginAllowThreads();
24992 wxEventLoop::SetActive(arg1);
24993
24994 wxPyEndAllowThreads(__tstate);
24995 if (PyErr_Occurred()) SWIG_fail;
24996 }
24997 Py_INCREF(Py_None); resultobj = Py_None;
24998 return resultobj;
24999 fail:
25000 return NULL;
25001 }
25002
25003
25004 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25005 PyObject *obj;
25006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25007 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25008 Py_INCREF(obj);
25009 return Py_BuildValue((char *)"");
25010 }
25011 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25012 PyObject *resultobj;
25013 int arg1 = (int) 0 ;
25014 int arg2 = (int) 0 ;
25015 int arg3 = (int) 0 ;
25016 wxAcceleratorEntry *result;
25017 PyObject * obj0 = 0 ;
25018 PyObject * obj1 = 0 ;
25019 PyObject * obj2 = 0 ;
25020 char *kwnames[] = {
25021 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25022 };
25023
25024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25025 if (obj0) {
25026 {
25027 arg1 = (int)(SWIG_As_int(obj0));
25028 if (SWIG_arg_fail(1)) SWIG_fail;
25029 }
25030 }
25031 if (obj1) {
25032 {
25033 arg2 = (int)(SWIG_As_int(obj1));
25034 if (SWIG_arg_fail(2)) SWIG_fail;
25035 }
25036 }
25037 if (obj2) {
25038 {
25039 arg3 = (int)(SWIG_As_int(obj2));
25040 if (SWIG_arg_fail(3)) SWIG_fail;
25041 }
25042 }
25043 {
25044 PyThreadState* __tstate = wxPyBeginAllowThreads();
25045 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25046
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25051 return resultobj;
25052 fail:
25053 return NULL;
25054 }
25055
25056
25057 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25058 PyObject *resultobj;
25059 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25060 PyObject * obj0 = 0 ;
25061 char *kwnames[] = {
25062 (char *) "self", NULL
25063 };
25064
25065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25067 if (SWIG_arg_fail(1)) SWIG_fail;
25068 {
25069 PyThreadState* __tstate = wxPyBeginAllowThreads();
25070 delete arg1;
25071
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 Py_INCREF(Py_None); resultobj = Py_None;
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25083 PyObject *resultobj;
25084 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25085 int arg2 ;
25086 int arg3 ;
25087 int arg4 ;
25088 PyObject * obj0 = 0 ;
25089 PyObject * obj1 = 0 ;
25090 PyObject * obj2 = 0 ;
25091 PyObject * obj3 = 0 ;
25092 char *kwnames[] = {
25093 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25094 };
25095
25096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25098 if (SWIG_arg_fail(1)) SWIG_fail;
25099 {
25100 arg2 = (int)(SWIG_As_int(obj1));
25101 if (SWIG_arg_fail(2)) SWIG_fail;
25102 }
25103 {
25104 arg3 = (int)(SWIG_As_int(obj2));
25105 if (SWIG_arg_fail(3)) SWIG_fail;
25106 }
25107 {
25108 arg4 = (int)(SWIG_As_int(obj3));
25109 if (SWIG_arg_fail(4)) SWIG_fail;
25110 }
25111 {
25112 PyThreadState* __tstate = wxPyBeginAllowThreads();
25113 (arg1)->Set(arg2,arg3,arg4);
25114
25115 wxPyEndAllowThreads(__tstate);
25116 if (PyErr_Occurred()) SWIG_fail;
25117 }
25118 Py_INCREF(Py_None); resultobj = Py_None;
25119 return resultobj;
25120 fail:
25121 return NULL;
25122 }
25123
25124
25125 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25126 PyObject *resultobj;
25127 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25128 int result;
25129 PyObject * obj0 = 0 ;
25130 char *kwnames[] = {
25131 (char *) "self", NULL
25132 };
25133
25134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25136 if (SWIG_arg_fail(1)) SWIG_fail;
25137 {
25138 PyThreadState* __tstate = wxPyBeginAllowThreads();
25139 result = (int)(arg1)->GetFlags();
25140
25141 wxPyEndAllowThreads(__tstate);
25142 if (PyErr_Occurred()) SWIG_fail;
25143 }
25144 {
25145 resultobj = SWIG_From_int((int)(result));
25146 }
25147 return resultobj;
25148 fail:
25149 return NULL;
25150 }
25151
25152
25153 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25154 PyObject *resultobj;
25155 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25156 int result;
25157 PyObject * obj0 = 0 ;
25158 char *kwnames[] = {
25159 (char *) "self", NULL
25160 };
25161
25162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25164 if (SWIG_arg_fail(1)) SWIG_fail;
25165 {
25166 PyThreadState* __tstate = wxPyBeginAllowThreads();
25167 result = (int)(arg1)->GetKeyCode();
25168
25169 wxPyEndAllowThreads(__tstate);
25170 if (PyErr_Occurred()) SWIG_fail;
25171 }
25172 {
25173 resultobj = SWIG_From_int((int)(result));
25174 }
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25182 PyObject *resultobj;
25183 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25184 int result;
25185 PyObject * obj0 = 0 ;
25186 char *kwnames[] = {
25187 (char *) "self", NULL
25188 };
25189
25190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25192 if (SWIG_arg_fail(1)) SWIG_fail;
25193 {
25194 PyThreadState* __tstate = wxPyBeginAllowThreads();
25195 result = (int)(arg1)->GetCommand();
25196
25197 wxPyEndAllowThreads(__tstate);
25198 if (PyErr_Occurred()) SWIG_fail;
25199 }
25200 {
25201 resultobj = SWIG_From_int((int)(result));
25202 }
25203 return resultobj;
25204 fail:
25205 return NULL;
25206 }
25207
25208
25209 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25210 PyObject *obj;
25211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25212 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25213 Py_INCREF(obj);
25214 return Py_BuildValue((char *)"");
25215 }
25216 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25217 PyObject *resultobj;
25218 int arg1 ;
25219 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25220 wxAcceleratorTable *result;
25221 PyObject * obj0 = 0 ;
25222 char *kwnames[] = {
25223 (char *) "n", NULL
25224 };
25225
25226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25227 {
25228 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25229 if (arg2) arg1 = PyList_Size(obj0);
25230 else arg1 = 0;
25231 }
25232 {
25233 PyThreadState* __tstate = wxPyBeginAllowThreads();
25234 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25235
25236 wxPyEndAllowThreads(__tstate);
25237 if (PyErr_Occurred()) SWIG_fail;
25238 }
25239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25240 {
25241 delete [] arg2;
25242 }
25243 return resultobj;
25244 fail:
25245 {
25246 delete [] arg2;
25247 }
25248 return NULL;
25249 }
25250
25251
25252 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj;
25254 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25255 PyObject * obj0 = 0 ;
25256 char *kwnames[] = {
25257 (char *) "self", NULL
25258 };
25259
25260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25262 if (SWIG_arg_fail(1)) SWIG_fail;
25263 {
25264 PyThreadState* __tstate = wxPyBeginAllowThreads();
25265 delete arg1;
25266
25267 wxPyEndAllowThreads(__tstate);
25268 if (PyErr_Occurred()) SWIG_fail;
25269 }
25270 Py_INCREF(Py_None); resultobj = Py_None;
25271 return resultobj;
25272 fail:
25273 return NULL;
25274 }
25275
25276
25277 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25278 PyObject *resultobj;
25279 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25280 bool result;
25281 PyObject * obj0 = 0 ;
25282 char *kwnames[] = {
25283 (char *) "self", NULL
25284 };
25285
25286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25288 if (SWIG_arg_fail(1)) SWIG_fail;
25289 {
25290 PyThreadState* __tstate = wxPyBeginAllowThreads();
25291 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25292
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 {
25297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25298 }
25299 return resultobj;
25300 fail:
25301 return NULL;
25302 }
25303
25304
25305 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25306 PyObject *obj;
25307 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25308 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25309 Py_INCREF(obj);
25310 return Py_BuildValue((char *)"");
25311 }
25312 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25313 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25314 return 1;
25315 }
25316
25317
25318 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25319 PyObject *pyobj;
25320
25321 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25322 return pyobj;
25323 }
25324
25325
25326 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25327 PyObject *resultobj;
25328 wxString *arg1 = 0 ;
25329 wxAcceleratorEntry *result;
25330 bool temp1 = false ;
25331 PyObject * obj0 = 0 ;
25332 char *kwnames[] = {
25333 (char *) "label", NULL
25334 };
25335
25336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25337 {
25338 arg1 = wxString_in_helper(obj0);
25339 if (arg1 == NULL) SWIG_fail;
25340 temp1 = true;
25341 }
25342 {
25343 PyThreadState* __tstate = wxPyBeginAllowThreads();
25344 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25345
25346 wxPyEndAllowThreads(__tstate);
25347 if (PyErr_Occurred()) SWIG_fail;
25348 }
25349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25350 {
25351 if (temp1)
25352 delete arg1;
25353 }
25354 return resultobj;
25355 fail:
25356 {
25357 if (temp1)
25358 delete arg1;
25359 }
25360 return NULL;
25361 }
25362
25363
25364 static int _wrap_PanelNameStr_set(PyObject *) {
25365 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25366 return 1;
25367 }
25368
25369
25370 static PyObject *_wrap_PanelNameStr_get(void) {
25371 PyObject *pyobj;
25372
25373 {
25374 #if wxUSE_UNICODE
25375 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25376 #else
25377 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25378 #endif
25379 }
25380 return pyobj;
25381 }
25382
25383
25384 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25385 PyObject *resultobj;
25386 wxVisualAttributes *result;
25387 char *kwnames[] = {
25388 NULL
25389 };
25390
25391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25392 {
25393 PyThreadState* __tstate = wxPyBeginAllowThreads();
25394 result = (wxVisualAttributes *)new_wxVisualAttributes();
25395
25396 wxPyEndAllowThreads(__tstate);
25397 if (PyErr_Occurred()) SWIG_fail;
25398 }
25399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25407 PyObject *resultobj;
25408 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25409 PyObject * obj0 = 0 ;
25410 char *kwnames[] = {
25411 (char *) "self", NULL
25412 };
25413
25414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25416 if (SWIG_arg_fail(1)) SWIG_fail;
25417 {
25418 PyThreadState* __tstate = wxPyBeginAllowThreads();
25419 delete_wxVisualAttributes(arg1);
25420
25421 wxPyEndAllowThreads(__tstate);
25422 if (PyErr_Occurred()) SWIG_fail;
25423 }
25424 Py_INCREF(Py_None); resultobj = Py_None;
25425 return resultobj;
25426 fail:
25427 return NULL;
25428 }
25429
25430
25431 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25432 PyObject *resultobj;
25433 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25434 wxFont *arg2 = (wxFont *) 0 ;
25435 PyObject * obj0 = 0 ;
25436 PyObject * obj1 = 0 ;
25437 char *kwnames[] = {
25438 (char *) "self",(char *) "font", NULL
25439 };
25440
25441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25443 if (SWIG_arg_fail(1)) SWIG_fail;
25444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25445 if (SWIG_arg_fail(2)) SWIG_fail;
25446 if (arg1) (arg1)->font = *arg2;
25447
25448 Py_INCREF(Py_None); resultobj = Py_None;
25449 return resultobj;
25450 fail:
25451 return NULL;
25452 }
25453
25454
25455 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25456 PyObject *resultobj;
25457 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25458 wxFont *result;
25459 PyObject * obj0 = 0 ;
25460 char *kwnames[] = {
25461 (char *) "self", NULL
25462 };
25463
25464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25466 if (SWIG_arg_fail(1)) SWIG_fail;
25467 result = (wxFont *)& ((arg1)->font);
25468
25469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25470 return resultobj;
25471 fail:
25472 return NULL;
25473 }
25474
25475
25476 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj;
25478 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25479 wxColour *arg2 = (wxColour *) 0 ;
25480 PyObject * obj0 = 0 ;
25481 PyObject * obj1 = 0 ;
25482 char *kwnames[] = {
25483 (char *) "self",(char *) "colFg", NULL
25484 };
25485
25486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25488 if (SWIG_arg_fail(1)) SWIG_fail;
25489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25490 if (SWIG_arg_fail(2)) SWIG_fail;
25491 if (arg1) (arg1)->colFg = *arg2;
25492
25493 Py_INCREF(Py_None); resultobj = Py_None;
25494 return resultobj;
25495 fail:
25496 return NULL;
25497 }
25498
25499
25500 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25501 PyObject *resultobj;
25502 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25503 wxColour *result;
25504 PyObject * obj0 = 0 ;
25505 char *kwnames[] = {
25506 (char *) "self", NULL
25507 };
25508
25509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25511 if (SWIG_arg_fail(1)) SWIG_fail;
25512 result = (wxColour *)& ((arg1)->colFg);
25513
25514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25522 PyObject *resultobj;
25523 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25524 wxColour *arg2 = (wxColour *) 0 ;
25525 PyObject * obj0 = 0 ;
25526 PyObject * obj1 = 0 ;
25527 char *kwnames[] = {
25528 (char *) "self",(char *) "colBg", NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25533 if (SWIG_arg_fail(1)) SWIG_fail;
25534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25535 if (SWIG_arg_fail(2)) SWIG_fail;
25536 if (arg1) (arg1)->colBg = *arg2;
25537
25538 Py_INCREF(Py_None); resultobj = Py_None;
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj;
25547 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25548 wxColour *result;
25549 PyObject * obj0 = 0 ;
25550 char *kwnames[] = {
25551 (char *) "self", NULL
25552 };
25553
25554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25556 if (SWIG_arg_fail(1)) SWIG_fail;
25557 result = (wxColour *)& ((arg1)->colBg);
25558
25559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25560 return resultobj;
25561 fail:
25562 return NULL;
25563 }
25564
25565
25566 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25567 PyObject *obj;
25568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25569 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25570 Py_INCREF(obj);
25571 return Py_BuildValue((char *)"");
25572 }
25573 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25574 PyObject *resultobj;
25575 wxWindow *arg1 = (wxWindow *) 0 ;
25576 int arg2 = (int) (int)-1 ;
25577 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25578 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25579 wxSize const &arg4_defvalue = wxDefaultSize ;
25580 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25581 long arg5 = (long) 0 ;
25582 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25583 wxString *arg6 = (wxString *) &arg6_defvalue ;
25584 wxWindow *result;
25585 wxPoint temp3 ;
25586 wxSize temp4 ;
25587 bool temp6 = false ;
25588 PyObject * obj0 = 0 ;
25589 PyObject * obj1 = 0 ;
25590 PyObject * obj2 = 0 ;
25591 PyObject * obj3 = 0 ;
25592 PyObject * obj4 = 0 ;
25593 PyObject * obj5 = 0 ;
25594 char *kwnames[] = {
25595 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25596 };
25597
25598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25600 if (SWIG_arg_fail(1)) SWIG_fail;
25601 if (obj1) {
25602 {
25603 arg2 = (int const)(SWIG_As_int(obj1));
25604 if (SWIG_arg_fail(2)) SWIG_fail;
25605 }
25606 }
25607 if (obj2) {
25608 {
25609 arg3 = &temp3;
25610 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25611 }
25612 }
25613 if (obj3) {
25614 {
25615 arg4 = &temp4;
25616 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25617 }
25618 }
25619 if (obj4) {
25620 {
25621 arg5 = (long)(SWIG_As_long(obj4));
25622 if (SWIG_arg_fail(5)) SWIG_fail;
25623 }
25624 }
25625 if (obj5) {
25626 {
25627 arg6 = wxString_in_helper(obj5);
25628 if (arg6 == NULL) SWIG_fail;
25629 temp6 = true;
25630 }
25631 }
25632 {
25633 if (!wxPyCheckForApp()) SWIG_fail;
25634 PyThreadState* __tstate = wxPyBeginAllowThreads();
25635 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25636
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25641 {
25642 if (temp6)
25643 delete arg6;
25644 }
25645 return resultobj;
25646 fail:
25647 {
25648 if (temp6)
25649 delete arg6;
25650 }
25651 return NULL;
25652 }
25653
25654
25655 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25656 PyObject *resultobj;
25657 wxWindow *result;
25658 char *kwnames[] = {
25659 NULL
25660 };
25661
25662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25663 {
25664 if (!wxPyCheckForApp()) SWIG_fail;
25665 PyThreadState* __tstate = wxPyBeginAllowThreads();
25666 result = (wxWindow *)new wxWindow();
25667
25668 wxPyEndAllowThreads(__tstate);
25669 if (PyErr_Occurred()) SWIG_fail;
25670 }
25671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25672 return resultobj;
25673 fail:
25674 return NULL;
25675 }
25676
25677
25678 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25679 PyObject *resultobj;
25680 wxWindow *arg1 = (wxWindow *) 0 ;
25681 wxWindow *arg2 = (wxWindow *) 0 ;
25682 int arg3 = (int) (int)-1 ;
25683 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25684 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25685 wxSize const &arg5_defvalue = wxDefaultSize ;
25686 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25687 long arg6 = (long) 0 ;
25688 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25689 wxString *arg7 = (wxString *) &arg7_defvalue ;
25690 bool result;
25691 wxPoint temp4 ;
25692 wxSize temp5 ;
25693 bool temp7 = false ;
25694 PyObject * obj0 = 0 ;
25695 PyObject * obj1 = 0 ;
25696 PyObject * obj2 = 0 ;
25697 PyObject * obj3 = 0 ;
25698 PyObject * obj4 = 0 ;
25699 PyObject * obj5 = 0 ;
25700 PyObject * obj6 = 0 ;
25701 char *kwnames[] = {
25702 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25703 };
25704
25705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25707 if (SWIG_arg_fail(1)) SWIG_fail;
25708 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25709 if (SWIG_arg_fail(2)) SWIG_fail;
25710 if (obj2) {
25711 {
25712 arg3 = (int const)(SWIG_As_int(obj2));
25713 if (SWIG_arg_fail(3)) SWIG_fail;
25714 }
25715 }
25716 if (obj3) {
25717 {
25718 arg4 = &temp4;
25719 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25720 }
25721 }
25722 if (obj4) {
25723 {
25724 arg5 = &temp5;
25725 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25726 }
25727 }
25728 if (obj5) {
25729 {
25730 arg6 = (long)(SWIG_As_long(obj5));
25731 if (SWIG_arg_fail(6)) SWIG_fail;
25732 }
25733 }
25734 if (obj6) {
25735 {
25736 arg7 = wxString_in_helper(obj6);
25737 if (arg7 == NULL) SWIG_fail;
25738 temp7 = true;
25739 }
25740 }
25741 {
25742 PyThreadState* __tstate = wxPyBeginAllowThreads();
25743 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25744
25745 wxPyEndAllowThreads(__tstate);
25746 if (PyErr_Occurred()) SWIG_fail;
25747 }
25748 {
25749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25750 }
25751 {
25752 if (temp7)
25753 delete arg7;
25754 }
25755 return resultobj;
25756 fail:
25757 {
25758 if (temp7)
25759 delete arg7;
25760 }
25761 return NULL;
25762 }
25763
25764
25765 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25766 PyObject *resultobj;
25767 wxWindow *arg1 = (wxWindow *) 0 ;
25768 bool arg2 = (bool) false ;
25769 bool result;
25770 PyObject * obj0 = 0 ;
25771 PyObject * obj1 = 0 ;
25772 char *kwnames[] = {
25773 (char *) "self",(char *) "force", NULL
25774 };
25775
25776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25778 if (SWIG_arg_fail(1)) SWIG_fail;
25779 if (obj1) {
25780 {
25781 arg2 = (bool)(SWIG_As_bool(obj1));
25782 if (SWIG_arg_fail(2)) SWIG_fail;
25783 }
25784 }
25785 {
25786 PyThreadState* __tstate = wxPyBeginAllowThreads();
25787 result = (bool)(arg1)->Close(arg2);
25788
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 {
25793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25794 }
25795 return resultobj;
25796 fail:
25797 return NULL;
25798 }
25799
25800
25801 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj;
25803 wxWindow *arg1 = (wxWindow *) 0 ;
25804 bool result;
25805 PyObject * obj0 = 0 ;
25806 char *kwnames[] = {
25807 (char *) "self", NULL
25808 };
25809
25810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25812 if (SWIG_arg_fail(1)) SWIG_fail;
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 result = (bool)(arg1)->Destroy();
25816
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 {
25821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25822 }
25823 return resultobj;
25824 fail:
25825 return NULL;
25826 }
25827
25828
25829 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25830 PyObject *resultobj;
25831 wxWindow *arg1 = (wxWindow *) 0 ;
25832 bool result;
25833 PyObject * obj0 = 0 ;
25834 char *kwnames[] = {
25835 (char *) "self", NULL
25836 };
25837
25838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25840 if (SWIG_arg_fail(1)) SWIG_fail;
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 result = (bool)(arg1)->DestroyChildren();
25844
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 {
25849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25850 }
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj;
25859 wxWindow *arg1 = (wxWindow *) 0 ;
25860 bool result;
25861 PyObject * obj0 = 0 ;
25862 char *kwnames[] = {
25863 (char *) "self", NULL
25864 };
25865
25866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25868 if (SWIG_arg_fail(1)) SWIG_fail;
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25872
25873 wxPyEndAllowThreads(__tstate);
25874 if (PyErr_Occurred()) SWIG_fail;
25875 }
25876 {
25877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25878 }
25879 return resultobj;
25880 fail:
25881 return NULL;
25882 }
25883
25884
25885 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25886 PyObject *resultobj;
25887 wxWindow *arg1 = (wxWindow *) 0 ;
25888 wxString *arg2 = 0 ;
25889 bool temp2 = false ;
25890 PyObject * obj0 = 0 ;
25891 PyObject * obj1 = 0 ;
25892 char *kwnames[] = {
25893 (char *) "self",(char *) "label", NULL
25894 };
25895
25896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25898 if (SWIG_arg_fail(1)) SWIG_fail;
25899 {
25900 arg2 = wxString_in_helper(obj1);
25901 if (arg2 == NULL) SWIG_fail;
25902 temp2 = true;
25903 }
25904 {
25905 PyThreadState* __tstate = wxPyBeginAllowThreads();
25906 (arg1)->SetLabel((wxString const &)*arg2);
25907
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 Py_INCREF(Py_None); resultobj = Py_None;
25912 {
25913 if (temp2)
25914 delete arg2;
25915 }
25916 return resultobj;
25917 fail:
25918 {
25919 if (temp2)
25920 delete arg2;
25921 }
25922 return NULL;
25923 }
25924
25925
25926 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25927 PyObject *resultobj;
25928 wxWindow *arg1 = (wxWindow *) 0 ;
25929 wxString result;
25930 PyObject * obj0 = 0 ;
25931 char *kwnames[] = {
25932 (char *) "self", NULL
25933 };
25934
25935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25937 if (SWIG_arg_fail(1)) SWIG_fail;
25938 {
25939 PyThreadState* __tstate = wxPyBeginAllowThreads();
25940 result = ((wxWindow const *)arg1)->GetLabel();
25941
25942 wxPyEndAllowThreads(__tstate);
25943 if (PyErr_Occurred()) SWIG_fail;
25944 }
25945 {
25946 #if wxUSE_UNICODE
25947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25948 #else
25949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25950 #endif
25951 }
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25959 PyObject *resultobj;
25960 wxWindow *arg1 = (wxWindow *) 0 ;
25961 wxString *arg2 = 0 ;
25962 bool temp2 = false ;
25963 PyObject * obj0 = 0 ;
25964 PyObject * obj1 = 0 ;
25965 char *kwnames[] = {
25966 (char *) "self",(char *) "name", NULL
25967 };
25968
25969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25971 if (SWIG_arg_fail(1)) SWIG_fail;
25972 {
25973 arg2 = wxString_in_helper(obj1);
25974 if (arg2 == NULL) SWIG_fail;
25975 temp2 = true;
25976 }
25977 {
25978 PyThreadState* __tstate = wxPyBeginAllowThreads();
25979 (arg1)->SetName((wxString const &)*arg2);
25980
25981 wxPyEndAllowThreads(__tstate);
25982 if (PyErr_Occurred()) SWIG_fail;
25983 }
25984 Py_INCREF(Py_None); resultobj = Py_None;
25985 {
25986 if (temp2)
25987 delete arg2;
25988 }
25989 return resultobj;
25990 fail:
25991 {
25992 if (temp2)
25993 delete arg2;
25994 }
25995 return NULL;
25996 }
25997
25998
25999 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj;
26001 wxWindow *arg1 = (wxWindow *) 0 ;
26002 wxString result;
26003 PyObject * obj0 = 0 ;
26004 char *kwnames[] = {
26005 (char *) "self", NULL
26006 };
26007
26008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26010 if (SWIG_arg_fail(1)) SWIG_fail;
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 result = ((wxWindow const *)arg1)->GetName();
26014
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 {
26019 #if wxUSE_UNICODE
26020 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26021 #else
26022 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26023 #endif
26024 }
26025 return resultobj;
26026 fail:
26027 return NULL;
26028 }
26029
26030
26031 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26032 PyObject *resultobj;
26033 wxWindow *arg1 = (wxWindow *) 0 ;
26034 wxWindowVariant arg2 ;
26035 PyObject * obj0 = 0 ;
26036 PyObject * obj1 = 0 ;
26037 char *kwnames[] = {
26038 (char *) "self",(char *) "variant", NULL
26039 };
26040
26041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26043 if (SWIG_arg_fail(1)) SWIG_fail;
26044 {
26045 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
26046 if (SWIG_arg_fail(2)) SWIG_fail;
26047 }
26048 {
26049 PyThreadState* __tstate = wxPyBeginAllowThreads();
26050 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
26051
26052 wxPyEndAllowThreads(__tstate);
26053 if (PyErr_Occurred()) SWIG_fail;
26054 }
26055 Py_INCREF(Py_None); resultobj = Py_None;
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26063 PyObject *resultobj;
26064 wxWindow *arg1 = (wxWindow *) 0 ;
26065 wxWindowVariant result;
26066 PyObject * obj0 = 0 ;
26067 char *kwnames[] = {
26068 (char *) "self", NULL
26069 };
26070
26071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26073 if (SWIG_arg_fail(1)) SWIG_fail;
26074 {
26075 PyThreadState* __tstate = wxPyBeginAllowThreads();
26076 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26077
26078 wxPyEndAllowThreads(__tstate);
26079 if (PyErr_Occurred()) SWIG_fail;
26080 }
26081 resultobj = SWIG_From_int((result));
26082 return resultobj;
26083 fail:
26084 return NULL;
26085 }
26086
26087
26088 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26089 PyObject *resultobj;
26090 wxWindow *arg1 = (wxWindow *) 0 ;
26091 int arg2 ;
26092 PyObject * obj0 = 0 ;
26093 PyObject * obj1 = 0 ;
26094 char *kwnames[] = {
26095 (char *) "self",(char *) "winid", NULL
26096 };
26097
26098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26100 if (SWIG_arg_fail(1)) SWIG_fail;
26101 {
26102 arg2 = (int)(SWIG_As_int(obj1));
26103 if (SWIG_arg_fail(2)) SWIG_fail;
26104 }
26105 {
26106 PyThreadState* __tstate = wxPyBeginAllowThreads();
26107 (arg1)->SetId(arg2);
26108
26109 wxPyEndAllowThreads(__tstate);
26110 if (PyErr_Occurred()) SWIG_fail;
26111 }
26112 Py_INCREF(Py_None); resultobj = Py_None;
26113 return resultobj;
26114 fail:
26115 return NULL;
26116 }
26117
26118
26119 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26120 PyObject *resultobj;
26121 wxWindow *arg1 = (wxWindow *) 0 ;
26122 int result;
26123 PyObject * obj0 = 0 ;
26124 char *kwnames[] = {
26125 (char *) "self", NULL
26126 };
26127
26128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26130 if (SWIG_arg_fail(1)) SWIG_fail;
26131 {
26132 PyThreadState* __tstate = wxPyBeginAllowThreads();
26133 result = (int)((wxWindow const *)arg1)->GetId();
26134
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 {
26139 resultobj = SWIG_From_int((int)(result));
26140 }
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj;
26149 int result;
26150 char *kwnames[] = {
26151 NULL
26152 };
26153
26154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26155 {
26156 PyThreadState* __tstate = wxPyBeginAllowThreads();
26157 result = (int)wxWindow::NewControlId();
26158
26159 wxPyEndAllowThreads(__tstate);
26160 if (PyErr_Occurred()) SWIG_fail;
26161 }
26162 {
26163 resultobj = SWIG_From_int((int)(result));
26164 }
26165 return resultobj;
26166 fail:
26167 return NULL;
26168 }
26169
26170
26171 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26172 PyObject *resultobj;
26173 int arg1 ;
26174 int result;
26175 PyObject * obj0 = 0 ;
26176 char *kwnames[] = {
26177 (char *) "winid", NULL
26178 };
26179
26180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26181 {
26182 arg1 = (int)(SWIG_As_int(obj0));
26183 if (SWIG_arg_fail(1)) SWIG_fail;
26184 }
26185 {
26186 PyThreadState* __tstate = wxPyBeginAllowThreads();
26187 result = (int)wxWindow::NextControlId(arg1);
26188
26189 wxPyEndAllowThreads(__tstate);
26190 if (PyErr_Occurred()) SWIG_fail;
26191 }
26192 {
26193 resultobj = SWIG_From_int((int)(result));
26194 }
26195 return resultobj;
26196 fail:
26197 return NULL;
26198 }
26199
26200
26201 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26202 PyObject *resultobj;
26203 int arg1 ;
26204 int result;
26205 PyObject * obj0 = 0 ;
26206 char *kwnames[] = {
26207 (char *) "winid", NULL
26208 };
26209
26210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26211 {
26212 arg1 = (int)(SWIG_As_int(obj0));
26213 if (SWIG_arg_fail(1)) SWIG_fail;
26214 }
26215 {
26216 PyThreadState* __tstate = wxPyBeginAllowThreads();
26217 result = (int)wxWindow::PrevControlId(arg1);
26218
26219 wxPyEndAllowThreads(__tstate);
26220 if (PyErr_Occurred()) SWIG_fail;
26221 }
26222 {
26223 resultobj = SWIG_From_int((int)(result));
26224 }
26225 return resultobj;
26226 fail:
26227 return NULL;
26228 }
26229
26230
26231 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26232 PyObject *resultobj;
26233 wxWindow *arg1 = (wxWindow *) 0 ;
26234 wxSize *arg2 = 0 ;
26235 wxSize temp2 ;
26236 PyObject * obj0 = 0 ;
26237 PyObject * obj1 = 0 ;
26238 char *kwnames[] = {
26239 (char *) "self",(char *) "size", NULL
26240 };
26241
26242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26244 if (SWIG_arg_fail(1)) SWIG_fail;
26245 {
26246 arg2 = &temp2;
26247 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26248 }
26249 {
26250 PyThreadState* __tstate = wxPyBeginAllowThreads();
26251 (arg1)->SetSize((wxSize const &)*arg2);
26252
26253 wxPyEndAllowThreads(__tstate);
26254 if (PyErr_Occurred()) SWIG_fail;
26255 }
26256 Py_INCREF(Py_None); resultobj = Py_None;
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26264 PyObject *resultobj;
26265 wxWindow *arg1 = (wxWindow *) 0 ;
26266 int arg2 ;
26267 int arg3 ;
26268 int arg4 ;
26269 int arg5 ;
26270 int arg6 = (int) wxSIZE_AUTO ;
26271 PyObject * obj0 = 0 ;
26272 PyObject * obj1 = 0 ;
26273 PyObject * obj2 = 0 ;
26274 PyObject * obj3 = 0 ;
26275 PyObject * obj4 = 0 ;
26276 PyObject * obj5 = 0 ;
26277 char *kwnames[] = {
26278 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26279 };
26280
26281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26283 if (SWIG_arg_fail(1)) SWIG_fail;
26284 {
26285 arg2 = (int)(SWIG_As_int(obj1));
26286 if (SWIG_arg_fail(2)) SWIG_fail;
26287 }
26288 {
26289 arg3 = (int)(SWIG_As_int(obj2));
26290 if (SWIG_arg_fail(3)) SWIG_fail;
26291 }
26292 {
26293 arg4 = (int)(SWIG_As_int(obj3));
26294 if (SWIG_arg_fail(4)) SWIG_fail;
26295 }
26296 {
26297 arg5 = (int)(SWIG_As_int(obj4));
26298 if (SWIG_arg_fail(5)) SWIG_fail;
26299 }
26300 if (obj5) {
26301 {
26302 arg6 = (int)(SWIG_As_int(obj5));
26303 if (SWIG_arg_fail(6)) SWIG_fail;
26304 }
26305 }
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26309
26310 wxPyEndAllowThreads(__tstate);
26311 if (PyErr_Occurred()) SWIG_fail;
26312 }
26313 Py_INCREF(Py_None); resultobj = Py_None;
26314 return resultobj;
26315 fail:
26316 return NULL;
26317 }
26318
26319
26320 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26321 PyObject *resultobj;
26322 wxWindow *arg1 = (wxWindow *) 0 ;
26323 wxRect *arg2 = 0 ;
26324 int arg3 = (int) wxSIZE_AUTO ;
26325 wxRect temp2 ;
26326 PyObject * obj0 = 0 ;
26327 PyObject * obj1 = 0 ;
26328 PyObject * obj2 = 0 ;
26329 char *kwnames[] = {
26330 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26331 };
26332
26333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26335 if (SWIG_arg_fail(1)) SWIG_fail;
26336 {
26337 arg2 = &temp2;
26338 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26339 }
26340 if (obj2) {
26341 {
26342 arg3 = (int)(SWIG_As_int(obj2));
26343 if (SWIG_arg_fail(3)) SWIG_fail;
26344 }
26345 }
26346 {
26347 PyThreadState* __tstate = wxPyBeginAllowThreads();
26348 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26349
26350 wxPyEndAllowThreads(__tstate);
26351 if (PyErr_Occurred()) SWIG_fail;
26352 }
26353 Py_INCREF(Py_None); resultobj = Py_None;
26354 return resultobj;
26355 fail:
26356 return NULL;
26357 }
26358
26359
26360 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26361 PyObject *resultobj;
26362 wxWindow *arg1 = (wxWindow *) 0 ;
26363 int arg2 ;
26364 int arg3 ;
26365 PyObject * obj0 = 0 ;
26366 PyObject * obj1 = 0 ;
26367 PyObject * obj2 = 0 ;
26368 char *kwnames[] = {
26369 (char *) "self",(char *) "width",(char *) "height", NULL
26370 };
26371
26372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26374 if (SWIG_arg_fail(1)) SWIG_fail;
26375 {
26376 arg2 = (int)(SWIG_As_int(obj1));
26377 if (SWIG_arg_fail(2)) SWIG_fail;
26378 }
26379 {
26380 arg3 = (int)(SWIG_As_int(obj2));
26381 if (SWIG_arg_fail(3)) SWIG_fail;
26382 }
26383 {
26384 PyThreadState* __tstate = wxPyBeginAllowThreads();
26385 (arg1)->SetSize(arg2,arg3);
26386
26387 wxPyEndAllowThreads(__tstate);
26388 if (PyErr_Occurred()) SWIG_fail;
26389 }
26390 Py_INCREF(Py_None); resultobj = Py_None;
26391 return resultobj;
26392 fail:
26393 return NULL;
26394 }
26395
26396
26397 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26398 PyObject *resultobj;
26399 wxWindow *arg1 = (wxWindow *) 0 ;
26400 wxPoint *arg2 = 0 ;
26401 int arg3 = (int) wxSIZE_USE_EXISTING ;
26402 wxPoint temp2 ;
26403 PyObject * obj0 = 0 ;
26404 PyObject * obj1 = 0 ;
26405 PyObject * obj2 = 0 ;
26406 char *kwnames[] = {
26407 (char *) "self",(char *) "pt",(char *) "flags", NULL
26408 };
26409
26410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26412 if (SWIG_arg_fail(1)) SWIG_fail;
26413 {
26414 arg2 = &temp2;
26415 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26416 }
26417 if (obj2) {
26418 {
26419 arg3 = (int)(SWIG_As_int(obj2));
26420 if (SWIG_arg_fail(3)) SWIG_fail;
26421 }
26422 }
26423 {
26424 PyThreadState* __tstate = wxPyBeginAllowThreads();
26425 (arg1)->Move((wxPoint const &)*arg2,arg3);
26426
26427 wxPyEndAllowThreads(__tstate);
26428 if (PyErr_Occurred()) SWIG_fail;
26429 }
26430 Py_INCREF(Py_None); resultobj = Py_None;
26431 return resultobj;
26432 fail:
26433 return NULL;
26434 }
26435
26436
26437 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26438 PyObject *resultobj;
26439 wxWindow *arg1 = (wxWindow *) 0 ;
26440 int arg2 ;
26441 int arg3 ;
26442 int arg4 = (int) wxSIZE_USE_EXISTING ;
26443 PyObject * obj0 = 0 ;
26444 PyObject * obj1 = 0 ;
26445 PyObject * obj2 = 0 ;
26446 PyObject * obj3 = 0 ;
26447 char *kwnames[] = {
26448 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26449 };
26450
26451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26453 if (SWIG_arg_fail(1)) SWIG_fail;
26454 {
26455 arg2 = (int)(SWIG_As_int(obj1));
26456 if (SWIG_arg_fail(2)) SWIG_fail;
26457 }
26458 {
26459 arg3 = (int)(SWIG_As_int(obj2));
26460 if (SWIG_arg_fail(3)) SWIG_fail;
26461 }
26462 if (obj3) {
26463 {
26464 arg4 = (int)(SWIG_As_int(obj3));
26465 if (SWIG_arg_fail(4)) SWIG_fail;
26466 }
26467 }
26468 {
26469 PyThreadState* __tstate = wxPyBeginAllowThreads();
26470 (arg1)->Move(arg2,arg3,arg4);
26471
26472 wxPyEndAllowThreads(__tstate);
26473 if (PyErr_Occurred()) SWIG_fail;
26474 }
26475 Py_INCREF(Py_None); resultobj = Py_None;
26476 return resultobj;
26477 fail:
26478 return NULL;
26479 }
26480
26481
26482 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26483 PyObject *resultobj;
26484 wxWindow *arg1 = (wxWindow *) 0 ;
26485 wxSize const &arg2_defvalue = wxDefaultSize ;
26486 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26487 wxSize temp2 ;
26488 PyObject * obj0 = 0 ;
26489 PyObject * obj1 = 0 ;
26490 char *kwnames[] = {
26491 (char *) "self",(char *) "size", NULL
26492 };
26493
26494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26496 if (SWIG_arg_fail(1)) SWIG_fail;
26497 if (obj1) {
26498 {
26499 arg2 = &temp2;
26500 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26501 }
26502 }
26503 {
26504 PyThreadState* __tstate = wxPyBeginAllowThreads();
26505 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26506
26507 wxPyEndAllowThreads(__tstate);
26508 if (PyErr_Occurred()) SWIG_fail;
26509 }
26510 Py_INCREF(Py_None); resultobj = Py_None;
26511 return resultobj;
26512 fail:
26513 return NULL;
26514 }
26515
26516
26517 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26518 PyObject *resultobj;
26519 wxWindow *arg1 = (wxWindow *) 0 ;
26520 PyObject * obj0 = 0 ;
26521 char *kwnames[] = {
26522 (char *) "self", NULL
26523 };
26524
26525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26527 if (SWIG_arg_fail(1)) SWIG_fail;
26528 {
26529 PyThreadState* __tstate = wxPyBeginAllowThreads();
26530 (arg1)->Raise();
26531
26532 wxPyEndAllowThreads(__tstate);
26533 if (PyErr_Occurred()) SWIG_fail;
26534 }
26535 Py_INCREF(Py_None); resultobj = Py_None;
26536 return resultobj;
26537 fail:
26538 return NULL;
26539 }
26540
26541
26542 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26543 PyObject *resultobj;
26544 wxWindow *arg1 = (wxWindow *) 0 ;
26545 PyObject * obj0 = 0 ;
26546 char *kwnames[] = {
26547 (char *) "self", NULL
26548 };
26549
26550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26552 if (SWIG_arg_fail(1)) SWIG_fail;
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 (arg1)->Lower();
26556
26557 wxPyEndAllowThreads(__tstate);
26558 if (PyErr_Occurred()) SWIG_fail;
26559 }
26560 Py_INCREF(Py_None); resultobj = Py_None;
26561 return resultobj;
26562 fail:
26563 return NULL;
26564 }
26565
26566
26567 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj;
26569 wxWindow *arg1 = (wxWindow *) 0 ;
26570 wxSize *arg2 = 0 ;
26571 wxSize temp2 ;
26572 PyObject * obj0 = 0 ;
26573 PyObject * obj1 = 0 ;
26574 char *kwnames[] = {
26575 (char *) "self",(char *) "size", NULL
26576 };
26577
26578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26580 if (SWIG_arg_fail(1)) SWIG_fail;
26581 {
26582 arg2 = &temp2;
26583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26584 }
26585 {
26586 PyThreadState* __tstate = wxPyBeginAllowThreads();
26587 (arg1)->SetClientSize((wxSize const &)*arg2);
26588
26589 wxPyEndAllowThreads(__tstate);
26590 if (PyErr_Occurred()) SWIG_fail;
26591 }
26592 Py_INCREF(Py_None); resultobj = Py_None;
26593 return resultobj;
26594 fail:
26595 return NULL;
26596 }
26597
26598
26599 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26600 PyObject *resultobj;
26601 wxWindow *arg1 = (wxWindow *) 0 ;
26602 int arg2 ;
26603 int arg3 ;
26604 PyObject * obj0 = 0 ;
26605 PyObject * obj1 = 0 ;
26606 PyObject * obj2 = 0 ;
26607 char *kwnames[] = {
26608 (char *) "self",(char *) "width",(char *) "height", NULL
26609 };
26610
26611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26613 if (SWIG_arg_fail(1)) SWIG_fail;
26614 {
26615 arg2 = (int)(SWIG_As_int(obj1));
26616 if (SWIG_arg_fail(2)) SWIG_fail;
26617 }
26618 {
26619 arg3 = (int)(SWIG_As_int(obj2));
26620 if (SWIG_arg_fail(3)) SWIG_fail;
26621 }
26622 {
26623 PyThreadState* __tstate = wxPyBeginAllowThreads();
26624 (arg1)->SetClientSize(arg2,arg3);
26625
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 Py_INCREF(Py_None); resultobj = Py_None;
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj;
26638 wxWindow *arg1 = (wxWindow *) 0 ;
26639 wxRect *arg2 = 0 ;
26640 wxRect temp2 ;
26641 PyObject * obj0 = 0 ;
26642 PyObject * obj1 = 0 ;
26643 char *kwnames[] = {
26644 (char *) "self",(char *) "rect", NULL
26645 };
26646
26647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26649 if (SWIG_arg_fail(1)) SWIG_fail;
26650 {
26651 arg2 = &temp2;
26652 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26653 }
26654 {
26655 PyThreadState* __tstate = wxPyBeginAllowThreads();
26656 (arg1)->SetClientSize((wxRect const &)*arg2);
26657
26658 wxPyEndAllowThreads(__tstate);
26659 if (PyErr_Occurred()) SWIG_fail;
26660 }
26661 Py_INCREF(Py_None); resultobj = Py_None;
26662 return resultobj;
26663 fail:
26664 return NULL;
26665 }
26666
26667
26668 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26669 PyObject *resultobj;
26670 wxWindow *arg1 = (wxWindow *) 0 ;
26671 wxPoint result;
26672 PyObject * obj0 = 0 ;
26673 char *kwnames[] = {
26674 (char *) "self", NULL
26675 };
26676
26677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26679 if (SWIG_arg_fail(1)) SWIG_fail;
26680 {
26681 PyThreadState* __tstate = wxPyBeginAllowThreads();
26682 result = (arg1)->GetPosition();
26683
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 {
26688 wxPoint * resultptr;
26689 resultptr = new wxPoint((wxPoint &)(result));
26690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26691 }
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26699 PyObject *resultobj;
26700 wxWindow *arg1 = (wxWindow *) 0 ;
26701 int *arg2 = (int *) 0 ;
26702 int *arg3 = (int *) 0 ;
26703 int temp2 ;
26704 int res2 = 0 ;
26705 int temp3 ;
26706 int res3 = 0 ;
26707 PyObject * obj0 = 0 ;
26708 char *kwnames[] = {
26709 (char *) "self", NULL
26710 };
26711
26712 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26713 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26716 if (SWIG_arg_fail(1)) SWIG_fail;
26717 {
26718 PyThreadState* __tstate = wxPyBeginAllowThreads();
26719 (arg1)->GetPosition(arg2,arg3);
26720
26721 wxPyEndAllowThreads(__tstate);
26722 if (PyErr_Occurred()) SWIG_fail;
26723 }
26724 Py_INCREF(Py_None); resultobj = Py_None;
26725 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26726 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26727 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26728 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26729 return resultobj;
26730 fail:
26731 return NULL;
26732 }
26733
26734
26735 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26736 PyObject *resultobj;
26737 wxWindow *arg1 = (wxWindow *) 0 ;
26738 wxSize result;
26739 PyObject * obj0 = 0 ;
26740 char *kwnames[] = {
26741 (char *) "self", NULL
26742 };
26743
26744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26746 if (SWIG_arg_fail(1)) SWIG_fail;
26747 {
26748 PyThreadState* __tstate = wxPyBeginAllowThreads();
26749 result = ((wxWindow const *)arg1)->GetSize();
26750
26751 wxPyEndAllowThreads(__tstate);
26752 if (PyErr_Occurred()) SWIG_fail;
26753 }
26754 {
26755 wxSize * resultptr;
26756 resultptr = new wxSize((wxSize &)(result));
26757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26758 }
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj;
26767 wxWindow *arg1 = (wxWindow *) 0 ;
26768 int *arg2 = (int *) 0 ;
26769 int *arg3 = (int *) 0 ;
26770 int temp2 ;
26771 int res2 = 0 ;
26772 int temp3 ;
26773 int res3 = 0 ;
26774 PyObject * obj0 = 0 ;
26775 char *kwnames[] = {
26776 (char *) "self", NULL
26777 };
26778
26779 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26780 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26783 if (SWIG_arg_fail(1)) SWIG_fail;
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26787
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 Py_INCREF(Py_None); resultobj = Py_None;
26792 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26793 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26794 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26795 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26796 return resultobj;
26797 fail:
26798 return NULL;
26799 }
26800
26801
26802 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26803 PyObject *resultobj;
26804 wxWindow *arg1 = (wxWindow *) 0 ;
26805 wxRect result;
26806 PyObject * obj0 = 0 ;
26807 char *kwnames[] = {
26808 (char *) "self", NULL
26809 };
26810
26811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26813 if (SWIG_arg_fail(1)) SWIG_fail;
26814 {
26815 PyThreadState* __tstate = wxPyBeginAllowThreads();
26816 result = ((wxWindow const *)arg1)->GetRect();
26817
26818 wxPyEndAllowThreads(__tstate);
26819 if (PyErr_Occurred()) SWIG_fail;
26820 }
26821 {
26822 wxRect * resultptr;
26823 resultptr = new wxRect((wxRect &)(result));
26824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26825 }
26826 return resultobj;
26827 fail:
26828 return NULL;
26829 }
26830
26831
26832 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26833 PyObject *resultobj;
26834 wxWindow *arg1 = (wxWindow *) 0 ;
26835 wxSize result;
26836 PyObject * obj0 = 0 ;
26837 char *kwnames[] = {
26838 (char *) "self", NULL
26839 };
26840
26841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26843 if (SWIG_arg_fail(1)) SWIG_fail;
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 result = ((wxWindow const *)arg1)->GetClientSize();
26847
26848 wxPyEndAllowThreads(__tstate);
26849 if (PyErr_Occurred()) SWIG_fail;
26850 }
26851 {
26852 wxSize * resultptr;
26853 resultptr = new wxSize((wxSize &)(result));
26854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26855 }
26856 return resultobj;
26857 fail:
26858 return NULL;
26859 }
26860
26861
26862 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26863 PyObject *resultobj;
26864 wxWindow *arg1 = (wxWindow *) 0 ;
26865 int *arg2 = (int *) 0 ;
26866 int *arg3 = (int *) 0 ;
26867 int temp2 ;
26868 int res2 = 0 ;
26869 int temp3 ;
26870 int res3 = 0 ;
26871 PyObject * obj0 = 0 ;
26872 char *kwnames[] = {
26873 (char *) "self", NULL
26874 };
26875
26876 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26877 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26880 if (SWIG_arg_fail(1)) SWIG_fail;
26881 {
26882 PyThreadState* __tstate = wxPyBeginAllowThreads();
26883 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26884
26885 wxPyEndAllowThreads(__tstate);
26886 if (PyErr_Occurred()) SWIG_fail;
26887 }
26888 Py_INCREF(Py_None); resultobj = Py_None;
26889 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26890 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26891 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26892 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26893 return resultobj;
26894 fail:
26895 return NULL;
26896 }
26897
26898
26899 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26900 PyObject *resultobj;
26901 wxWindow *arg1 = (wxWindow *) 0 ;
26902 wxPoint result;
26903 PyObject * obj0 = 0 ;
26904 char *kwnames[] = {
26905 (char *) "self", NULL
26906 };
26907
26908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26910 if (SWIG_arg_fail(1)) SWIG_fail;
26911 {
26912 PyThreadState* __tstate = wxPyBeginAllowThreads();
26913 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26914
26915 wxPyEndAllowThreads(__tstate);
26916 if (PyErr_Occurred()) SWIG_fail;
26917 }
26918 {
26919 wxPoint * resultptr;
26920 resultptr = new wxPoint((wxPoint &)(result));
26921 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26922 }
26923 return resultobj;
26924 fail:
26925 return NULL;
26926 }
26927
26928
26929 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26930 PyObject *resultobj;
26931 wxWindow *arg1 = (wxWindow *) 0 ;
26932 wxRect result;
26933 PyObject * obj0 = 0 ;
26934 char *kwnames[] = {
26935 (char *) "self", NULL
26936 };
26937
26938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26940 if (SWIG_arg_fail(1)) SWIG_fail;
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 result = ((wxWindow const *)arg1)->GetClientRect();
26944
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 {
26949 wxRect * resultptr;
26950 resultptr = new wxRect((wxRect &)(result));
26951 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26952 }
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj;
26961 wxWindow *arg1 = (wxWindow *) 0 ;
26962 wxSize result;
26963 PyObject * obj0 = 0 ;
26964 char *kwnames[] = {
26965 (char *) "self", NULL
26966 };
26967
26968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26970 if (SWIG_arg_fail(1)) SWIG_fail;
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 result = ((wxWindow const *)arg1)->GetBestSize();
26974
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 {
26979 wxSize * resultptr;
26980 resultptr = new wxSize((wxSize &)(result));
26981 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26982 }
26983 return resultobj;
26984 fail:
26985 return NULL;
26986 }
26987
26988
26989 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26990 PyObject *resultobj;
26991 wxWindow *arg1 = (wxWindow *) 0 ;
26992 int *arg2 = (int *) 0 ;
26993 int *arg3 = (int *) 0 ;
26994 int temp2 ;
26995 int res2 = 0 ;
26996 int temp3 ;
26997 int res3 = 0 ;
26998 PyObject * obj0 = 0 ;
26999 char *kwnames[] = {
27000 (char *) "self", NULL
27001 };
27002
27003 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27004 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27007 if (SWIG_arg_fail(1)) SWIG_fail;
27008 {
27009 PyThreadState* __tstate = wxPyBeginAllowThreads();
27010 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27011
27012 wxPyEndAllowThreads(__tstate);
27013 if (PyErr_Occurred()) SWIG_fail;
27014 }
27015 Py_INCREF(Py_None); resultobj = Py_None;
27016 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27017 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27018 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27019 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27020 return resultobj;
27021 fail:
27022 return NULL;
27023 }
27024
27025
27026 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27027 PyObject *resultobj;
27028 wxWindow *arg1 = (wxWindow *) 0 ;
27029 PyObject * obj0 = 0 ;
27030 char *kwnames[] = {
27031 (char *) "self", NULL
27032 };
27033
27034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27036 if (SWIG_arg_fail(1)) SWIG_fail;
27037 {
27038 PyThreadState* __tstate = wxPyBeginAllowThreads();
27039 (arg1)->InvalidateBestSize();
27040
27041 wxPyEndAllowThreads(__tstate);
27042 if (PyErr_Occurred()) SWIG_fail;
27043 }
27044 Py_INCREF(Py_None); resultobj = Py_None;
27045 return resultobj;
27046 fail:
27047 return NULL;
27048 }
27049
27050
27051 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27052 PyObject *resultobj;
27053 wxWindow *arg1 = (wxWindow *) 0 ;
27054 wxSize *arg2 = 0 ;
27055 wxSize temp2 ;
27056 PyObject * obj0 = 0 ;
27057 PyObject * obj1 = 0 ;
27058 char *kwnames[] = {
27059 (char *) "self",(char *) "size", NULL
27060 };
27061
27062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27064 if (SWIG_arg_fail(1)) SWIG_fail;
27065 {
27066 arg2 = &temp2;
27067 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27068 }
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27072
27073 wxPyEndAllowThreads(__tstate);
27074 if (PyErr_Occurred()) SWIG_fail;
27075 }
27076 Py_INCREF(Py_None); resultobj = Py_None;
27077 return resultobj;
27078 fail:
27079 return NULL;
27080 }
27081
27082
27083 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27084 PyObject *resultobj;
27085 wxWindow *arg1 = (wxWindow *) 0 ;
27086 wxSize result;
27087 PyObject * obj0 = 0 ;
27088 char *kwnames[] = {
27089 (char *) "self", NULL
27090 };
27091
27092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27094 if (SWIG_arg_fail(1)) SWIG_fail;
27095 {
27096 PyThreadState* __tstate = wxPyBeginAllowThreads();
27097 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27098
27099 wxPyEndAllowThreads(__tstate);
27100 if (PyErr_Occurred()) SWIG_fail;
27101 }
27102 {
27103 wxSize * resultptr;
27104 resultptr = new wxSize((wxSize &)(result));
27105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27106 }
27107 return resultobj;
27108 fail:
27109 return NULL;
27110 }
27111
27112
27113 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27114 PyObject *resultobj;
27115 wxWindow *arg1 = (wxWindow *) 0 ;
27116 wxSize result;
27117 PyObject * obj0 = 0 ;
27118 char *kwnames[] = {
27119 (char *) "self", NULL
27120 };
27121
27122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27124 if (SWIG_arg_fail(1)) SWIG_fail;
27125 {
27126 PyThreadState* __tstate = wxPyBeginAllowThreads();
27127 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27128
27129 wxPyEndAllowThreads(__tstate);
27130 if (PyErr_Occurred()) SWIG_fail;
27131 }
27132 {
27133 wxSize * resultptr;
27134 resultptr = new wxSize((wxSize &)(result));
27135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27136 }
27137 return resultobj;
27138 fail:
27139 return NULL;
27140 }
27141
27142
27143 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27144 PyObject *resultobj;
27145 wxWindow *arg1 = (wxWindow *) 0 ;
27146 int arg2 = (int) wxBOTH ;
27147 PyObject * obj0 = 0 ;
27148 PyObject * obj1 = 0 ;
27149 char *kwnames[] = {
27150 (char *) "self",(char *) "direction", NULL
27151 };
27152
27153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27155 if (SWIG_arg_fail(1)) SWIG_fail;
27156 if (obj1) {
27157 {
27158 arg2 = (int)(SWIG_As_int(obj1));
27159 if (SWIG_arg_fail(2)) SWIG_fail;
27160 }
27161 }
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 (arg1)->Center(arg2);
27165
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 Py_INCREF(Py_None); resultobj = Py_None;
27170 return resultobj;
27171 fail:
27172 return NULL;
27173 }
27174
27175
27176 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27177 PyObject *resultobj;
27178 wxWindow *arg1 = (wxWindow *) 0 ;
27179 int arg2 = (int) wxBOTH ;
27180 PyObject * obj0 = 0 ;
27181 PyObject * obj1 = 0 ;
27182 char *kwnames[] = {
27183 (char *) "self",(char *) "dir", NULL
27184 };
27185
27186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27188 if (SWIG_arg_fail(1)) SWIG_fail;
27189 if (obj1) {
27190 {
27191 arg2 = (int)(SWIG_As_int(obj1));
27192 if (SWIG_arg_fail(2)) SWIG_fail;
27193 }
27194 }
27195 {
27196 PyThreadState* __tstate = wxPyBeginAllowThreads();
27197 (arg1)->CenterOnScreen(arg2);
27198
27199 wxPyEndAllowThreads(__tstate);
27200 if (PyErr_Occurred()) SWIG_fail;
27201 }
27202 Py_INCREF(Py_None); resultobj = Py_None;
27203 return resultobj;
27204 fail:
27205 return NULL;
27206 }
27207
27208
27209 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27210 PyObject *resultobj;
27211 wxWindow *arg1 = (wxWindow *) 0 ;
27212 int arg2 = (int) wxBOTH ;
27213 PyObject * obj0 = 0 ;
27214 PyObject * obj1 = 0 ;
27215 char *kwnames[] = {
27216 (char *) "self",(char *) "dir", NULL
27217 };
27218
27219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(1)) SWIG_fail;
27222 if (obj1) {
27223 {
27224 arg2 = (int)(SWIG_As_int(obj1));
27225 if (SWIG_arg_fail(2)) SWIG_fail;
27226 }
27227 }
27228 {
27229 PyThreadState* __tstate = wxPyBeginAllowThreads();
27230 (arg1)->CenterOnParent(arg2);
27231
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 Py_INCREF(Py_None); resultobj = Py_None;
27236 return resultobj;
27237 fail:
27238 return NULL;
27239 }
27240
27241
27242 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27243 PyObject *resultobj;
27244 wxWindow *arg1 = (wxWindow *) 0 ;
27245 PyObject * obj0 = 0 ;
27246 char *kwnames[] = {
27247 (char *) "self", NULL
27248 };
27249
27250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(1)) SWIG_fail;
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 (arg1)->Fit();
27256
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 Py_INCREF(Py_None); resultobj = Py_None;
27261 return resultobj;
27262 fail:
27263 return NULL;
27264 }
27265
27266
27267 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27268 PyObject *resultobj;
27269 wxWindow *arg1 = (wxWindow *) 0 ;
27270 PyObject * obj0 = 0 ;
27271 char *kwnames[] = {
27272 (char *) "self", NULL
27273 };
27274
27275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27277 if (SWIG_arg_fail(1)) SWIG_fail;
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 (arg1)->FitInside();
27281
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 Py_INCREF(Py_None); resultobj = Py_None;
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27293 PyObject *resultobj;
27294 wxWindow *arg1 = (wxWindow *) 0 ;
27295 int arg2 ;
27296 int arg3 ;
27297 int arg4 = (int) -1 ;
27298 int arg5 = (int) -1 ;
27299 int arg6 = (int) -1 ;
27300 int arg7 = (int) -1 ;
27301 PyObject * obj0 = 0 ;
27302 PyObject * obj1 = 0 ;
27303 PyObject * obj2 = 0 ;
27304 PyObject * obj3 = 0 ;
27305 PyObject * obj4 = 0 ;
27306 PyObject * obj5 = 0 ;
27307 PyObject * obj6 = 0 ;
27308 char *kwnames[] = {
27309 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27310 };
27311
27312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27314 if (SWIG_arg_fail(1)) SWIG_fail;
27315 {
27316 arg2 = (int)(SWIG_As_int(obj1));
27317 if (SWIG_arg_fail(2)) SWIG_fail;
27318 }
27319 {
27320 arg3 = (int)(SWIG_As_int(obj2));
27321 if (SWIG_arg_fail(3)) SWIG_fail;
27322 }
27323 if (obj3) {
27324 {
27325 arg4 = (int)(SWIG_As_int(obj3));
27326 if (SWIG_arg_fail(4)) SWIG_fail;
27327 }
27328 }
27329 if (obj4) {
27330 {
27331 arg5 = (int)(SWIG_As_int(obj4));
27332 if (SWIG_arg_fail(5)) SWIG_fail;
27333 }
27334 }
27335 if (obj5) {
27336 {
27337 arg6 = (int)(SWIG_As_int(obj5));
27338 if (SWIG_arg_fail(6)) SWIG_fail;
27339 }
27340 }
27341 if (obj6) {
27342 {
27343 arg7 = (int)(SWIG_As_int(obj6));
27344 if (SWIG_arg_fail(7)) SWIG_fail;
27345 }
27346 }
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27350
27351 wxPyEndAllowThreads(__tstate);
27352 if (PyErr_Occurred()) SWIG_fail;
27353 }
27354 Py_INCREF(Py_None); resultobj = Py_None;
27355 return resultobj;
27356 fail:
27357 return NULL;
27358 }
27359
27360
27361 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27362 PyObject *resultobj;
27363 wxWindow *arg1 = (wxWindow *) 0 ;
27364 wxSize *arg2 = 0 ;
27365 wxSize const &arg3_defvalue = wxDefaultSize ;
27366 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27367 wxSize const &arg4_defvalue = wxDefaultSize ;
27368 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27369 wxSize temp2 ;
27370 wxSize temp3 ;
27371 wxSize temp4 ;
27372 PyObject * obj0 = 0 ;
27373 PyObject * obj1 = 0 ;
27374 PyObject * obj2 = 0 ;
27375 PyObject * obj3 = 0 ;
27376 char *kwnames[] = {
27377 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27378 };
27379
27380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27382 if (SWIG_arg_fail(1)) SWIG_fail;
27383 {
27384 arg2 = &temp2;
27385 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27386 }
27387 if (obj2) {
27388 {
27389 arg3 = &temp3;
27390 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27391 }
27392 }
27393 if (obj3) {
27394 {
27395 arg4 = &temp4;
27396 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27397 }
27398 }
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27402
27403 wxPyEndAllowThreads(__tstate);
27404 if (PyErr_Occurred()) SWIG_fail;
27405 }
27406 Py_INCREF(Py_None); resultobj = Py_None;
27407 return resultobj;
27408 fail:
27409 return NULL;
27410 }
27411
27412
27413 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27414 PyObject *resultobj;
27415 wxWindow *arg1 = (wxWindow *) 0 ;
27416 int arg2 ;
27417 int arg3 ;
27418 int arg4 = (int) -1 ;
27419 int arg5 = (int) -1 ;
27420 PyObject * obj0 = 0 ;
27421 PyObject * obj1 = 0 ;
27422 PyObject * obj2 = 0 ;
27423 PyObject * obj3 = 0 ;
27424 PyObject * obj4 = 0 ;
27425 char *kwnames[] = {
27426 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27427 };
27428
27429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27431 if (SWIG_arg_fail(1)) SWIG_fail;
27432 {
27433 arg2 = (int)(SWIG_As_int(obj1));
27434 if (SWIG_arg_fail(2)) SWIG_fail;
27435 }
27436 {
27437 arg3 = (int)(SWIG_As_int(obj2));
27438 if (SWIG_arg_fail(3)) SWIG_fail;
27439 }
27440 if (obj3) {
27441 {
27442 arg4 = (int)(SWIG_As_int(obj3));
27443 if (SWIG_arg_fail(4)) SWIG_fail;
27444 }
27445 }
27446 if (obj4) {
27447 {
27448 arg5 = (int)(SWIG_As_int(obj4));
27449 if (SWIG_arg_fail(5)) SWIG_fail;
27450 }
27451 }
27452 {
27453 PyThreadState* __tstate = wxPyBeginAllowThreads();
27454 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27455
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 Py_INCREF(Py_None); resultobj = Py_None;
27460 return resultobj;
27461 fail:
27462 return NULL;
27463 }
27464
27465
27466 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27467 PyObject *resultobj;
27468 wxWindow *arg1 = (wxWindow *) 0 ;
27469 wxSize *arg2 = 0 ;
27470 wxSize const &arg3_defvalue = wxDefaultSize ;
27471 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27472 wxSize temp2 ;
27473 wxSize temp3 ;
27474 PyObject * obj0 = 0 ;
27475 PyObject * obj1 = 0 ;
27476 PyObject * obj2 = 0 ;
27477 char *kwnames[] = {
27478 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27479 };
27480
27481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27483 if (SWIG_arg_fail(1)) SWIG_fail;
27484 {
27485 arg2 = &temp2;
27486 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27487 }
27488 if (obj2) {
27489 {
27490 arg3 = &temp3;
27491 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27492 }
27493 }
27494 {
27495 PyThreadState* __tstate = wxPyBeginAllowThreads();
27496 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27497
27498 wxPyEndAllowThreads(__tstate);
27499 if (PyErr_Occurred()) SWIG_fail;
27500 }
27501 Py_INCREF(Py_None); resultobj = Py_None;
27502 return resultobj;
27503 fail:
27504 return NULL;
27505 }
27506
27507
27508 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27509 PyObject *resultobj;
27510 wxWindow *arg1 = (wxWindow *) 0 ;
27511 wxSize result;
27512 PyObject * obj0 = 0 ;
27513 char *kwnames[] = {
27514 (char *) "self", NULL
27515 };
27516
27517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27519 if (SWIG_arg_fail(1)) SWIG_fail;
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 result = ((wxWindow const *)arg1)->GetMaxSize();
27523
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 {
27528 wxSize * resultptr;
27529 resultptr = new wxSize((wxSize &)(result));
27530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27531 }
27532 return resultobj;
27533 fail:
27534 return NULL;
27535 }
27536
27537
27538 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27539 PyObject *resultobj;
27540 wxWindow *arg1 = (wxWindow *) 0 ;
27541 wxSize result;
27542 PyObject * obj0 = 0 ;
27543 char *kwnames[] = {
27544 (char *) "self", NULL
27545 };
27546
27547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27549 if (SWIG_arg_fail(1)) SWIG_fail;
27550 {
27551 PyThreadState* __tstate = wxPyBeginAllowThreads();
27552 result = ((wxWindow const *)arg1)->GetMinSize();
27553
27554 wxPyEndAllowThreads(__tstate);
27555 if (PyErr_Occurred()) SWIG_fail;
27556 }
27557 {
27558 wxSize * resultptr;
27559 resultptr = new wxSize((wxSize &)(result));
27560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27561 }
27562 return resultobj;
27563 fail:
27564 return NULL;
27565 }
27566
27567
27568 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27569 PyObject *resultobj;
27570 wxWindow *arg1 = (wxWindow *) 0 ;
27571 wxSize *arg2 = 0 ;
27572 wxSize temp2 ;
27573 PyObject * obj0 = 0 ;
27574 PyObject * obj1 = 0 ;
27575 char *kwnames[] = {
27576 (char *) "self",(char *) "minSize", NULL
27577 };
27578
27579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27581 if (SWIG_arg_fail(1)) SWIG_fail;
27582 {
27583 arg2 = &temp2;
27584 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27585 }
27586 {
27587 PyThreadState* __tstate = wxPyBeginAllowThreads();
27588 (arg1)->SetMinSize((wxSize const &)*arg2);
27589
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 Py_INCREF(Py_None); resultobj = Py_None;
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27601 PyObject *resultobj;
27602 wxWindow *arg1 = (wxWindow *) 0 ;
27603 wxSize *arg2 = 0 ;
27604 wxSize temp2 ;
27605 PyObject * obj0 = 0 ;
27606 PyObject * obj1 = 0 ;
27607 char *kwnames[] = {
27608 (char *) "self",(char *) "maxSize", NULL
27609 };
27610
27611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27613 if (SWIG_arg_fail(1)) SWIG_fail;
27614 {
27615 arg2 = &temp2;
27616 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27617 }
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 (arg1)->SetMaxSize((wxSize const &)*arg2);
27621
27622 wxPyEndAllowThreads(__tstate);
27623 if (PyErr_Occurred()) SWIG_fail;
27624 }
27625 Py_INCREF(Py_None); resultobj = Py_None;
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27633 PyObject *resultobj;
27634 wxWindow *arg1 = (wxWindow *) 0 ;
27635 int result;
27636 PyObject * obj0 = 0 ;
27637 char *kwnames[] = {
27638 (char *) "self", NULL
27639 };
27640
27641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27643 if (SWIG_arg_fail(1)) SWIG_fail;
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27647
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 {
27652 resultobj = SWIG_From_int((int)(result));
27653 }
27654 return resultobj;
27655 fail:
27656 return NULL;
27657 }
27658
27659
27660 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27661 PyObject *resultobj;
27662 wxWindow *arg1 = (wxWindow *) 0 ;
27663 int result;
27664 PyObject * obj0 = 0 ;
27665 char *kwnames[] = {
27666 (char *) "self", NULL
27667 };
27668
27669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27671 if (SWIG_arg_fail(1)) SWIG_fail;
27672 {
27673 PyThreadState* __tstate = wxPyBeginAllowThreads();
27674 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27675
27676 wxPyEndAllowThreads(__tstate);
27677 if (PyErr_Occurred()) SWIG_fail;
27678 }
27679 {
27680 resultobj = SWIG_From_int((int)(result));
27681 }
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27689 PyObject *resultobj;
27690 wxWindow *arg1 = (wxWindow *) 0 ;
27691 int result;
27692 PyObject * obj0 = 0 ;
27693 char *kwnames[] = {
27694 (char *) "self", NULL
27695 };
27696
27697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27699 if (SWIG_arg_fail(1)) SWIG_fail;
27700 {
27701 PyThreadState* __tstate = wxPyBeginAllowThreads();
27702 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27703
27704 wxPyEndAllowThreads(__tstate);
27705 if (PyErr_Occurred()) SWIG_fail;
27706 }
27707 {
27708 resultobj = SWIG_From_int((int)(result));
27709 }
27710 return resultobj;
27711 fail:
27712 return NULL;
27713 }
27714
27715
27716 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27717 PyObject *resultobj;
27718 wxWindow *arg1 = (wxWindow *) 0 ;
27719 int result;
27720 PyObject * obj0 = 0 ;
27721 char *kwnames[] = {
27722 (char *) "self", NULL
27723 };
27724
27725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27727 if (SWIG_arg_fail(1)) SWIG_fail;
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27731
27732 wxPyEndAllowThreads(__tstate);
27733 if (PyErr_Occurred()) SWIG_fail;
27734 }
27735 {
27736 resultobj = SWIG_From_int((int)(result));
27737 }
27738 return resultobj;
27739 fail:
27740 return NULL;
27741 }
27742
27743
27744 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27745 PyObject *resultobj;
27746 wxWindow *arg1 = (wxWindow *) 0 ;
27747 wxSize *arg2 = 0 ;
27748 wxSize temp2 ;
27749 PyObject * obj0 = 0 ;
27750 PyObject * obj1 = 0 ;
27751 char *kwnames[] = {
27752 (char *) "self",(char *) "size", NULL
27753 };
27754
27755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27757 if (SWIG_arg_fail(1)) SWIG_fail;
27758 {
27759 arg2 = &temp2;
27760 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27761 }
27762 {
27763 PyThreadState* __tstate = wxPyBeginAllowThreads();
27764 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27765
27766 wxPyEndAllowThreads(__tstate);
27767 if (PyErr_Occurred()) SWIG_fail;
27768 }
27769 Py_INCREF(Py_None); resultobj = Py_None;
27770 return resultobj;
27771 fail:
27772 return NULL;
27773 }
27774
27775
27776 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27777 PyObject *resultobj;
27778 wxWindow *arg1 = (wxWindow *) 0 ;
27779 int arg2 ;
27780 int arg3 ;
27781 PyObject * obj0 = 0 ;
27782 PyObject * obj1 = 0 ;
27783 PyObject * obj2 = 0 ;
27784 char *kwnames[] = {
27785 (char *) "self",(char *) "w",(char *) "h", NULL
27786 };
27787
27788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27790 if (SWIG_arg_fail(1)) SWIG_fail;
27791 {
27792 arg2 = (int)(SWIG_As_int(obj1));
27793 if (SWIG_arg_fail(2)) SWIG_fail;
27794 }
27795 {
27796 arg3 = (int)(SWIG_As_int(obj2));
27797 if (SWIG_arg_fail(3)) SWIG_fail;
27798 }
27799 {
27800 PyThreadState* __tstate = wxPyBeginAllowThreads();
27801 (arg1)->SetVirtualSize(arg2,arg3);
27802
27803 wxPyEndAllowThreads(__tstate);
27804 if (PyErr_Occurred()) SWIG_fail;
27805 }
27806 Py_INCREF(Py_None); resultobj = Py_None;
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27814 PyObject *resultobj;
27815 wxWindow *arg1 = (wxWindow *) 0 ;
27816 wxSize result;
27817 PyObject * obj0 = 0 ;
27818 char *kwnames[] = {
27819 (char *) "self", NULL
27820 };
27821
27822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27824 if (SWIG_arg_fail(1)) SWIG_fail;
27825 {
27826 PyThreadState* __tstate = wxPyBeginAllowThreads();
27827 result = ((wxWindow const *)arg1)->GetVirtualSize();
27828
27829 wxPyEndAllowThreads(__tstate);
27830 if (PyErr_Occurred()) SWIG_fail;
27831 }
27832 {
27833 wxSize * resultptr;
27834 resultptr = new wxSize((wxSize &)(result));
27835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27836 }
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27844 PyObject *resultobj;
27845 wxWindow *arg1 = (wxWindow *) 0 ;
27846 int *arg2 = (int *) 0 ;
27847 int *arg3 = (int *) 0 ;
27848 int temp2 ;
27849 int res2 = 0 ;
27850 int temp3 ;
27851 int res3 = 0 ;
27852 PyObject * obj0 = 0 ;
27853 char *kwnames[] = {
27854 (char *) "self", NULL
27855 };
27856
27857 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27858 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27861 if (SWIG_arg_fail(1)) SWIG_fail;
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27865
27866 wxPyEndAllowThreads(__tstate);
27867 if (PyErr_Occurred()) SWIG_fail;
27868 }
27869 Py_INCREF(Py_None); resultobj = Py_None;
27870 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27871 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27872 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27873 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27874 return resultobj;
27875 fail:
27876 return NULL;
27877 }
27878
27879
27880 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27881 PyObject *resultobj;
27882 wxWindow *arg1 = (wxWindow *) 0 ;
27883 wxSize result;
27884 PyObject * obj0 = 0 ;
27885 char *kwnames[] = {
27886 (char *) "self", NULL
27887 };
27888
27889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27891 if (SWIG_arg_fail(1)) SWIG_fail;
27892 {
27893 PyThreadState* __tstate = wxPyBeginAllowThreads();
27894 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27895
27896 wxPyEndAllowThreads(__tstate);
27897 if (PyErr_Occurred()) SWIG_fail;
27898 }
27899 {
27900 wxSize * resultptr;
27901 resultptr = new wxSize((wxSize &)(result));
27902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27903 }
27904 return resultobj;
27905 fail:
27906 return NULL;
27907 }
27908
27909
27910 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27911 PyObject *resultobj;
27912 wxWindow *arg1 = (wxWindow *) 0 ;
27913 bool arg2 = (bool) true ;
27914 bool result;
27915 PyObject * obj0 = 0 ;
27916 PyObject * obj1 = 0 ;
27917 char *kwnames[] = {
27918 (char *) "self",(char *) "show", NULL
27919 };
27920
27921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27923 if (SWIG_arg_fail(1)) SWIG_fail;
27924 if (obj1) {
27925 {
27926 arg2 = (bool)(SWIG_As_bool(obj1));
27927 if (SWIG_arg_fail(2)) SWIG_fail;
27928 }
27929 }
27930 {
27931 PyThreadState* __tstate = wxPyBeginAllowThreads();
27932 result = (bool)(arg1)->Show(arg2);
27933
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 {
27938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27939 }
27940 return resultobj;
27941 fail:
27942 return NULL;
27943 }
27944
27945
27946 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27947 PyObject *resultobj;
27948 wxWindow *arg1 = (wxWindow *) 0 ;
27949 bool result;
27950 PyObject * obj0 = 0 ;
27951 char *kwnames[] = {
27952 (char *) "self", NULL
27953 };
27954
27955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27957 if (SWIG_arg_fail(1)) SWIG_fail;
27958 {
27959 PyThreadState* __tstate = wxPyBeginAllowThreads();
27960 result = (bool)(arg1)->Hide();
27961
27962 wxPyEndAllowThreads(__tstate);
27963 if (PyErr_Occurred()) SWIG_fail;
27964 }
27965 {
27966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27967 }
27968 return resultobj;
27969 fail:
27970 return NULL;
27971 }
27972
27973
27974 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27975 PyObject *resultobj;
27976 wxWindow *arg1 = (wxWindow *) 0 ;
27977 bool arg2 = (bool) true ;
27978 bool result;
27979 PyObject * obj0 = 0 ;
27980 PyObject * obj1 = 0 ;
27981 char *kwnames[] = {
27982 (char *) "self",(char *) "enable", NULL
27983 };
27984
27985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27987 if (SWIG_arg_fail(1)) SWIG_fail;
27988 if (obj1) {
27989 {
27990 arg2 = (bool)(SWIG_As_bool(obj1));
27991 if (SWIG_arg_fail(2)) SWIG_fail;
27992 }
27993 }
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 result = (bool)(arg1)->Enable(arg2);
27997
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 {
28002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28003 }
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj;
28012 wxWindow *arg1 = (wxWindow *) 0 ;
28013 bool result;
28014 PyObject * obj0 = 0 ;
28015 char *kwnames[] = {
28016 (char *) "self", NULL
28017 };
28018
28019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28021 if (SWIG_arg_fail(1)) SWIG_fail;
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 result = (bool)(arg1)->Disable();
28025
28026 wxPyEndAllowThreads(__tstate);
28027 if (PyErr_Occurred()) SWIG_fail;
28028 }
28029 {
28030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28031 }
28032 return resultobj;
28033 fail:
28034 return NULL;
28035 }
28036
28037
28038 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28039 PyObject *resultobj;
28040 wxWindow *arg1 = (wxWindow *) 0 ;
28041 bool result;
28042 PyObject * obj0 = 0 ;
28043 char *kwnames[] = {
28044 (char *) "self", NULL
28045 };
28046
28047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28049 if (SWIG_arg_fail(1)) SWIG_fail;
28050 {
28051 PyThreadState* __tstate = wxPyBeginAllowThreads();
28052 result = (bool)((wxWindow const *)arg1)->IsShown();
28053
28054 wxPyEndAllowThreads(__tstate);
28055 if (PyErr_Occurred()) SWIG_fail;
28056 }
28057 {
28058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28059 }
28060 return resultobj;
28061 fail:
28062 return NULL;
28063 }
28064
28065
28066 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28067 PyObject *resultobj;
28068 wxWindow *arg1 = (wxWindow *) 0 ;
28069 bool result;
28070 PyObject * obj0 = 0 ;
28071 char *kwnames[] = {
28072 (char *) "self", NULL
28073 };
28074
28075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28077 if (SWIG_arg_fail(1)) SWIG_fail;
28078 {
28079 PyThreadState* __tstate = wxPyBeginAllowThreads();
28080 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28081
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 {
28086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28087 }
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28095 PyObject *resultobj;
28096 wxWindow *arg1 = (wxWindow *) 0 ;
28097 long arg2 ;
28098 PyObject * obj0 = 0 ;
28099 PyObject * obj1 = 0 ;
28100 char *kwnames[] = {
28101 (char *) "self",(char *) "style", NULL
28102 };
28103
28104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28106 if (SWIG_arg_fail(1)) SWIG_fail;
28107 {
28108 arg2 = (long)(SWIG_As_long(obj1));
28109 if (SWIG_arg_fail(2)) SWIG_fail;
28110 }
28111 {
28112 PyThreadState* __tstate = wxPyBeginAllowThreads();
28113 (arg1)->SetWindowStyleFlag(arg2);
28114
28115 wxPyEndAllowThreads(__tstate);
28116 if (PyErr_Occurred()) SWIG_fail;
28117 }
28118 Py_INCREF(Py_None); resultobj = Py_None;
28119 return resultobj;
28120 fail:
28121 return NULL;
28122 }
28123
28124
28125 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28126 PyObject *resultobj;
28127 wxWindow *arg1 = (wxWindow *) 0 ;
28128 long result;
28129 PyObject * obj0 = 0 ;
28130 char *kwnames[] = {
28131 (char *) "self", NULL
28132 };
28133
28134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28136 if (SWIG_arg_fail(1)) SWIG_fail;
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28140
28141 wxPyEndAllowThreads(__tstate);
28142 if (PyErr_Occurred()) SWIG_fail;
28143 }
28144 {
28145 resultobj = SWIG_From_long((long)(result));
28146 }
28147 return resultobj;
28148 fail:
28149 return NULL;
28150 }
28151
28152
28153 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28154 PyObject *resultobj;
28155 wxWindow *arg1 = (wxWindow *) 0 ;
28156 int arg2 ;
28157 bool result;
28158 PyObject * obj0 = 0 ;
28159 PyObject * obj1 = 0 ;
28160 char *kwnames[] = {
28161 (char *) "self",(char *) "flag", NULL
28162 };
28163
28164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28166 if (SWIG_arg_fail(1)) SWIG_fail;
28167 {
28168 arg2 = (int)(SWIG_As_int(obj1));
28169 if (SWIG_arg_fail(2)) SWIG_fail;
28170 }
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28174
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 {
28179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28180 }
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28188 PyObject *resultobj;
28189 wxWindow *arg1 = (wxWindow *) 0 ;
28190 bool result;
28191 PyObject * obj0 = 0 ;
28192 char *kwnames[] = {
28193 (char *) "self", NULL
28194 };
28195
28196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28198 if (SWIG_arg_fail(1)) SWIG_fail;
28199 {
28200 PyThreadState* __tstate = wxPyBeginAllowThreads();
28201 result = (bool)((wxWindow const *)arg1)->IsRetained();
28202
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 {
28207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28208 }
28209 return resultobj;
28210 fail:
28211 return NULL;
28212 }
28213
28214
28215 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28216 PyObject *resultobj;
28217 wxWindow *arg1 = (wxWindow *) 0 ;
28218 long arg2 ;
28219 PyObject * obj0 = 0 ;
28220 PyObject * obj1 = 0 ;
28221 char *kwnames[] = {
28222 (char *) "self",(char *) "exStyle", NULL
28223 };
28224
28225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28227 if (SWIG_arg_fail(1)) SWIG_fail;
28228 {
28229 arg2 = (long)(SWIG_As_long(obj1));
28230 if (SWIG_arg_fail(2)) SWIG_fail;
28231 }
28232 {
28233 PyThreadState* __tstate = wxPyBeginAllowThreads();
28234 (arg1)->SetExtraStyle(arg2);
28235
28236 wxPyEndAllowThreads(__tstate);
28237 if (PyErr_Occurred()) SWIG_fail;
28238 }
28239 Py_INCREF(Py_None); resultobj = Py_None;
28240 return resultobj;
28241 fail:
28242 return NULL;
28243 }
28244
28245
28246 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28247 PyObject *resultobj;
28248 wxWindow *arg1 = (wxWindow *) 0 ;
28249 long result;
28250 PyObject * obj0 = 0 ;
28251 char *kwnames[] = {
28252 (char *) "self", NULL
28253 };
28254
28255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28257 if (SWIG_arg_fail(1)) SWIG_fail;
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28261
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 {
28266 resultobj = SWIG_From_long((long)(result));
28267 }
28268 return resultobj;
28269 fail:
28270 return NULL;
28271 }
28272
28273
28274 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj;
28276 wxWindow *arg1 = (wxWindow *) 0 ;
28277 bool arg2 = (bool) true ;
28278 PyObject * obj0 = 0 ;
28279 PyObject * obj1 = 0 ;
28280 char *kwnames[] = {
28281 (char *) "self",(char *) "modal", NULL
28282 };
28283
28284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28286 if (SWIG_arg_fail(1)) SWIG_fail;
28287 if (obj1) {
28288 {
28289 arg2 = (bool)(SWIG_As_bool(obj1));
28290 if (SWIG_arg_fail(2)) SWIG_fail;
28291 }
28292 }
28293 {
28294 PyThreadState* __tstate = wxPyBeginAllowThreads();
28295 (arg1)->MakeModal(arg2);
28296
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 Py_INCREF(Py_None); resultobj = Py_None;
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28308 PyObject *resultobj;
28309 wxWindow *arg1 = (wxWindow *) 0 ;
28310 bool arg2 ;
28311 PyObject * obj0 = 0 ;
28312 PyObject * obj1 = 0 ;
28313 char *kwnames[] = {
28314 (char *) "self",(char *) "enableTheme", NULL
28315 };
28316
28317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28319 if (SWIG_arg_fail(1)) SWIG_fail;
28320 {
28321 arg2 = (bool)(SWIG_As_bool(obj1));
28322 if (SWIG_arg_fail(2)) SWIG_fail;
28323 }
28324 {
28325 PyThreadState* __tstate = wxPyBeginAllowThreads();
28326 (arg1)->SetThemeEnabled(arg2);
28327
28328 wxPyEndAllowThreads(__tstate);
28329 if (PyErr_Occurred()) SWIG_fail;
28330 }
28331 Py_INCREF(Py_None); resultobj = Py_None;
28332 return resultobj;
28333 fail:
28334 return NULL;
28335 }
28336
28337
28338 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28339 PyObject *resultobj;
28340 wxWindow *arg1 = (wxWindow *) 0 ;
28341 bool result;
28342 PyObject * obj0 = 0 ;
28343 char *kwnames[] = {
28344 (char *) "self", NULL
28345 };
28346
28347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28349 if (SWIG_arg_fail(1)) SWIG_fail;
28350 {
28351 PyThreadState* __tstate = wxPyBeginAllowThreads();
28352 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28353
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 {
28358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28359 }
28360 return resultobj;
28361 fail:
28362 return NULL;
28363 }
28364
28365
28366 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28367 PyObject *resultobj;
28368 wxWindow *arg1 = (wxWindow *) 0 ;
28369 PyObject * obj0 = 0 ;
28370 char *kwnames[] = {
28371 (char *) "self", NULL
28372 };
28373
28374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28376 if (SWIG_arg_fail(1)) SWIG_fail;
28377 {
28378 PyThreadState* __tstate = wxPyBeginAllowThreads();
28379 (arg1)->SetFocus();
28380
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 Py_INCREF(Py_None); resultobj = Py_None;
28385 return resultobj;
28386 fail:
28387 return NULL;
28388 }
28389
28390
28391 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28392 PyObject *resultobj;
28393 wxWindow *arg1 = (wxWindow *) 0 ;
28394 PyObject * obj0 = 0 ;
28395 char *kwnames[] = {
28396 (char *) "self", NULL
28397 };
28398
28399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28401 if (SWIG_arg_fail(1)) SWIG_fail;
28402 {
28403 PyThreadState* __tstate = wxPyBeginAllowThreads();
28404 (arg1)->SetFocusFromKbd();
28405
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 Py_INCREF(Py_None); resultobj = Py_None;
28410 return resultobj;
28411 fail:
28412 return NULL;
28413 }
28414
28415
28416 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28417 PyObject *resultobj;
28418 wxWindow *result;
28419 char *kwnames[] = {
28420 NULL
28421 };
28422
28423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28424 {
28425 if (!wxPyCheckForApp()) SWIG_fail;
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 result = (wxWindow *)wxWindow::FindFocus();
28428
28429 wxPyEndAllowThreads(__tstate);
28430 if (PyErr_Occurred()) SWIG_fail;
28431 }
28432 {
28433 resultobj = wxPyMake_wxObject(result, 0);
28434 }
28435 return resultobj;
28436 fail:
28437 return NULL;
28438 }
28439
28440
28441 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28442 PyObject *resultobj;
28443 wxWindow *arg1 = (wxWindow *) 0 ;
28444 bool result;
28445 PyObject * obj0 = 0 ;
28446 char *kwnames[] = {
28447 (char *) "self", NULL
28448 };
28449
28450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28452 if (SWIG_arg_fail(1)) SWIG_fail;
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28456
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 {
28461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28462 }
28463 return resultobj;
28464 fail:
28465 return NULL;
28466 }
28467
28468
28469 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28470 PyObject *resultobj;
28471 wxWindow *arg1 = (wxWindow *) 0 ;
28472 bool result;
28473 PyObject * obj0 = 0 ;
28474 char *kwnames[] = {
28475 (char *) "self", NULL
28476 };
28477
28478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28480 if (SWIG_arg_fail(1)) SWIG_fail;
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28484
28485 wxPyEndAllowThreads(__tstate);
28486 if (PyErr_Occurred()) SWIG_fail;
28487 }
28488 {
28489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28490 }
28491 return resultobj;
28492 fail:
28493 return NULL;
28494 }
28495
28496
28497 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28498 PyObject *resultobj;
28499 wxWindow *arg1 = (wxWindow *) 0 ;
28500 wxWindow *result;
28501 PyObject * obj0 = 0 ;
28502 char *kwnames[] = {
28503 (char *) "self", NULL
28504 };
28505
28506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28508 if (SWIG_arg_fail(1)) SWIG_fail;
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28512
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 {
28517 resultobj = wxPyMake_wxObject(result, 0);
28518 }
28519 return resultobj;
28520 fail:
28521 return NULL;
28522 }
28523
28524
28525 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28526 PyObject *resultobj;
28527 wxWindow *arg1 = (wxWindow *) 0 ;
28528 wxWindow *arg2 = (wxWindow *) 0 ;
28529 wxWindow *result;
28530 PyObject * obj0 = 0 ;
28531 PyObject * obj1 = 0 ;
28532 char *kwnames[] = {
28533 (char *) "self",(char *) "child", NULL
28534 };
28535
28536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28538 if (SWIG_arg_fail(1)) SWIG_fail;
28539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28540 if (SWIG_arg_fail(2)) SWIG_fail;
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28544
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 {
28549 resultobj = wxPyMake_wxObject(result, 0);
28550 }
28551 return resultobj;
28552 fail:
28553 return NULL;
28554 }
28555
28556
28557 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28558 PyObject *resultobj;
28559 wxWindow *arg1 = (wxWindow *) 0 ;
28560 wxWindow *arg2 = (wxWindow *) 0 ;
28561 PyObject * obj0 = 0 ;
28562 PyObject * obj1 = 0 ;
28563 char *kwnames[] = {
28564 (char *) "self",(char *) "win", NULL
28565 };
28566
28567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28569 if (SWIG_arg_fail(1)) SWIG_fail;
28570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28571 if (SWIG_arg_fail(2)) SWIG_fail;
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 (arg1)->SetTmpDefaultItem(arg2);
28575
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 Py_INCREF(Py_None); resultobj = Py_None;
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj;
28588 wxWindow *arg1 = (wxWindow *) 0 ;
28589 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28590 bool result;
28591 PyObject * obj0 = 0 ;
28592 PyObject * obj1 = 0 ;
28593 char *kwnames[] = {
28594 (char *) "self",(char *) "flags", NULL
28595 };
28596
28597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28599 if (SWIG_arg_fail(1)) SWIG_fail;
28600 if (obj1) {
28601 {
28602 arg2 = (int)(SWIG_As_int(obj1));
28603 if (SWIG_arg_fail(2)) SWIG_fail;
28604 }
28605 }
28606 {
28607 PyThreadState* __tstate = wxPyBeginAllowThreads();
28608 result = (bool)(arg1)->Navigate(arg2);
28609
28610 wxPyEndAllowThreads(__tstate);
28611 if (PyErr_Occurred()) SWIG_fail;
28612 }
28613 {
28614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28615 }
28616 return resultobj;
28617 fail:
28618 return NULL;
28619 }
28620
28621
28622 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28623 PyObject *resultobj;
28624 wxWindow *arg1 = (wxWindow *) 0 ;
28625 wxWindow *arg2 = (wxWindow *) 0 ;
28626 PyObject * obj0 = 0 ;
28627 PyObject * obj1 = 0 ;
28628 char *kwnames[] = {
28629 (char *) "self",(char *) "win", NULL
28630 };
28631
28632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28634 if (SWIG_arg_fail(1)) SWIG_fail;
28635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28636 if (SWIG_arg_fail(2)) SWIG_fail;
28637 {
28638 PyThreadState* __tstate = wxPyBeginAllowThreads();
28639 (arg1)->MoveAfterInTabOrder(arg2);
28640
28641 wxPyEndAllowThreads(__tstate);
28642 if (PyErr_Occurred()) SWIG_fail;
28643 }
28644 Py_INCREF(Py_None); resultobj = Py_None;
28645 return resultobj;
28646 fail:
28647 return NULL;
28648 }
28649
28650
28651 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28652 PyObject *resultobj;
28653 wxWindow *arg1 = (wxWindow *) 0 ;
28654 wxWindow *arg2 = (wxWindow *) 0 ;
28655 PyObject * obj0 = 0 ;
28656 PyObject * obj1 = 0 ;
28657 char *kwnames[] = {
28658 (char *) "self",(char *) "win", NULL
28659 };
28660
28661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28663 if (SWIG_arg_fail(1)) SWIG_fail;
28664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28665 if (SWIG_arg_fail(2)) SWIG_fail;
28666 {
28667 PyThreadState* __tstate = wxPyBeginAllowThreads();
28668 (arg1)->MoveBeforeInTabOrder(arg2);
28669
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 Py_INCREF(Py_None); resultobj = Py_None;
28674 return resultobj;
28675 fail:
28676 return NULL;
28677 }
28678
28679
28680 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28681 PyObject *resultobj;
28682 wxWindow *arg1 = (wxWindow *) 0 ;
28683 PyObject *result;
28684 PyObject * obj0 = 0 ;
28685 char *kwnames[] = {
28686 (char *) "self", NULL
28687 };
28688
28689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28691 if (SWIG_arg_fail(1)) SWIG_fail;
28692 {
28693 PyThreadState* __tstate = wxPyBeginAllowThreads();
28694 result = (PyObject *)wxWindow_GetChildren(arg1);
28695
28696 wxPyEndAllowThreads(__tstate);
28697 if (PyErr_Occurred()) SWIG_fail;
28698 }
28699 resultobj = result;
28700 return resultobj;
28701 fail:
28702 return NULL;
28703 }
28704
28705
28706 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28707 PyObject *resultobj;
28708 wxWindow *arg1 = (wxWindow *) 0 ;
28709 wxWindow *result;
28710 PyObject * obj0 = 0 ;
28711 char *kwnames[] = {
28712 (char *) "self", NULL
28713 };
28714
28715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28717 if (SWIG_arg_fail(1)) SWIG_fail;
28718 {
28719 PyThreadState* __tstate = wxPyBeginAllowThreads();
28720 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28721
28722 wxPyEndAllowThreads(__tstate);
28723 if (PyErr_Occurred()) SWIG_fail;
28724 }
28725 {
28726 resultobj = wxPyMake_wxObject(result, 0);
28727 }
28728 return resultobj;
28729 fail:
28730 return NULL;
28731 }
28732
28733
28734 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28735 PyObject *resultobj;
28736 wxWindow *arg1 = (wxWindow *) 0 ;
28737 wxWindow *result;
28738 PyObject * obj0 = 0 ;
28739 char *kwnames[] = {
28740 (char *) "self", NULL
28741 };
28742
28743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28745 if (SWIG_arg_fail(1)) SWIG_fail;
28746 {
28747 PyThreadState* __tstate = wxPyBeginAllowThreads();
28748 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28749
28750 wxPyEndAllowThreads(__tstate);
28751 if (PyErr_Occurred()) SWIG_fail;
28752 }
28753 {
28754 resultobj = wxPyMake_wxObject(result, 0);
28755 }
28756 return resultobj;
28757 fail:
28758 return NULL;
28759 }
28760
28761
28762 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28763 PyObject *resultobj;
28764 wxWindow *arg1 = (wxWindow *) 0 ;
28765 bool result;
28766 PyObject * obj0 = 0 ;
28767 char *kwnames[] = {
28768 (char *) "self", NULL
28769 };
28770
28771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28773 if (SWIG_arg_fail(1)) SWIG_fail;
28774 {
28775 PyThreadState* __tstate = wxPyBeginAllowThreads();
28776 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28777
28778 wxPyEndAllowThreads(__tstate);
28779 if (PyErr_Occurred()) SWIG_fail;
28780 }
28781 {
28782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28783 }
28784 return resultobj;
28785 fail:
28786 return NULL;
28787 }
28788
28789
28790 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28791 PyObject *resultobj;
28792 wxWindow *arg1 = (wxWindow *) 0 ;
28793 wxWindow *arg2 = (wxWindow *) 0 ;
28794 bool result;
28795 PyObject * obj0 = 0 ;
28796 PyObject * obj1 = 0 ;
28797 char *kwnames[] = {
28798 (char *) "self",(char *) "newParent", NULL
28799 };
28800
28801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28803 if (SWIG_arg_fail(1)) SWIG_fail;
28804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28805 if (SWIG_arg_fail(2)) SWIG_fail;
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 result = (bool)(arg1)->Reparent(arg2);
28809
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 {
28814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28815 }
28816 return resultobj;
28817 fail:
28818 return NULL;
28819 }
28820
28821
28822 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28823 PyObject *resultobj;
28824 wxWindow *arg1 = (wxWindow *) 0 ;
28825 wxWindow *arg2 = (wxWindow *) 0 ;
28826 PyObject * obj0 = 0 ;
28827 PyObject * obj1 = 0 ;
28828 char *kwnames[] = {
28829 (char *) "self",(char *) "child", NULL
28830 };
28831
28832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28834 if (SWIG_arg_fail(1)) SWIG_fail;
28835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28836 if (SWIG_arg_fail(2)) SWIG_fail;
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 (arg1)->AddChild(arg2);
28840
28841 wxPyEndAllowThreads(__tstate);
28842 if (PyErr_Occurred()) SWIG_fail;
28843 }
28844 Py_INCREF(Py_None); resultobj = Py_None;
28845 return resultobj;
28846 fail:
28847 return NULL;
28848 }
28849
28850
28851 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28852 PyObject *resultobj;
28853 wxWindow *arg1 = (wxWindow *) 0 ;
28854 wxWindow *arg2 = (wxWindow *) 0 ;
28855 PyObject * obj0 = 0 ;
28856 PyObject * obj1 = 0 ;
28857 char *kwnames[] = {
28858 (char *) "self",(char *) "child", NULL
28859 };
28860
28861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28863 if (SWIG_arg_fail(1)) SWIG_fail;
28864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28865 if (SWIG_arg_fail(2)) SWIG_fail;
28866 {
28867 PyThreadState* __tstate = wxPyBeginAllowThreads();
28868 (arg1)->RemoveChild(arg2);
28869
28870 wxPyEndAllowThreads(__tstate);
28871 if (PyErr_Occurred()) SWIG_fail;
28872 }
28873 Py_INCREF(Py_None); resultobj = Py_None;
28874 return resultobj;
28875 fail:
28876 return NULL;
28877 }
28878
28879
28880 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28881 PyObject *resultobj;
28882 wxWindow *arg1 = (wxWindow *) 0 ;
28883 long arg2 ;
28884 wxWindow *result;
28885 PyObject * obj0 = 0 ;
28886 PyObject * obj1 = 0 ;
28887 char *kwnames[] = {
28888 (char *) "self",(char *) "winid", NULL
28889 };
28890
28891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28893 if (SWIG_arg_fail(1)) SWIG_fail;
28894 {
28895 arg2 = (long)(SWIG_As_long(obj1));
28896 if (SWIG_arg_fail(2)) SWIG_fail;
28897 }
28898 {
28899 PyThreadState* __tstate = wxPyBeginAllowThreads();
28900 result = (wxWindow *)(arg1)->FindWindow(arg2);
28901
28902 wxPyEndAllowThreads(__tstate);
28903 if (PyErr_Occurred()) SWIG_fail;
28904 }
28905 {
28906 resultobj = wxPyMake_wxObject(result, 0);
28907 }
28908 return resultobj;
28909 fail:
28910 return NULL;
28911 }
28912
28913
28914 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28915 PyObject *resultobj;
28916 wxWindow *arg1 = (wxWindow *) 0 ;
28917 wxString *arg2 = 0 ;
28918 wxWindow *result;
28919 bool temp2 = false ;
28920 PyObject * obj0 = 0 ;
28921 PyObject * obj1 = 0 ;
28922 char *kwnames[] = {
28923 (char *) "self",(char *) "name", NULL
28924 };
28925
28926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28928 if (SWIG_arg_fail(1)) SWIG_fail;
28929 {
28930 arg2 = wxString_in_helper(obj1);
28931 if (arg2 == NULL) SWIG_fail;
28932 temp2 = true;
28933 }
28934 {
28935 PyThreadState* __tstate = wxPyBeginAllowThreads();
28936 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28937
28938 wxPyEndAllowThreads(__tstate);
28939 if (PyErr_Occurred()) SWIG_fail;
28940 }
28941 {
28942 resultobj = wxPyMake_wxObject(result, 0);
28943 }
28944 {
28945 if (temp2)
28946 delete arg2;
28947 }
28948 return resultobj;
28949 fail:
28950 {
28951 if (temp2)
28952 delete arg2;
28953 }
28954 return NULL;
28955 }
28956
28957
28958 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28959 PyObject *resultobj;
28960 wxWindow *arg1 = (wxWindow *) 0 ;
28961 wxEvtHandler *result;
28962 PyObject * obj0 = 0 ;
28963 char *kwnames[] = {
28964 (char *) "self", NULL
28965 };
28966
28967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28969 if (SWIG_arg_fail(1)) SWIG_fail;
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28973
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 {
28978 resultobj = wxPyMake_wxObject(result, 0);
28979 }
28980 return resultobj;
28981 fail:
28982 return NULL;
28983 }
28984
28985
28986 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28987 PyObject *resultobj;
28988 wxWindow *arg1 = (wxWindow *) 0 ;
28989 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28990 PyObject * obj0 = 0 ;
28991 PyObject * obj1 = 0 ;
28992 char *kwnames[] = {
28993 (char *) "self",(char *) "handler", NULL
28994 };
28995
28996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28998 if (SWIG_arg_fail(1)) SWIG_fail;
28999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29000 if (SWIG_arg_fail(2)) SWIG_fail;
29001 {
29002 PyThreadState* __tstate = wxPyBeginAllowThreads();
29003 (arg1)->SetEventHandler(arg2);
29004
29005 wxPyEndAllowThreads(__tstate);
29006 if (PyErr_Occurred()) SWIG_fail;
29007 }
29008 Py_INCREF(Py_None); resultobj = Py_None;
29009 return resultobj;
29010 fail:
29011 return NULL;
29012 }
29013
29014
29015 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29016 PyObject *resultobj;
29017 wxWindow *arg1 = (wxWindow *) 0 ;
29018 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29019 PyObject * obj0 = 0 ;
29020 PyObject * obj1 = 0 ;
29021 char *kwnames[] = {
29022 (char *) "self",(char *) "handler", NULL
29023 };
29024
29025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29027 if (SWIG_arg_fail(1)) SWIG_fail;
29028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29029 if (SWIG_arg_fail(2)) SWIG_fail;
29030 {
29031 PyThreadState* __tstate = wxPyBeginAllowThreads();
29032 (arg1)->PushEventHandler(arg2);
29033
29034 wxPyEndAllowThreads(__tstate);
29035 if (PyErr_Occurred()) SWIG_fail;
29036 }
29037 Py_INCREF(Py_None); resultobj = Py_None;
29038 return resultobj;
29039 fail:
29040 return NULL;
29041 }
29042
29043
29044 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29045 PyObject *resultobj;
29046 wxWindow *arg1 = (wxWindow *) 0 ;
29047 bool arg2 = (bool) false ;
29048 wxEvtHandler *result;
29049 PyObject * obj0 = 0 ;
29050 PyObject * obj1 = 0 ;
29051 char *kwnames[] = {
29052 (char *) "self",(char *) "deleteHandler", NULL
29053 };
29054
29055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29057 if (SWIG_arg_fail(1)) SWIG_fail;
29058 if (obj1) {
29059 {
29060 arg2 = (bool)(SWIG_As_bool(obj1));
29061 if (SWIG_arg_fail(2)) SWIG_fail;
29062 }
29063 }
29064 {
29065 PyThreadState* __tstate = wxPyBeginAllowThreads();
29066 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29067
29068 wxPyEndAllowThreads(__tstate);
29069 if (PyErr_Occurred()) SWIG_fail;
29070 }
29071 {
29072 resultobj = wxPyMake_wxObject(result, 0);
29073 }
29074 return resultobj;
29075 fail:
29076 return NULL;
29077 }
29078
29079
29080 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29081 PyObject *resultobj;
29082 wxWindow *arg1 = (wxWindow *) 0 ;
29083 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29084 bool result;
29085 PyObject * obj0 = 0 ;
29086 PyObject * obj1 = 0 ;
29087 char *kwnames[] = {
29088 (char *) "self",(char *) "handler", NULL
29089 };
29090
29091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29093 if (SWIG_arg_fail(1)) SWIG_fail;
29094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29095 if (SWIG_arg_fail(2)) SWIG_fail;
29096 {
29097 PyThreadState* __tstate = wxPyBeginAllowThreads();
29098 result = (bool)(arg1)->RemoveEventHandler(arg2);
29099
29100 wxPyEndAllowThreads(__tstate);
29101 if (PyErr_Occurred()) SWIG_fail;
29102 }
29103 {
29104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29105 }
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29113 PyObject *resultobj;
29114 wxWindow *arg1 = (wxWindow *) 0 ;
29115 wxValidator *arg2 = 0 ;
29116 PyObject * obj0 = 0 ;
29117 PyObject * obj1 = 0 ;
29118 char *kwnames[] = {
29119 (char *) "self",(char *) "validator", NULL
29120 };
29121
29122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29124 if (SWIG_arg_fail(1)) SWIG_fail;
29125 {
29126 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29127 if (SWIG_arg_fail(2)) SWIG_fail;
29128 if (arg2 == NULL) {
29129 SWIG_null_ref("wxValidator");
29130 }
29131 if (SWIG_arg_fail(2)) SWIG_fail;
29132 }
29133 {
29134 PyThreadState* __tstate = wxPyBeginAllowThreads();
29135 (arg1)->SetValidator((wxValidator const &)*arg2);
29136
29137 wxPyEndAllowThreads(__tstate);
29138 if (PyErr_Occurred()) SWIG_fail;
29139 }
29140 Py_INCREF(Py_None); resultobj = Py_None;
29141 return resultobj;
29142 fail:
29143 return NULL;
29144 }
29145
29146
29147 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29148 PyObject *resultobj;
29149 wxWindow *arg1 = (wxWindow *) 0 ;
29150 wxValidator *result;
29151 PyObject * obj0 = 0 ;
29152 char *kwnames[] = {
29153 (char *) "self", NULL
29154 };
29155
29156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29158 if (SWIG_arg_fail(1)) SWIG_fail;
29159 {
29160 PyThreadState* __tstate = wxPyBeginAllowThreads();
29161 result = (wxValidator *)(arg1)->GetValidator();
29162
29163 wxPyEndAllowThreads(__tstate);
29164 if (PyErr_Occurred()) SWIG_fail;
29165 }
29166 {
29167 resultobj = wxPyMake_wxObject(result, 0);
29168 }
29169 return resultobj;
29170 fail:
29171 return NULL;
29172 }
29173
29174
29175 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29176 PyObject *resultobj;
29177 wxWindow *arg1 = (wxWindow *) 0 ;
29178 bool result;
29179 PyObject * obj0 = 0 ;
29180 char *kwnames[] = {
29181 (char *) "self", NULL
29182 };
29183
29184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29186 if (SWIG_arg_fail(1)) SWIG_fail;
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 result = (bool)(arg1)->Validate();
29190
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 {
29195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29196 }
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29204 PyObject *resultobj;
29205 wxWindow *arg1 = (wxWindow *) 0 ;
29206 bool result;
29207 PyObject * obj0 = 0 ;
29208 char *kwnames[] = {
29209 (char *) "self", NULL
29210 };
29211
29212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29214 if (SWIG_arg_fail(1)) SWIG_fail;
29215 {
29216 PyThreadState* __tstate = wxPyBeginAllowThreads();
29217 result = (bool)(arg1)->TransferDataToWindow();
29218
29219 wxPyEndAllowThreads(__tstate);
29220 if (PyErr_Occurred()) SWIG_fail;
29221 }
29222 {
29223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29224 }
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29232 PyObject *resultobj;
29233 wxWindow *arg1 = (wxWindow *) 0 ;
29234 bool result;
29235 PyObject * obj0 = 0 ;
29236 char *kwnames[] = {
29237 (char *) "self", NULL
29238 };
29239
29240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29242 if (SWIG_arg_fail(1)) SWIG_fail;
29243 {
29244 PyThreadState* __tstate = wxPyBeginAllowThreads();
29245 result = (bool)(arg1)->TransferDataFromWindow();
29246
29247 wxPyEndAllowThreads(__tstate);
29248 if (PyErr_Occurred()) SWIG_fail;
29249 }
29250 {
29251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29252 }
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29260 PyObject *resultobj;
29261 wxWindow *arg1 = (wxWindow *) 0 ;
29262 PyObject * obj0 = 0 ;
29263 char *kwnames[] = {
29264 (char *) "self", NULL
29265 };
29266
29267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29269 if (SWIG_arg_fail(1)) SWIG_fail;
29270 {
29271 PyThreadState* __tstate = wxPyBeginAllowThreads();
29272 (arg1)->InitDialog();
29273
29274 wxPyEndAllowThreads(__tstate);
29275 if (PyErr_Occurred()) SWIG_fail;
29276 }
29277 Py_INCREF(Py_None); resultobj = Py_None;
29278 return resultobj;
29279 fail:
29280 return NULL;
29281 }
29282
29283
29284 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29285 PyObject *resultobj;
29286 wxWindow *arg1 = (wxWindow *) 0 ;
29287 wxAcceleratorTable *arg2 = 0 ;
29288 PyObject * obj0 = 0 ;
29289 PyObject * obj1 = 0 ;
29290 char *kwnames[] = {
29291 (char *) "self",(char *) "accel", NULL
29292 };
29293
29294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29296 if (SWIG_arg_fail(1)) SWIG_fail;
29297 {
29298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29299 if (SWIG_arg_fail(2)) SWIG_fail;
29300 if (arg2 == NULL) {
29301 SWIG_null_ref("wxAcceleratorTable");
29302 }
29303 if (SWIG_arg_fail(2)) SWIG_fail;
29304 }
29305 {
29306 PyThreadState* __tstate = wxPyBeginAllowThreads();
29307 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29308
29309 wxPyEndAllowThreads(__tstate);
29310 if (PyErr_Occurred()) SWIG_fail;
29311 }
29312 Py_INCREF(Py_None); resultobj = Py_None;
29313 return resultobj;
29314 fail:
29315 return NULL;
29316 }
29317
29318
29319 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29320 PyObject *resultobj;
29321 wxWindow *arg1 = (wxWindow *) 0 ;
29322 wxAcceleratorTable *result;
29323 PyObject * obj0 = 0 ;
29324 char *kwnames[] = {
29325 (char *) "self", NULL
29326 };
29327
29328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29330 if (SWIG_arg_fail(1)) SWIG_fail;
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29334
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29339 return resultobj;
29340 fail:
29341 return NULL;
29342 }
29343
29344
29345 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29346 PyObject *resultobj;
29347 wxWindow *arg1 = (wxWindow *) 0 ;
29348 int arg2 ;
29349 int arg3 ;
29350 int arg4 ;
29351 bool result;
29352 PyObject * obj0 = 0 ;
29353 PyObject * obj1 = 0 ;
29354 PyObject * obj2 = 0 ;
29355 PyObject * obj3 = 0 ;
29356 char *kwnames[] = {
29357 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29358 };
29359
29360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29362 if (SWIG_arg_fail(1)) SWIG_fail;
29363 {
29364 arg2 = (int)(SWIG_As_int(obj1));
29365 if (SWIG_arg_fail(2)) SWIG_fail;
29366 }
29367 {
29368 arg3 = (int)(SWIG_As_int(obj2));
29369 if (SWIG_arg_fail(3)) SWIG_fail;
29370 }
29371 {
29372 arg4 = (int)(SWIG_As_int(obj3));
29373 if (SWIG_arg_fail(4)) SWIG_fail;
29374 }
29375 {
29376 PyThreadState* __tstate = wxPyBeginAllowThreads();
29377 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29378
29379 wxPyEndAllowThreads(__tstate);
29380 if (PyErr_Occurred()) SWIG_fail;
29381 }
29382 {
29383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29384 }
29385 return resultobj;
29386 fail:
29387 return NULL;
29388 }
29389
29390
29391 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29392 PyObject *resultobj;
29393 wxWindow *arg1 = (wxWindow *) 0 ;
29394 int arg2 ;
29395 bool result;
29396 PyObject * obj0 = 0 ;
29397 PyObject * obj1 = 0 ;
29398 char *kwnames[] = {
29399 (char *) "self",(char *) "hotkeyId", NULL
29400 };
29401
29402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29404 if (SWIG_arg_fail(1)) SWIG_fail;
29405 {
29406 arg2 = (int)(SWIG_As_int(obj1));
29407 if (SWIG_arg_fail(2)) SWIG_fail;
29408 }
29409 {
29410 PyThreadState* __tstate = wxPyBeginAllowThreads();
29411 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29412
29413 wxPyEndAllowThreads(__tstate);
29414 if (PyErr_Occurred()) SWIG_fail;
29415 }
29416 {
29417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29418 }
29419 return resultobj;
29420 fail:
29421 return NULL;
29422 }
29423
29424
29425 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29426 PyObject *resultobj;
29427 wxWindow *arg1 = (wxWindow *) 0 ;
29428 wxPoint *arg2 = 0 ;
29429 wxPoint result;
29430 wxPoint temp2 ;
29431 PyObject * obj0 = 0 ;
29432 PyObject * obj1 = 0 ;
29433 char *kwnames[] = {
29434 (char *) "self",(char *) "pt", NULL
29435 };
29436
29437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29439 if (SWIG_arg_fail(1)) SWIG_fail;
29440 {
29441 arg2 = &temp2;
29442 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29443 }
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29447
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 {
29452 wxPoint * resultptr;
29453 resultptr = new wxPoint((wxPoint &)(result));
29454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29455 }
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj;
29464 wxWindow *arg1 = (wxWindow *) 0 ;
29465 wxSize *arg2 = 0 ;
29466 wxSize result;
29467 wxSize temp2 ;
29468 PyObject * obj0 = 0 ;
29469 PyObject * obj1 = 0 ;
29470 char *kwnames[] = {
29471 (char *) "self",(char *) "sz", NULL
29472 };
29473
29474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29476 if (SWIG_arg_fail(1)) SWIG_fail;
29477 {
29478 arg2 = &temp2;
29479 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29480 }
29481 {
29482 PyThreadState* __tstate = wxPyBeginAllowThreads();
29483 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29484
29485 wxPyEndAllowThreads(__tstate);
29486 if (PyErr_Occurred()) SWIG_fail;
29487 }
29488 {
29489 wxSize * resultptr;
29490 resultptr = new wxSize((wxSize &)(result));
29491 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29492 }
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29500 PyObject *resultobj;
29501 wxWindow *arg1 = (wxWindow *) 0 ;
29502 wxPoint *arg2 = 0 ;
29503 wxPoint result;
29504 wxPoint temp2 ;
29505 PyObject * obj0 = 0 ;
29506 PyObject * obj1 = 0 ;
29507 char *kwnames[] = {
29508 (char *) "self",(char *) "pt", NULL
29509 };
29510
29511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29513 if (SWIG_arg_fail(1)) SWIG_fail;
29514 {
29515 arg2 = &temp2;
29516 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29517 }
29518 {
29519 PyThreadState* __tstate = wxPyBeginAllowThreads();
29520 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29521
29522 wxPyEndAllowThreads(__tstate);
29523 if (PyErr_Occurred()) SWIG_fail;
29524 }
29525 {
29526 wxPoint * resultptr;
29527 resultptr = new wxPoint((wxPoint &)(result));
29528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29529 }
29530 return resultobj;
29531 fail:
29532 return NULL;
29533 }
29534
29535
29536 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29537 PyObject *resultobj;
29538 wxWindow *arg1 = (wxWindow *) 0 ;
29539 wxSize *arg2 = 0 ;
29540 wxSize result;
29541 wxSize temp2 ;
29542 PyObject * obj0 = 0 ;
29543 PyObject * obj1 = 0 ;
29544 char *kwnames[] = {
29545 (char *) "self",(char *) "sz", NULL
29546 };
29547
29548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29550 if (SWIG_arg_fail(1)) SWIG_fail;
29551 {
29552 arg2 = &temp2;
29553 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29554 }
29555 {
29556 PyThreadState* __tstate = wxPyBeginAllowThreads();
29557 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29558
29559 wxPyEndAllowThreads(__tstate);
29560 if (PyErr_Occurred()) SWIG_fail;
29561 }
29562 {
29563 wxSize * resultptr;
29564 resultptr = new wxSize((wxSize &)(result));
29565 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29566 }
29567 return resultobj;
29568 fail:
29569 return NULL;
29570 }
29571
29572
29573 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29574 PyObject *resultobj;
29575 wxWindow *arg1 = (wxWindow *) 0 ;
29576 wxPoint *arg2 = 0 ;
29577 wxPoint result;
29578 wxPoint temp2 ;
29579 PyObject * obj0 = 0 ;
29580 PyObject * obj1 = 0 ;
29581 char *kwnames[] = {
29582 (char *) "self",(char *) "pt", NULL
29583 };
29584
29585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29587 if (SWIG_arg_fail(1)) SWIG_fail;
29588 {
29589 arg2 = &temp2;
29590 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29591 }
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29595
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 {
29600 wxPoint * resultptr;
29601 resultptr = new wxPoint((wxPoint &)(result));
29602 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29603 }
29604 return resultobj;
29605 fail:
29606 return NULL;
29607 }
29608
29609
29610 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29611 PyObject *resultobj;
29612 wxWindow *arg1 = (wxWindow *) 0 ;
29613 wxSize *arg2 = 0 ;
29614 wxSize result;
29615 wxSize temp2 ;
29616 PyObject * obj0 = 0 ;
29617 PyObject * obj1 = 0 ;
29618 char *kwnames[] = {
29619 (char *) "self",(char *) "sz", NULL
29620 };
29621
29622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29624 if (SWIG_arg_fail(1)) SWIG_fail;
29625 {
29626 arg2 = &temp2;
29627 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29628 }
29629 {
29630 PyThreadState* __tstate = wxPyBeginAllowThreads();
29631 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29632
29633 wxPyEndAllowThreads(__tstate);
29634 if (PyErr_Occurred()) SWIG_fail;
29635 }
29636 {
29637 wxSize * resultptr;
29638 resultptr = new wxSize((wxSize &)(result));
29639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29640 }
29641 return resultobj;
29642 fail:
29643 return NULL;
29644 }
29645
29646
29647 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29648 PyObject *resultobj;
29649 wxWindow *arg1 = (wxWindow *) 0 ;
29650 int arg2 ;
29651 int arg3 ;
29652 PyObject * obj0 = 0 ;
29653 PyObject * obj1 = 0 ;
29654 PyObject * obj2 = 0 ;
29655 char *kwnames[] = {
29656 (char *) "self",(char *) "x",(char *) "y", NULL
29657 };
29658
29659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29661 if (SWIG_arg_fail(1)) SWIG_fail;
29662 {
29663 arg2 = (int)(SWIG_As_int(obj1));
29664 if (SWIG_arg_fail(2)) SWIG_fail;
29665 }
29666 {
29667 arg3 = (int)(SWIG_As_int(obj2));
29668 if (SWIG_arg_fail(3)) SWIG_fail;
29669 }
29670 {
29671 PyThreadState* __tstate = wxPyBeginAllowThreads();
29672 (arg1)->WarpPointer(arg2,arg3);
29673
29674 wxPyEndAllowThreads(__tstate);
29675 if (PyErr_Occurred()) SWIG_fail;
29676 }
29677 Py_INCREF(Py_None); resultobj = Py_None;
29678 return resultobj;
29679 fail:
29680 return NULL;
29681 }
29682
29683
29684 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29685 PyObject *resultobj;
29686 wxWindow *arg1 = (wxWindow *) 0 ;
29687 PyObject * obj0 = 0 ;
29688 char *kwnames[] = {
29689 (char *) "self", NULL
29690 };
29691
29692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29694 if (SWIG_arg_fail(1)) SWIG_fail;
29695 {
29696 PyThreadState* __tstate = wxPyBeginAllowThreads();
29697 (arg1)->CaptureMouse();
29698
29699 wxPyEndAllowThreads(__tstate);
29700 if (PyErr_Occurred()) SWIG_fail;
29701 }
29702 Py_INCREF(Py_None); resultobj = Py_None;
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29710 PyObject *resultobj;
29711 wxWindow *arg1 = (wxWindow *) 0 ;
29712 PyObject * obj0 = 0 ;
29713 char *kwnames[] = {
29714 (char *) "self", NULL
29715 };
29716
29717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29719 if (SWIG_arg_fail(1)) SWIG_fail;
29720 {
29721 PyThreadState* __tstate = wxPyBeginAllowThreads();
29722 (arg1)->ReleaseMouse();
29723
29724 wxPyEndAllowThreads(__tstate);
29725 if (PyErr_Occurred()) SWIG_fail;
29726 }
29727 Py_INCREF(Py_None); resultobj = Py_None;
29728 return resultobj;
29729 fail:
29730 return NULL;
29731 }
29732
29733
29734 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29735 PyObject *resultobj;
29736 wxWindow *result;
29737 char *kwnames[] = {
29738 NULL
29739 };
29740
29741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29742 {
29743 if (!wxPyCheckForApp()) SWIG_fail;
29744 PyThreadState* __tstate = wxPyBeginAllowThreads();
29745 result = (wxWindow *)wxWindow::GetCapture();
29746
29747 wxPyEndAllowThreads(__tstate);
29748 if (PyErr_Occurred()) SWIG_fail;
29749 }
29750 {
29751 resultobj = wxPyMake_wxObject(result, 0);
29752 }
29753 return resultobj;
29754 fail:
29755 return NULL;
29756 }
29757
29758
29759 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29760 PyObject *resultobj;
29761 wxWindow *arg1 = (wxWindow *) 0 ;
29762 bool result;
29763 PyObject * obj0 = 0 ;
29764 char *kwnames[] = {
29765 (char *) "self", NULL
29766 };
29767
29768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29770 if (SWIG_arg_fail(1)) SWIG_fail;
29771 {
29772 PyThreadState* __tstate = wxPyBeginAllowThreads();
29773 result = (bool)((wxWindow const *)arg1)->HasCapture();
29774
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 {
29779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29780 }
29781 return resultobj;
29782 fail:
29783 return NULL;
29784 }
29785
29786
29787 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29788 PyObject *resultobj;
29789 wxWindow *arg1 = (wxWindow *) 0 ;
29790 bool arg2 = (bool) true ;
29791 wxRect *arg3 = (wxRect *) NULL ;
29792 PyObject * obj0 = 0 ;
29793 PyObject * obj1 = 0 ;
29794 PyObject * obj2 = 0 ;
29795 char *kwnames[] = {
29796 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29797 };
29798
29799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29801 if (SWIG_arg_fail(1)) SWIG_fail;
29802 if (obj1) {
29803 {
29804 arg2 = (bool)(SWIG_As_bool(obj1));
29805 if (SWIG_arg_fail(2)) SWIG_fail;
29806 }
29807 }
29808 if (obj2) {
29809 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29810 if (SWIG_arg_fail(3)) SWIG_fail;
29811 }
29812 {
29813 PyThreadState* __tstate = wxPyBeginAllowThreads();
29814 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29815
29816 wxPyEndAllowThreads(__tstate);
29817 if (PyErr_Occurred()) SWIG_fail;
29818 }
29819 Py_INCREF(Py_None); resultobj = Py_None;
29820 return resultobj;
29821 fail:
29822 return NULL;
29823 }
29824
29825
29826 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj;
29828 wxWindow *arg1 = (wxWindow *) 0 ;
29829 wxRect *arg2 = 0 ;
29830 bool arg3 = (bool) true ;
29831 wxRect temp2 ;
29832 PyObject * obj0 = 0 ;
29833 PyObject * obj1 = 0 ;
29834 PyObject * obj2 = 0 ;
29835 char *kwnames[] = {
29836 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29837 };
29838
29839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29841 if (SWIG_arg_fail(1)) SWIG_fail;
29842 {
29843 arg2 = &temp2;
29844 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29845 }
29846 if (obj2) {
29847 {
29848 arg3 = (bool)(SWIG_As_bool(obj2));
29849 if (SWIG_arg_fail(3)) SWIG_fail;
29850 }
29851 }
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29855
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 Py_INCREF(Py_None); resultobj = Py_None;
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29867 PyObject *resultobj;
29868 wxWindow *arg1 = (wxWindow *) 0 ;
29869 PyObject * obj0 = 0 ;
29870 char *kwnames[] = {
29871 (char *) "self", NULL
29872 };
29873
29874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29876 if (SWIG_arg_fail(1)) SWIG_fail;
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 (arg1)->Update();
29880
29881 wxPyEndAllowThreads(__tstate);
29882 if (PyErr_Occurred()) SWIG_fail;
29883 }
29884 Py_INCREF(Py_None); resultobj = Py_None;
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29892 PyObject *resultobj;
29893 wxWindow *arg1 = (wxWindow *) 0 ;
29894 PyObject * obj0 = 0 ;
29895 char *kwnames[] = {
29896 (char *) "self", NULL
29897 };
29898
29899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29901 if (SWIG_arg_fail(1)) SWIG_fail;
29902 {
29903 PyThreadState* __tstate = wxPyBeginAllowThreads();
29904 (arg1)->ClearBackground();
29905
29906 wxPyEndAllowThreads(__tstate);
29907 if (PyErr_Occurred()) SWIG_fail;
29908 }
29909 Py_INCREF(Py_None); resultobj = Py_None;
29910 return resultobj;
29911 fail:
29912 return NULL;
29913 }
29914
29915
29916 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29917 PyObject *resultobj;
29918 wxWindow *arg1 = (wxWindow *) 0 ;
29919 PyObject * obj0 = 0 ;
29920 char *kwnames[] = {
29921 (char *) "self", NULL
29922 };
29923
29924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29926 if (SWIG_arg_fail(1)) SWIG_fail;
29927 {
29928 PyThreadState* __tstate = wxPyBeginAllowThreads();
29929 (arg1)->Freeze();
29930
29931 wxPyEndAllowThreads(__tstate);
29932 if (PyErr_Occurred()) SWIG_fail;
29933 }
29934 Py_INCREF(Py_None); resultobj = Py_None;
29935 return resultobj;
29936 fail:
29937 return NULL;
29938 }
29939
29940
29941 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29942 PyObject *resultobj;
29943 wxWindow *arg1 = (wxWindow *) 0 ;
29944 PyObject * obj0 = 0 ;
29945 char *kwnames[] = {
29946 (char *) "self", NULL
29947 };
29948
29949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29951 if (SWIG_arg_fail(1)) SWIG_fail;
29952 {
29953 PyThreadState* __tstate = wxPyBeginAllowThreads();
29954 (arg1)->Thaw();
29955
29956 wxPyEndAllowThreads(__tstate);
29957 if (PyErr_Occurred()) SWIG_fail;
29958 }
29959 Py_INCREF(Py_None); resultobj = Py_None;
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj;
29968 wxWindow *arg1 = (wxWindow *) 0 ;
29969 wxDC *arg2 = 0 ;
29970 PyObject * obj0 = 0 ;
29971 PyObject * obj1 = 0 ;
29972 char *kwnames[] = {
29973 (char *) "self",(char *) "dc", NULL
29974 };
29975
29976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29978 if (SWIG_arg_fail(1)) SWIG_fail;
29979 {
29980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29981 if (SWIG_arg_fail(2)) SWIG_fail;
29982 if (arg2 == NULL) {
29983 SWIG_null_ref("wxDC");
29984 }
29985 if (SWIG_arg_fail(2)) SWIG_fail;
29986 }
29987 {
29988 PyThreadState* __tstate = wxPyBeginAllowThreads();
29989 (arg1)->PrepareDC(*arg2);
29990
29991 wxPyEndAllowThreads(__tstate);
29992 if (PyErr_Occurred()) SWIG_fail;
29993 }
29994 Py_INCREF(Py_None); resultobj = Py_None;
29995 return resultobj;
29996 fail:
29997 return NULL;
29998 }
29999
30000
30001 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30002 PyObject *resultobj;
30003 wxWindow *arg1 = (wxWindow *) 0 ;
30004 wxRegion *result;
30005 PyObject * obj0 = 0 ;
30006 char *kwnames[] = {
30007 (char *) "self", NULL
30008 };
30009
30010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30012 if (SWIG_arg_fail(1)) SWIG_fail;
30013 {
30014 PyThreadState* __tstate = wxPyBeginAllowThreads();
30015 {
30016 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30017 result = (wxRegion *) &_result_ref;
30018 }
30019
30020 wxPyEndAllowThreads(__tstate);
30021 if (PyErr_Occurred()) SWIG_fail;
30022 }
30023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30024 return resultobj;
30025 fail:
30026 return NULL;
30027 }
30028
30029
30030 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30031 PyObject *resultobj;
30032 wxWindow *arg1 = (wxWindow *) 0 ;
30033 wxRect result;
30034 PyObject * obj0 = 0 ;
30035 char *kwnames[] = {
30036 (char *) "self", NULL
30037 };
30038
30039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30041 if (SWIG_arg_fail(1)) SWIG_fail;
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30045
30046 wxPyEndAllowThreads(__tstate);
30047 if (PyErr_Occurred()) SWIG_fail;
30048 }
30049 {
30050 wxRect * resultptr;
30051 resultptr = new wxRect((wxRect &)(result));
30052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30053 }
30054 return resultobj;
30055 fail:
30056 return NULL;
30057 }
30058
30059
30060 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30061 PyObject *resultobj;
30062 wxWindow *arg1 = (wxWindow *) 0 ;
30063 int arg2 ;
30064 int arg3 ;
30065 int arg4 = (int) 1 ;
30066 int arg5 = (int) 1 ;
30067 bool result;
30068 PyObject * obj0 = 0 ;
30069 PyObject * obj1 = 0 ;
30070 PyObject * obj2 = 0 ;
30071 PyObject * obj3 = 0 ;
30072 PyObject * obj4 = 0 ;
30073 char *kwnames[] = {
30074 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30075 };
30076
30077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30079 if (SWIG_arg_fail(1)) SWIG_fail;
30080 {
30081 arg2 = (int)(SWIG_As_int(obj1));
30082 if (SWIG_arg_fail(2)) SWIG_fail;
30083 }
30084 {
30085 arg3 = (int)(SWIG_As_int(obj2));
30086 if (SWIG_arg_fail(3)) SWIG_fail;
30087 }
30088 if (obj3) {
30089 {
30090 arg4 = (int)(SWIG_As_int(obj3));
30091 if (SWIG_arg_fail(4)) SWIG_fail;
30092 }
30093 }
30094 if (obj4) {
30095 {
30096 arg5 = (int)(SWIG_As_int(obj4));
30097 if (SWIG_arg_fail(5)) SWIG_fail;
30098 }
30099 }
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30103
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 {
30108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30109 }
30110 return resultobj;
30111 fail:
30112 return NULL;
30113 }
30114
30115
30116 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30117 PyObject *resultobj;
30118 wxWindow *arg1 = (wxWindow *) 0 ;
30119 wxPoint *arg2 = 0 ;
30120 bool result;
30121 wxPoint temp2 ;
30122 PyObject * obj0 = 0 ;
30123 PyObject * obj1 = 0 ;
30124 char *kwnames[] = {
30125 (char *) "self",(char *) "pt", NULL
30126 };
30127
30128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30130 if (SWIG_arg_fail(1)) SWIG_fail;
30131 {
30132 arg2 = &temp2;
30133 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30134 }
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30138
30139 wxPyEndAllowThreads(__tstate);
30140 if (PyErr_Occurred()) SWIG_fail;
30141 }
30142 {
30143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30144 }
30145 return resultobj;
30146 fail:
30147 return NULL;
30148 }
30149
30150
30151 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30152 PyObject *resultobj;
30153 wxWindow *arg1 = (wxWindow *) 0 ;
30154 wxRect *arg2 = 0 ;
30155 bool result;
30156 wxRect temp2 ;
30157 PyObject * obj0 = 0 ;
30158 PyObject * obj1 = 0 ;
30159 char *kwnames[] = {
30160 (char *) "self",(char *) "rect", NULL
30161 };
30162
30163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30165 if (SWIG_arg_fail(1)) SWIG_fail;
30166 {
30167 arg2 = &temp2;
30168 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30169 }
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30173
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 {
30178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30179 }
30180 return resultobj;
30181 fail:
30182 return NULL;
30183 }
30184
30185
30186 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30187 PyObject *resultobj;
30188 wxWindow *arg1 = (wxWindow *) 0 ;
30189 wxVisualAttributes result;
30190 PyObject * obj0 = 0 ;
30191 char *kwnames[] = {
30192 (char *) "self", NULL
30193 };
30194
30195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30197 if (SWIG_arg_fail(1)) SWIG_fail;
30198 {
30199 PyThreadState* __tstate = wxPyBeginAllowThreads();
30200 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30201
30202 wxPyEndAllowThreads(__tstate);
30203 if (PyErr_Occurred()) SWIG_fail;
30204 }
30205 {
30206 wxVisualAttributes * resultptr;
30207 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30208 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30209 }
30210 return resultobj;
30211 fail:
30212 return NULL;
30213 }
30214
30215
30216 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30217 PyObject *resultobj;
30218 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30219 wxVisualAttributes result;
30220 PyObject * obj0 = 0 ;
30221 char *kwnames[] = {
30222 (char *) "variant", NULL
30223 };
30224
30225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30226 if (obj0) {
30227 {
30228 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
30229 if (SWIG_arg_fail(1)) SWIG_fail;
30230 }
30231 }
30232 {
30233 if (!wxPyCheckForApp()) SWIG_fail;
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
30236
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 {
30241 wxVisualAttributes * resultptr;
30242 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30243 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30244 }
30245 return resultobj;
30246 fail:
30247 return NULL;
30248 }
30249
30250
30251 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30252 PyObject *resultobj;
30253 wxWindow *arg1 = (wxWindow *) 0 ;
30254 wxColour *arg2 = 0 ;
30255 bool result;
30256 wxColour temp2 ;
30257 PyObject * obj0 = 0 ;
30258 PyObject * obj1 = 0 ;
30259 char *kwnames[] = {
30260 (char *) "self",(char *) "colour", NULL
30261 };
30262
30263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30265 if (SWIG_arg_fail(1)) SWIG_fail;
30266 {
30267 arg2 = &temp2;
30268 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30269 }
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30273
30274 wxPyEndAllowThreads(__tstate);
30275 if (PyErr_Occurred()) SWIG_fail;
30276 }
30277 {
30278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30279 }
30280 return resultobj;
30281 fail:
30282 return NULL;
30283 }
30284
30285
30286 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30287 PyObject *resultobj;
30288 wxWindow *arg1 = (wxWindow *) 0 ;
30289 wxColour *arg2 = 0 ;
30290 wxColour temp2 ;
30291 PyObject * obj0 = 0 ;
30292 PyObject * obj1 = 0 ;
30293 char *kwnames[] = {
30294 (char *) "self",(char *) "colour", NULL
30295 };
30296
30297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30299 if (SWIG_arg_fail(1)) SWIG_fail;
30300 {
30301 arg2 = &temp2;
30302 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30303 }
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30307
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 Py_INCREF(Py_None); resultobj = Py_None;
30312 return resultobj;
30313 fail:
30314 return NULL;
30315 }
30316
30317
30318 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30319 PyObject *resultobj;
30320 wxWindow *arg1 = (wxWindow *) 0 ;
30321 wxColour *arg2 = 0 ;
30322 bool result;
30323 wxColour temp2 ;
30324 PyObject * obj0 = 0 ;
30325 PyObject * obj1 = 0 ;
30326 char *kwnames[] = {
30327 (char *) "self",(char *) "colour", NULL
30328 };
30329
30330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30332 if (SWIG_arg_fail(1)) SWIG_fail;
30333 {
30334 arg2 = &temp2;
30335 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30336 }
30337 {
30338 PyThreadState* __tstate = wxPyBeginAllowThreads();
30339 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30340
30341 wxPyEndAllowThreads(__tstate);
30342 if (PyErr_Occurred()) SWIG_fail;
30343 }
30344 {
30345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30346 }
30347 return resultobj;
30348 fail:
30349 return NULL;
30350 }
30351
30352
30353 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30354 PyObject *resultobj;
30355 wxWindow *arg1 = (wxWindow *) 0 ;
30356 wxColour *arg2 = 0 ;
30357 wxColour temp2 ;
30358 PyObject * obj0 = 0 ;
30359 PyObject * obj1 = 0 ;
30360 char *kwnames[] = {
30361 (char *) "self",(char *) "colour", NULL
30362 };
30363
30364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30366 if (SWIG_arg_fail(1)) SWIG_fail;
30367 {
30368 arg2 = &temp2;
30369 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30370 }
30371 {
30372 PyThreadState* __tstate = wxPyBeginAllowThreads();
30373 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30374
30375 wxPyEndAllowThreads(__tstate);
30376 if (PyErr_Occurred()) SWIG_fail;
30377 }
30378 Py_INCREF(Py_None); resultobj = Py_None;
30379 return resultobj;
30380 fail:
30381 return NULL;
30382 }
30383
30384
30385 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30386 PyObject *resultobj;
30387 wxWindow *arg1 = (wxWindow *) 0 ;
30388 wxColour result;
30389 PyObject * obj0 = 0 ;
30390 char *kwnames[] = {
30391 (char *) "self", NULL
30392 };
30393
30394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30396 if (SWIG_arg_fail(1)) SWIG_fail;
30397 {
30398 PyThreadState* __tstate = wxPyBeginAllowThreads();
30399 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30400
30401 wxPyEndAllowThreads(__tstate);
30402 if (PyErr_Occurred()) SWIG_fail;
30403 }
30404 {
30405 wxColour * resultptr;
30406 resultptr = new wxColour((wxColour &)(result));
30407 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30408 }
30409 return resultobj;
30410 fail:
30411 return NULL;
30412 }
30413
30414
30415 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30416 PyObject *resultobj;
30417 wxWindow *arg1 = (wxWindow *) 0 ;
30418 wxColour result;
30419 PyObject * obj0 = 0 ;
30420 char *kwnames[] = {
30421 (char *) "self", NULL
30422 };
30423
30424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30426 if (SWIG_arg_fail(1)) SWIG_fail;
30427 {
30428 PyThreadState* __tstate = wxPyBeginAllowThreads();
30429 result = ((wxWindow const *)arg1)->GetForegroundColour();
30430
30431 wxPyEndAllowThreads(__tstate);
30432 if (PyErr_Occurred()) SWIG_fail;
30433 }
30434 {
30435 wxColour * resultptr;
30436 resultptr = new wxColour((wxColour &)(result));
30437 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30438 }
30439 return resultobj;
30440 fail:
30441 return NULL;
30442 }
30443
30444
30445 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30446 PyObject *resultobj;
30447 wxWindow *arg1 = (wxWindow *) 0 ;
30448 bool result;
30449 PyObject * obj0 = 0 ;
30450 char *kwnames[] = {
30451 (char *) "self", NULL
30452 };
30453
30454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30456 if (SWIG_arg_fail(1)) SWIG_fail;
30457 {
30458 PyThreadState* __tstate = wxPyBeginAllowThreads();
30459 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30460
30461 wxPyEndAllowThreads(__tstate);
30462 if (PyErr_Occurred()) SWIG_fail;
30463 }
30464 {
30465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30466 }
30467 return resultobj;
30468 fail:
30469 return NULL;
30470 }
30471
30472
30473 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30474 PyObject *resultobj;
30475 wxWindow *arg1 = (wxWindow *) 0 ;
30476 bool result;
30477 PyObject * obj0 = 0 ;
30478 char *kwnames[] = {
30479 (char *) "self", NULL
30480 };
30481
30482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30484 if (SWIG_arg_fail(1)) SWIG_fail;
30485 {
30486 PyThreadState* __tstate = wxPyBeginAllowThreads();
30487 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30488
30489 wxPyEndAllowThreads(__tstate);
30490 if (PyErr_Occurred()) SWIG_fail;
30491 }
30492 {
30493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30494 }
30495 return resultobj;
30496 fail:
30497 return NULL;
30498 }
30499
30500
30501 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30502 PyObject *resultobj;
30503 wxWindow *arg1 = (wxWindow *) 0 ;
30504 wxBackgroundStyle arg2 ;
30505 bool result;
30506 PyObject * obj0 = 0 ;
30507 PyObject * obj1 = 0 ;
30508 char *kwnames[] = {
30509 (char *) "self",(char *) "style", NULL
30510 };
30511
30512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30514 if (SWIG_arg_fail(1)) SWIG_fail;
30515 {
30516 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
30517 if (SWIG_arg_fail(2)) SWIG_fail;
30518 }
30519 {
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
30522
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 {
30527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30528 }
30529 return resultobj;
30530 fail:
30531 return NULL;
30532 }
30533
30534
30535 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30536 PyObject *resultobj;
30537 wxWindow *arg1 = (wxWindow *) 0 ;
30538 wxBackgroundStyle result;
30539 PyObject * obj0 = 0 ;
30540 char *kwnames[] = {
30541 (char *) "self", NULL
30542 };
30543
30544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30546 if (SWIG_arg_fail(1)) SWIG_fail;
30547 {
30548 PyThreadState* __tstate = wxPyBeginAllowThreads();
30549 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30550
30551 wxPyEndAllowThreads(__tstate);
30552 if (PyErr_Occurred()) SWIG_fail;
30553 }
30554 resultobj = SWIG_From_int((result));
30555 return resultobj;
30556 fail:
30557 return NULL;
30558 }
30559
30560
30561 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30562 PyObject *resultobj;
30563 wxWindow *arg1 = (wxWindow *) 0 ;
30564 bool result;
30565 PyObject * obj0 = 0 ;
30566 char *kwnames[] = {
30567 (char *) "self", NULL
30568 };
30569
30570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30572 if (SWIG_arg_fail(1)) SWIG_fail;
30573 {
30574 PyThreadState* __tstate = wxPyBeginAllowThreads();
30575 result = (bool)(arg1)->HasTransparentBackground();
30576
30577 wxPyEndAllowThreads(__tstate);
30578 if (PyErr_Occurred()) SWIG_fail;
30579 }
30580 {
30581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30582 }
30583 return resultobj;
30584 fail:
30585 return NULL;
30586 }
30587
30588
30589 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30590 PyObject *resultobj;
30591 wxWindow *arg1 = (wxWindow *) 0 ;
30592 wxCursor *arg2 = 0 ;
30593 bool result;
30594 PyObject * obj0 = 0 ;
30595 PyObject * obj1 = 0 ;
30596 char *kwnames[] = {
30597 (char *) "self",(char *) "cursor", NULL
30598 };
30599
30600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30602 if (SWIG_arg_fail(1)) SWIG_fail;
30603 {
30604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30605 if (SWIG_arg_fail(2)) SWIG_fail;
30606 if (arg2 == NULL) {
30607 SWIG_null_ref("wxCursor");
30608 }
30609 if (SWIG_arg_fail(2)) SWIG_fail;
30610 }
30611 {
30612 PyThreadState* __tstate = wxPyBeginAllowThreads();
30613 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30614
30615 wxPyEndAllowThreads(__tstate);
30616 if (PyErr_Occurred()) SWIG_fail;
30617 }
30618 {
30619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30620 }
30621 return resultobj;
30622 fail:
30623 return NULL;
30624 }
30625
30626
30627 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30628 PyObject *resultobj;
30629 wxWindow *arg1 = (wxWindow *) 0 ;
30630 wxCursor result;
30631 PyObject * obj0 = 0 ;
30632 char *kwnames[] = {
30633 (char *) "self", NULL
30634 };
30635
30636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30638 if (SWIG_arg_fail(1)) SWIG_fail;
30639 {
30640 PyThreadState* __tstate = wxPyBeginAllowThreads();
30641 result = (arg1)->GetCursor();
30642
30643 wxPyEndAllowThreads(__tstate);
30644 if (PyErr_Occurred()) SWIG_fail;
30645 }
30646 {
30647 wxCursor * resultptr;
30648 resultptr = new wxCursor((wxCursor &)(result));
30649 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30650 }
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30658 PyObject *resultobj;
30659 wxWindow *arg1 = (wxWindow *) 0 ;
30660 wxFont *arg2 = 0 ;
30661 bool result;
30662 PyObject * obj0 = 0 ;
30663 PyObject * obj1 = 0 ;
30664 char *kwnames[] = {
30665 (char *) "self",(char *) "font", NULL
30666 };
30667
30668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30670 if (SWIG_arg_fail(1)) SWIG_fail;
30671 {
30672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30673 if (SWIG_arg_fail(2)) SWIG_fail;
30674 if (arg2 == NULL) {
30675 SWIG_null_ref("wxFont");
30676 }
30677 if (SWIG_arg_fail(2)) SWIG_fail;
30678 }
30679 {
30680 PyThreadState* __tstate = wxPyBeginAllowThreads();
30681 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30682
30683 wxPyEndAllowThreads(__tstate);
30684 if (PyErr_Occurred()) SWIG_fail;
30685 }
30686 {
30687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30688 }
30689 return resultobj;
30690 fail:
30691 return NULL;
30692 }
30693
30694
30695 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30696 PyObject *resultobj;
30697 wxWindow *arg1 = (wxWindow *) 0 ;
30698 wxFont *arg2 = 0 ;
30699 PyObject * obj0 = 0 ;
30700 PyObject * obj1 = 0 ;
30701 char *kwnames[] = {
30702 (char *) "self",(char *) "font", NULL
30703 };
30704
30705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30707 if (SWIG_arg_fail(1)) SWIG_fail;
30708 {
30709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30710 if (SWIG_arg_fail(2)) SWIG_fail;
30711 if (arg2 == NULL) {
30712 SWIG_null_ref("wxFont");
30713 }
30714 if (SWIG_arg_fail(2)) SWIG_fail;
30715 }
30716 {
30717 PyThreadState* __tstate = wxPyBeginAllowThreads();
30718 (arg1)->SetOwnFont((wxFont const &)*arg2);
30719
30720 wxPyEndAllowThreads(__tstate);
30721 if (PyErr_Occurred()) SWIG_fail;
30722 }
30723 Py_INCREF(Py_None); resultobj = Py_None;
30724 return resultobj;
30725 fail:
30726 return NULL;
30727 }
30728
30729
30730 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30731 PyObject *resultobj;
30732 wxWindow *arg1 = (wxWindow *) 0 ;
30733 wxFont result;
30734 PyObject * obj0 = 0 ;
30735 char *kwnames[] = {
30736 (char *) "self", NULL
30737 };
30738
30739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30741 if (SWIG_arg_fail(1)) SWIG_fail;
30742 {
30743 PyThreadState* __tstate = wxPyBeginAllowThreads();
30744 result = (arg1)->GetFont();
30745
30746 wxPyEndAllowThreads(__tstate);
30747 if (PyErr_Occurred()) SWIG_fail;
30748 }
30749 {
30750 wxFont * resultptr;
30751 resultptr = new wxFont((wxFont &)(result));
30752 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30753 }
30754 return resultobj;
30755 fail:
30756 return NULL;
30757 }
30758
30759
30760 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30761 PyObject *resultobj;
30762 wxWindow *arg1 = (wxWindow *) 0 ;
30763 wxCaret *arg2 = (wxCaret *) 0 ;
30764 PyObject * obj0 = 0 ;
30765 PyObject * obj1 = 0 ;
30766 char *kwnames[] = {
30767 (char *) "self",(char *) "caret", NULL
30768 };
30769
30770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30772 if (SWIG_arg_fail(1)) SWIG_fail;
30773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30774 if (SWIG_arg_fail(2)) SWIG_fail;
30775 {
30776 PyThreadState* __tstate = wxPyBeginAllowThreads();
30777 (arg1)->SetCaret(arg2);
30778
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 Py_INCREF(Py_None); resultobj = Py_None;
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30790 PyObject *resultobj;
30791 wxWindow *arg1 = (wxWindow *) 0 ;
30792 wxCaret *result;
30793 PyObject * obj0 = 0 ;
30794 char *kwnames[] = {
30795 (char *) "self", NULL
30796 };
30797
30798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30800 if (SWIG_arg_fail(1)) SWIG_fail;
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30804
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 int result;
30819 PyObject * obj0 = 0 ;
30820 char *kwnames[] = {
30821 (char *) "self", NULL
30822 };
30823
30824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30826 if (SWIG_arg_fail(1)) SWIG_fail;
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30830
30831 wxPyEndAllowThreads(__tstate);
30832 if (PyErr_Occurred()) SWIG_fail;
30833 }
30834 {
30835 resultobj = SWIG_From_int((int)(result));
30836 }
30837 return resultobj;
30838 fail:
30839 return NULL;
30840 }
30841
30842
30843 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30844 PyObject *resultobj;
30845 wxWindow *arg1 = (wxWindow *) 0 ;
30846 int result;
30847 PyObject * obj0 = 0 ;
30848 char *kwnames[] = {
30849 (char *) "self", NULL
30850 };
30851
30852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30854 if (SWIG_arg_fail(1)) SWIG_fail;
30855 {
30856 PyThreadState* __tstate = wxPyBeginAllowThreads();
30857 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30858
30859 wxPyEndAllowThreads(__tstate);
30860 if (PyErr_Occurred()) SWIG_fail;
30861 }
30862 {
30863 resultobj = SWIG_From_int((int)(result));
30864 }
30865 return resultobj;
30866 fail:
30867 return NULL;
30868 }
30869
30870
30871 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30872 PyObject *resultobj;
30873 wxWindow *arg1 = (wxWindow *) 0 ;
30874 wxString *arg2 = 0 ;
30875 int *arg3 = (int *) 0 ;
30876 int *arg4 = (int *) 0 ;
30877 bool temp2 = false ;
30878 int temp3 ;
30879 int res3 = 0 ;
30880 int temp4 ;
30881 int res4 = 0 ;
30882 PyObject * obj0 = 0 ;
30883 PyObject * obj1 = 0 ;
30884 char *kwnames[] = {
30885 (char *) "self",(char *) "string", NULL
30886 };
30887
30888 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30889 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30892 if (SWIG_arg_fail(1)) SWIG_fail;
30893 {
30894 arg2 = wxString_in_helper(obj1);
30895 if (arg2 == NULL) SWIG_fail;
30896 temp2 = true;
30897 }
30898 {
30899 PyThreadState* __tstate = wxPyBeginAllowThreads();
30900 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30901
30902 wxPyEndAllowThreads(__tstate);
30903 if (PyErr_Occurred()) SWIG_fail;
30904 }
30905 Py_INCREF(Py_None); resultobj = Py_None;
30906 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30907 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30908 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30909 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30910 {
30911 if (temp2)
30912 delete arg2;
30913 }
30914 return resultobj;
30915 fail:
30916 {
30917 if (temp2)
30918 delete arg2;
30919 }
30920 return NULL;
30921 }
30922
30923
30924 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30925 PyObject *resultobj;
30926 wxWindow *arg1 = (wxWindow *) 0 ;
30927 wxString *arg2 = 0 ;
30928 int *arg3 = (int *) 0 ;
30929 int *arg4 = (int *) 0 ;
30930 int *arg5 = (int *) 0 ;
30931 int *arg6 = (int *) 0 ;
30932 wxFont *arg7 = (wxFont *) NULL ;
30933 bool temp2 = false ;
30934 int temp3 ;
30935 int res3 = 0 ;
30936 int temp4 ;
30937 int res4 = 0 ;
30938 int temp5 ;
30939 int res5 = 0 ;
30940 int temp6 ;
30941 int res6 = 0 ;
30942 PyObject * obj0 = 0 ;
30943 PyObject * obj1 = 0 ;
30944 PyObject * obj2 = 0 ;
30945 char *kwnames[] = {
30946 (char *) "self",(char *) "string",(char *) "font", NULL
30947 };
30948
30949 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30950 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30951 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30952 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30955 if (SWIG_arg_fail(1)) SWIG_fail;
30956 {
30957 arg2 = wxString_in_helper(obj1);
30958 if (arg2 == NULL) SWIG_fail;
30959 temp2 = true;
30960 }
30961 if (obj2) {
30962 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30963 if (SWIG_arg_fail(7)) SWIG_fail;
30964 }
30965 {
30966 PyThreadState* __tstate = wxPyBeginAllowThreads();
30967 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30968
30969 wxPyEndAllowThreads(__tstate);
30970 if (PyErr_Occurred()) SWIG_fail;
30971 }
30972 Py_INCREF(Py_None); resultobj = Py_None;
30973 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30974 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30975 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30976 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30977 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30978 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30979 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30980 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30981 {
30982 if (temp2)
30983 delete arg2;
30984 }
30985 return resultobj;
30986 fail:
30987 {
30988 if (temp2)
30989 delete arg2;
30990 }
30991 return NULL;
30992 }
30993
30994
30995 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30996 PyObject *resultobj;
30997 wxWindow *arg1 = (wxWindow *) 0 ;
30998 int *arg2 = (int *) 0 ;
30999 int *arg3 = (int *) 0 ;
31000 int temp2 ;
31001 int res2 = 0 ;
31002 int temp3 ;
31003 int res3 = 0 ;
31004 PyObject * obj0 = 0 ;
31005 PyObject * obj1 = 0 ;
31006 PyObject * obj2 = 0 ;
31007 char *kwnames[] = {
31008 (char *) "self",(char *) "x",(char *) "y", NULL
31009 };
31010
31011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31013 if (SWIG_arg_fail(1)) SWIG_fail;
31014 {
31015 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31016 temp2 = SWIG_As_int(obj1);
31017 if (SWIG_arg_fail(2)) SWIG_fail;
31018 arg2 = &temp2;
31019 res2 = SWIG_NEWOBJ;
31020 }
31021 }
31022 {
31023 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31024 temp3 = SWIG_As_int(obj2);
31025 if (SWIG_arg_fail(3)) SWIG_fail;
31026 arg3 = &temp3;
31027 res3 = SWIG_NEWOBJ;
31028 }
31029 }
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31033
31034 wxPyEndAllowThreads(__tstate);
31035 if (PyErr_Occurred()) SWIG_fail;
31036 }
31037 Py_INCREF(Py_None); resultobj = Py_None;
31038 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31039 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31040 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31041 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31042 return resultobj;
31043 fail:
31044 return NULL;
31045 }
31046
31047
31048 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31049 PyObject *resultobj;
31050 wxWindow *arg1 = (wxWindow *) 0 ;
31051 int *arg2 = (int *) 0 ;
31052 int *arg3 = (int *) 0 ;
31053 int temp2 ;
31054 int res2 = 0 ;
31055 int temp3 ;
31056 int res3 = 0 ;
31057 PyObject * obj0 = 0 ;
31058 PyObject * obj1 = 0 ;
31059 PyObject * obj2 = 0 ;
31060 char *kwnames[] = {
31061 (char *) "self",(char *) "x",(char *) "y", NULL
31062 };
31063
31064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31066 if (SWIG_arg_fail(1)) SWIG_fail;
31067 {
31068 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31069 temp2 = SWIG_As_int(obj1);
31070 if (SWIG_arg_fail(2)) SWIG_fail;
31071 arg2 = &temp2;
31072 res2 = SWIG_NEWOBJ;
31073 }
31074 }
31075 {
31076 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31077 temp3 = SWIG_As_int(obj2);
31078 if (SWIG_arg_fail(3)) SWIG_fail;
31079 arg3 = &temp3;
31080 res3 = SWIG_NEWOBJ;
31081 }
31082 }
31083 {
31084 PyThreadState* __tstate = wxPyBeginAllowThreads();
31085 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31086
31087 wxPyEndAllowThreads(__tstate);
31088 if (PyErr_Occurred()) SWIG_fail;
31089 }
31090 Py_INCREF(Py_None); resultobj = Py_None;
31091 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31092 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31093 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31094 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31095 return resultobj;
31096 fail:
31097 return NULL;
31098 }
31099
31100
31101 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31102 PyObject *resultobj;
31103 wxWindow *arg1 = (wxWindow *) 0 ;
31104 wxPoint *arg2 = 0 ;
31105 wxPoint result;
31106 wxPoint temp2 ;
31107 PyObject * obj0 = 0 ;
31108 PyObject * obj1 = 0 ;
31109 char *kwnames[] = {
31110 (char *) "self",(char *) "pt", NULL
31111 };
31112
31113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31115 if (SWIG_arg_fail(1)) SWIG_fail;
31116 {
31117 arg2 = &temp2;
31118 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31119 }
31120 {
31121 PyThreadState* __tstate = wxPyBeginAllowThreads();
31122 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31123
31124 wxPyEndAllowThreads(__tstate);
31125 if (PyErr_Occurred()) SWIG_fail;
31126 }
31127 {
31128 wxPoint * resultptr;
31129 resultptr = new wxPoint((wxPoint &)(result));
31130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31131 }
31132 return resultobj;
31133 fail:
31134 return NULL;
31135 }
31136
31137
31138 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31139 PyObject *resultobj;
31140 wxWindow *arg1 = (wxWindow *) 0 ;
31141 wxPoint *arg2 = 0 ;
31142 wxPoint result;
31143 wxPoint temp2 ;
31144 PyObject * obj0 = 0 ;
31145 PyObject * obj1 = 0 ;
31146 char *kwnames[] = {
31147 (char *) "self",(char *) "pt", NULL
31148 };
31149
31150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31152 if (SWIG_arg_fail(1)) SWIG_fail;
31153 {
31154 arg2 = &temp2;
31155 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31156 }
31157 {
31158 PyThreadState* __tstate = wxPyBeginAllowThreads();
31159 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31160
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 {
31165 wxPoint * resultptr;
31166 resultptr = new wxPoint((wxPoint &)(result));
31167 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31168 }
31169 return resultobj;
31170 fail:
31171 return NULL;
31172 }
31173
31174
31175 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31176 PyObject *resultobj;
31177 wxWindow *arg1 = (wxWindow *) 0 ;
31178 int arg2 ;
31179 int arg3 ;
31180 wxHitTest result;
31181 PyObject * obj0 = 0 ;
31182 PyObject * obj1 = 0 ;
31183 PyObject * obj2 = 0 ;
31184 char *kwnames[] = {
31185 (char *) "self",(char *) "x",(char *) "y", NULL
31186 };
31187
31188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31190 if (SWIG_arg_fail(1)) SWIG_fail;
31191 {
31192 arg2 = (int)(SWIG_As_int(obj1));
31193 if (SWIG_arg_fail(2)) SWIG_fail;
31194 }
31195 {
31196 arg3 = (int)(SWIG_As_int(obj2));
31197 if (SWIG_arg_fail(3)) SWIG_fail;
31198 }
31199 {
31200 PyThreadState* __tstate = wxPyBeginAllowThreads();
31201 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31202
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 resultobj = SWIG_From_int((result));
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj;
31215 wxWindow *arg1 = (wxWindow *) 0 ;
31216 wxPoint *arg2 = 0 ;
31217 wxHitTest result;
31218 wxPoint temp2 ;
31219 PyObject * obj0 = 0 ;
31220 PyObject * obj1 = 0 ;
31221 char *kwnames[] = {
31222 (char *) "self",(char *) "pt", NULL
31223 };
31224
31225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31227 if (SWIG_arg_fail(1)) SWIG_fail;
31228 {
31229 arg2 = &temp2;
31230 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31231 }
31232 {
31233 PyThreadState* __tstate = wxPyBeginAllowThreads();
31234 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31235
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 resultobj = SWIG_From_int((result));
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31247 PyObject *resultobj;
31248 wxWindow *arg1 = (wxWindow *) 0 ;
31249 long arg2 ;
31250 wxBorder result;
31251 PyObject * obj0 = 0 ;
31252 PyObject * obj1 = 0 ;
31253
31254 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31256 if (SWIG_arg_fail(1)) SWIG_fail;
31257 {
31258 arg2 = (long)(SWIG_As_long(obj1));
31259 if (SWIG_arg_fail(2)) SWIG_fail;
31260 }
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31264
31265 wxPyEndAllowThreads(__tstate);
31266 if (PyErr_Occurred()) SWIG_fail;
31267 }
31268 resultobj = SWIG_From_int((result));
31269 return resultobj;
31270 fail:
31271 return NULL;
31272 }
31273
31274
31275 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31276 PyObject *resultobj;
31277 wxWindow *arg1 = (wxWindow *) 0 ;
31278 wxBorder result;
31279 PyObject * obj0 = 0 ;
31280
31281 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31283 if (SWIG_arg_fail(1)) SWIG_fail;
31284 {
31285 PyThreadState* __tstate = wxPyBeginAllowThreads();
31286 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31287
31288 wxPyEndAllowThreads(__tstate);
31289 if (PyErr_Occurred()) SWIG_fail;
31290 }
31291 resultobj = SWIG_From_int((result));
31292 return resultobj;
31293 fail:
31294 return NULL;
31295 }
31296
31297
31298 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31299 int argc;
31300 PyObject *argv[3];
31301 int ii;
31302
31303 argc = PyObject_Length(args);
31304 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31305 argv[ii] = PyTuple_GetItem(args,ii);
31306 }
31307 if (argc == 1) {
31308 int _v;
31309 {
31310 void *ptr;
31311 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31312 _v = 0;
31313 PyErr_Clear();
31314 } else {
31315 _v = 1;
31316 }
31317 }
31318 if (_v) {
31319 return _wrap_Window_GetBorder__SWIG_1(self,args);
31320 }
31321 }
31322 if (argc == 2) {
31323 int _v;
31324 {
31325 void *ptr;
31326 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31327 _v = 0;
31328 PyErr_Clear();
31329 } else {
31330 _v = 1;
31331 }
31332 }
31333 if (_v) {
31334 _v = SWIG_Check_long(argv[1]);
31335 if (_v) {
31336 return _wrap_Window_GetBorder__SWIG_0(self,args);
31337 }
31338 }
31339 }
31340
31341 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31342 return NULL;
31343 }
31344
31345
31346 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj;
31348 wxWindow *arg1 = (wxWindow *) 0 ;
31349 long arg2 = (long) wxUPDATE_UI_NONE ;
31350 PyObject * obj0 = 0 ;
31351 PyObject * obj1 = 0 ;
31352 char *kwnames[] = {
31353 (char *) "self",(char *) "flags", NULL
31354 };
31355
31356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31358 if (SWIG_arg_fail(1)) SWIG_fail;
31359 if (obj1) {
31360 {
31361 arg2 = (long)(SWIG_As_long(obj1));
31362 if (SWIG_arg_fail(2)) SWIG_fail;
31363 }
31364 }
31365 {
31366 PyThreadState* __tstate = wxPyBeginAllowThreads();
31367 (arg1)->UpdateWindowUI(arg2);
31368
31369 wxPyEndAllowThreads(__tstate);
31370 if (PyErr_Occurred()) SWIG_fail;
31371 }
31372 Py_INCREF(Py_None); resultobj = Py_None;
31373 return resultobj;
31374 fail:
31375 return NULL;
31376 }
31377
31378
31379 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31380 PyObject *resultobj;
31381 wxWindow *arg1 = (wxWindow *) 0 ;
31382 wxMenu *arg2 = (wxMenu *) 0 ;
31383 int arg3 = (int) -1 ;
31384 int arg4 = (int) -1 ;
31385 bool result;
31386 PyObject * obj0 = 0 ;
31387 PyObject * obj1 = 0 ;
31388 PyObject * obj2 = 0 ;
31389 PyObject * obj3 = 0 ;
31390 char *kwnames[] = {
31391 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31392 };
31393
31394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31396 if (SWIG_arg_fail(1)) SWIG_fail;
31397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31398 if (SWIG_arg_fail(2)) SWIG_fail;
31399 if (obj2) {
31400 {
31401 arg3 = (int)(SWIG_As_int(obj2));
31402 if (SWIG_arg_fail(3)) SWIG_fail;
31403 }
31404 }
31405 if (obj3) {
31406 {
31407 arg4 = (int)(SWIG_As_int(obj3));
31408 if (SWIG_arg_fail(4)) SWIG_fail;
31409 }
31410 }
31411 {
31412 PyThreadState* __tstate = wxPyBeginAllowThreads();
31413 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31414
31415 wxPyEndAllowThreads(__tstate);
31416 if (PyErr_Occurred()) SWIG_fail;
31417 }
31418 {
31419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31420 }
31421 return resultobj;
31422 fail:
31423 return NULL;
31424 }
31425
31426
31427 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31428 PyObject *resultobj;
31429 wxWindow *arg1 = (wxWindow *) 0 ;
31430 wxMenu *arg2 = (wxMenu *) 0 ;
31431 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31432 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31433 bool result;
31434 wxPoint temp3 ;
31435 PyObject * obj0 = 0 ;
31436 PyObject * obj1 = 0 ;
31437 PyObject * obj2 = 0 ;
31438 char *kwnames[] = {
31439 (char *) "self",(char *) "menu",(char *) "pos", NULL
31440 };
31441
31442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31444 if (SWIG_arg_fail(1)) SWIG_fail;
31445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31446 if (SWIG_arg_fail(2)) SWIG_fail;
31447 if (obj2) {
31448 {
31449 arg3 = &temp3;
31450 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31451 }
31452 }
31453 {
31454 PyThreadState* __tstate = wxPyBeginAllowThreads();
31455 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31456
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 {
31461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31462 }
31463 return resultobj;
31464 fail:
31465 return NULL;
31466 }
31467
31468
31469 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31470 PyObject *resultobj;
31471 wxWindow *arg1 = (wxWindow *) 0 ;
31472 long result;
31473 PyObject * obj0 = 0 ;
31474 char *kwnames[] = {
31475 (char *) "self", NULL
31476 };
31477
31478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31480 if (SWIG_arg_fail(1)) SWIG_fail;
31481 {
31482 PyThreadState* __tstate = wxPyBeginAllowThreads();
31483 result = (long)wxWindow_GetHandle(arg1);
31484
31485 wxPyEndAllowThreads(__tstate);
31486 if (PyErr_Occurred()) SWIG_fail;
31487 }
31488 {
31489 resultobj = SWIG_From_long((long)(result));
31490 }
31491 return resultobj;
31492 fail:
31493 return NULL;
31494 }
31495
31496
31497 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31498 PyObject *resultobj;
31499 wxWindow *arg1 = (wxWindow *) 0 ;
31500 long arg2 ;
31501 PyObject * obj0 = 0 ;
31502 PyObject * obj1 = 0 ;
31503 char *kwnames[] = {
31504 (char *) "self",(char *) "handle", NULL
31505 };
31506
31507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31509 if (SWIG_arg_fail(1)) SWIG_fail;
31510 {
31511 arg2 = (long)(SWIG_As_long(obj1));
31512 if (SWIG_arg_fail(2)) SWIG_fail;
31513 }
31514 {
31515 PyThreadState* __tstate = wxPyBeginAllowThreads();
31516 wxWindow_AssociateHandle(arg1,arg2);
31517
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 Py_INCREF(Py_None); resultobj = Py_None;
31522 return resultobj;
31523 fail:
31524 return NULL;
31525 }
31526
31527
31528 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31529 PyObject *resultobj;
31530 wxWindow *arg1 = (wxWindow *) 0 ;
31531 PyObject * obj0 = 0 ;
31532 char *kwnames[] = {
31533 (char *) "self", NULL
31534 };
31535
31536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31538 if (SWIG_arg_fail(1)) SWIG_fail;
31539 {
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 (arg1)->DissociateHandle();
31542
31543 wxPyEndAllowThreads(__tstate);
31544 if (PyErr_Occurred()) SWIG_fail;
31545 }
31546 Py_INCREF(Py_None); resultobj = Py_None;
31547 return resultobj;
31548 fail:
31549 return NULL;
31550 }
31551
31552
31553 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
31554 PyObject *resultobj;
31555 wxWindow *arg1 = (wxWindow *) 0 ;
31556 wxPaintEvent *arg2 = 0 ;
31557 PyObject * obj0 = 0 ;
31558 PyObject * obj1 = 0 ;
31559 char *kwnames[] = {
31560 (char *) "self",(char *) "event", NULL
31561 };
31562
31563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
31564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31565 if (SWIG_arg_fail(1)) SWIG_fail;
31566 {
31567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
31568 if (SWIG_arg_fail(2)) SWIG_fail;
31569 if (arg2 == NULL) {
31570 SWIG_null_ref("wxPaintEvent");
31571 }
31572 if (SWIG_arg_fail(2)) SWIG_fail;
31573 }
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 (arg1)->OnPaint(*arg2);
31577
31578 wxPyEndAllowThreads(__tstate);
31579 if (PyErr_Occurred()) SWIG_fail;
31580 }
31581 Py_INCREF(Py_None); resultobj = Py_None;
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31589 PyObject *resultobj;
31590 wxWindow *arg1 = (wxWindow *) 0 ;
31591 int arg2 ;
31592 bool result;
31593 PyObject * obj0 = 0 ;
31594 PyObject * obj1 = 0 ;
31595 char *kwnames[] = {
31596 (char *) "self",(char *) "orient", NULL
31597 };
31598
31599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31601 if (SWIG_arg_fail(1)) SWIG_fail;
31602 {
31603 arg2 = (int)(SWIG_As_int(obj1));
31604 if (SWIG_arg_fail(2)) SWIG_fail;
31605 }
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31609
31610 wxPyEndAllowThreads(__tstate);
31611 if (PyErr_Occurred()) SWIG_fail;
31612 }
31613 {
31614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31615 }
31616 return resultobj;
31617 fail:
31618 return NULL;
31619 }
31620
31621
31622 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31623 PyObject *resultobj;
31624 wxWindow *arg1 = (wxWindow *) 0 ;
31625 int arg2 ;
31626 int arg3 ;
31627 int arg4 ;
31628 int arg5 ;
31629 bool arg6 = (bool) true ;
31630 PyObject * obj0 = 0 ;
31631 PyObject * obj1 = 0 ;
31632 PyObject * obj2 = 0 ;
31633 PyObject * obj3 = 0 ;
31634 PyObject * obj4 = 0 ;
31635 PyObject * obj5 = 0 ;
31636 char *kwnames[] = {
31637 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31638 };
31639
31640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31642 if (SWIG_arg_fail(1)) SWIG_fail;
31643 {
31644 arg2 = (int)(SWIG_As_int(obj1));
31645 if (SWIG_arg_fail(2)) SWIG_fail;
31646 }
31647 {
31648 arg3 = (int)(SWIG_As_int(obj2));
31649 if (SWIG_arg_fail(3)) SWIG_fail;
31650 }
31651 {
31652 arg4 = (int)(SWIG_As_int(obj3));
31653 if (SWIG_arg_fail(4)) SWIG_fail;
31654 }
31655 {
31656 arg5 = (int)(SWIG_As_int(obj4));
31657 if (SWIG_arg_fail(5)) SWIG_fail;
31658 }
31659 if (obj5) {
31660 {
31661 arg6 = (bool)(SWIG_As_bool(obj5));
31662 if (SWIG_arg_fail(6)) SWIG_fail;
31663 }
31664 }
31665 {
31666 PyThreadState* __tstate = wxPyBeginAllowThreads();
31667 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31668
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 Py_INCREF(Py_None); resultobj = Py_None;
31673 return resultobj;
31674 fail:
31675 return NULL;
31676 }
31677
31678
31679 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31680 PyObject *resultobj;
31681 wxWindow *arg1 = (wxWindow *) 0 ;
31682 int arg2 ;
31683 int arg3 ;
31684 bool arg4 = (bool) true ;
31685 PyObject * obj0 = 0 ;
31686 PyObject * obj1 = 0 ;
31687 PyObject * obj2 = 0 ;
31688 PyObject * obj3 = 0 ;
31689 char *kwnames[] = {
31690 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31691 };
31692
31693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31695 if (SWIG_arg_fail(1)) SWIG_fail;
31696 {
31697 arg2 = (int)(SWIG_As_int(obj1));
31698 if (SWIG_arg_fail(2)) SWIG_fail;
31699 }
31700 {
31701 arg3 = (int)(SWIG_As_int(obj2));
31702 if (SWIG_arg_fail(3)) SWIG_fail;
31703 }
31704 if (obj3) {
31705 {
31706 arg4 = (bool)(SWIG_As_bool(obj3));
31707 if (SWIG_arg_fail(4)) SWIG_fail;
31708 }
31709 }
31710 {
31711 PyThreadState* __tstate = wxPyBeginAllowThreads();
31712 (arg1)->SetScrollPos(arg2,arg3,arg4);
31713
31714 wxPyEndAllowThreads(__tstate);
31715 if (PyErr_Occurred()) SWIG_fail;
31716 }
31717 Py_INCREF(Py_None); resultobj = Py_None;
31718 return resultobj;
31719 fail:
31720 return NULL;
31721 }
31722
31723
31724 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31725 PyObject *resultobj;
31726 wxWindow *arg1 = (wxWindow *) 0 ;
31727 int arg2 ;
31728 int result;
31729 PyObject * obj0 = 0 ;
31730 PyObject * obj1 = 0 ;
31731 char *kwnames[] = {
31732 (char *) "self",(char *) "orientation", NULL
31733 };
31734
31735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31737 if (SWIG_arg_fail(1)) SWIG_fail;
31738 {
31739 arg2 = (int)(SWIG_As_int(obj1));
31740 if (SWIG_arg_fail(2)) SWIG_fail;
31741 }
31742 {
31743 PyThreadState* __tstate = wxPyBeginAllowThreads();
31744 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31745
31746 wxPyEndAllowThreads(__tstate);
31747 if (PyErr_Occurred()) SWIG_fail;
31748 }
31749 {
31750 resultobj = SWIG_From_int((int)(result));
31751 }
31752 return resultobj;
31753 fail:
31754 return NULL;
31755 }
31756
31757
31758 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31759 PyObject *resultobj;
31760 wxWindow *arg1 = (wxWindow *) 0 ;
31761 int arg2 ;
31762 int result;
31763 PyObject * obj0 = 0 ;
31764 PyObject * obj1 = 0 ;
31765 char *kwnames[] = {
31766 (char *) "self",(char *) "orientation", NULL
31767 };
31768
31769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31771 if (SWIG_arg_fail(1)) SWIG_fail;
31772 {
31773 arg2 = (int)(SWIG_As_int(obj1));
31774 if (SWIG_arg_fail(2)) SWIG_fail;
31775 }
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31779
31780 wxPyEndAllowThreads(__tstate);
31781 if (PyErr_Occurred()) SWIG_fail;
31782 }
31783 {
31784 resultobj = SWIG_From_int((int)(result));
31785 }
31786 return resultobj;
31787 fail:
31788 return NULL;
31789 }
31790
31791
31792 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31793 PyObject *resultobj;
31794 wxWindow *arg1 = (wxWindow *) 0 ;
31795 int arg2 ;
31796 int result;
31797 PyObject * obj0 = 0 ;
31798 PyObject * obj1 = 0 ;
31799 char *kwnames[] = {
31800 (char *) "self",(char *) "orientation", NULL
31801 };
31802
31803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31805 if (SWIG_arg_fail(1)) SWIG_fail;
31806 {
31807 arg2 = (int)(SWIG_As_int(obj1));
31808 if (SWIG_arg_fail(2)) SWIG_fail;
31809 }
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31813
31814 wxPyEndAllowThreads(__tstate);
31815 if (PyErr_Occurred()) SWIG_fail;
31816 }
31817 {
31818 resultobj = SWIG_From_int((int)(result));
31819 }
31820 return resultobj;
31821 fail:
31822 return NULL;
31823 }
31824
31825
31826 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31827 PyObject *resultobj;
31828 wxWindow *arg1 = (wxWindow *) 0 ;
31829 int arg2 ;
31830 int arg3 ;
31831 wxRect *arg4 = (wxRect *) NULL ;
31832 PyObject * obj0 = 0 ;
31833 PyObject * obj1 = 0 ;
31834 PyObject * obj2 = 0 ;
31835 PyObject * obj3 = 0 ;
31836 char *kwnames[] = {
31837 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31838 };
31839
31840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31842 if (SWIG_arg_fail(1)) SWIG_fail;
31843 {
31844 arg2 = (int)(SWIG_As_int(obj1));
31845 if (SWIG_arg_fail(2)) SWIG_fail;
31846 }
31847 {
31848 arg3 = (int)(SWIG_As_int(obj2));
31849 if (SWIG_arg_fail(3)) SWIG_fail;
31850 }
31851 if (obj3) {
31852 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31853 if (SWIG_arg_fail(4)) SWIG_fail;
31854 }
31855 {
31856 PyThreadState* __tstate = wxPyBeginAllowThreads();
31857 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31858
31859 wxPyEndAllowThreads(__tstate);
31860 if (PyErr_Occurred()) SWIG_fail;
31861 }
31862 Py_INCREF(Py_None); resultobj = Py_None;
31863 return resultobj;
31864 fail:
31865 return NULL;
31866 }
31867
31868
31869 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31870 PyObject *resultobj;
31871 wxWindow *arg1 = (wxWindow *) 0 ;
31872 int arg2 ;
31873 bool result;
31874 PyObject * obj0 = 0 ;
31875 PyObject * obj1 = 0 ;
31876 char *kwnames[] = {
31877 (char *) "self",(char *) "lines", NULL
31878 };
31879
31880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31882 if (SWIG_arg_fail(1)) SWIG_fail;
31883 {
31884 arg2 = (int)(SWIG_As_int(obj1));
31885 if (SWIG_arg_fail(2)) SWIG_fail;
31886 }
31887 {
31888 PyThreadState* __tstate = wxPyBeginAllowThreads();
31889 result = (bool)(arg1)->ScrollLines(arg2);
31890
31891 wxPyEndAllowThreads(__tstate);
31892 if (PyErr_Occurred()) SWIG_fail;
31893 }
31894 {
31895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31896 }
31897 return resultobj;
31898 fail:
31899 return NULL;
31900 }
31901
31902
31903 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31904 PyObject *resultobj;
31905 wxWindow *arg1 = (wxWindow *) 0 ;
31906 int arg2 ;
31907 bool result;
31908 PyObject * obj0 = 0 ;
31909 PyObject * obj1 = 0 ;
31910 char *kwnames[] = {
31911 (char *) "self",(char *) "pages", NULL
31912 };
31913
31914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31916 if (SWIG_arg_fail(1)) SWIG_fail;
31917 {
31918 arg2 = (int)(SWIG_As_int(obj1));
31919 if (SWIG_arg_fail(2)) SWIG_fail;
31920 }
31921 {
31922 PyThreadState* __tstate = wxPyBeginAllowThreads();
31923 result = (bool)(arg1)->ScrollPages(arg2);
31924
31925 wxPyEndAllowThreads(__tstate);
31926 if (PyErr_Occurred()) SWIG_fail;
31927 }
31928 {
31929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31930 }
31931 return resultobj;
31932 fail:
31933 return NULL;
31934 }
31935
31936
31937 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31938 PyObject *resultobj;
31939 wxWindow *arg1 = (wxWindow *) 0 ;
31940 bool result;
31941 PyObject * obj0 = 0 ;
31942 char *kwnames[] = {
31943 (char *) "self", NULL
31944 };
31945
31946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31948 if (SWIG_arg_fail(1)) SWIG_fail;
31949 {
31950 PyThreadState* __tstate = wxPyBeginAllowThreads();
31951 result = (bool)(arg1)->LineUp();
31952
31953 wxPyEndAllowThreads(__tstate);
31954 if (PyErr_Occurred()) SWIG_fail;
31955 }
31956 {
31957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31958 }
31959 return resultobj;
31960 fail:
31961 return NULL;
31962 }
31963
31964
31965 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31966 PyObject *resultobj;
31967 wxWindow *arg1 = (wxWindow *) 0 ;
31968 bool result;
31969 PyObject * obj0 = 0 ;
31970 char *kwnames[] = {
31971 (char *) "self", NULL
31972 };
31973
31974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31976 if (SWIG_arg_fail(1)) SWIG_fail;
31977 {
31978 PyThreadState* __tstate = wxPyBeginAllowThreads();
31979 result = (bool)(arg1)->LineDown();
31980
31981 wxPyEndAllowThreads(__tstate);
31982 if (PyErr_Occurred()) SWIG_fail;
31983 }
31984 {
31985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31986 }
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31994 PyObject *resultobj;
31995 wxWindow *arg1 = (wxWindow *) 0 ;
31996 bool result;
31997 PyObject * obj0 = 0 ;
31998 char *kwnames[] = {
31999 (char *) "self", NULL
32000 };
32001
32002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32004 if (SWIG_arg_fail(1)) SWIG_fail;
32005 {
32006 PyThreadState* __tstate = wxPyBeginAllowThreads();
32007 result = (bool)(arg1)->PageUp();
32008
32009 wxPyEndAllowThreads(__tstate);
32010 if (PyErr_Occurred()) SWIG_fail;
32011 }
32012 {
32013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32014 }
32015 return resultobj;
32016 fail:
32017 return NULL;
32018 }
32019
32020
32021 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32022 PyObject *resultobj;
32023 wxWindow *arg1 = (wxWindow *) 0 ;
32024 bool result;
32025 PyObject * obj0 = 0 ;
32026 char *kwnames[] = {
32027 (char *) "self", NULL
32028 };
32029
32030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32032 if (SWIG_arg_fail(1)) SWIG_fail;
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 result = (bool)(arg1)->PageDown();
32036
32037 wxPyEndAllowThreads(__tstate);
32038 if (PyErr_Occurred()) SWIG_fail;
32039 }
32040 {
32041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32042 }
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32050 PyObject *resultobj;
32051 wxWindow *arg1 = (wxWindow *) 0 ;
32052 wxString *arg2 = 0 ;
32053 bool temp2 = false ;
32054 PyObject * obj0 = 0 ;
32055 PyObject * obj1 = 0 ;
32056 char *kwnames[] = {
32057 (char *) "self",(char *) "text", NULL
32058 };
32059
32060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32062 if (SWIG_arg_fail(1)) SWIG_fail;
32063 {
32064 arg2 = wxString_in_helper(obj1);
32065 if (arg2 == NULL) SWIG_fail;
32066 temp2 = true;
32067 }
32068 {
32069 PyThreadState* __tstate = wxPyBeginAllowThreads();
32070 (arg1)->SetHelpText((wxString const &)*arg2);
32071
32072 wxPyEndAllowThreads(__tstate);
32073 if (PyErr_Occurred()) SWIG_fail;
32074 }
32075 Py_INCREF(Py_None); resultobj = Py_None;
32076 {
32077 if (temp2)
32078 delete arg2;
32079 }
32080 return resultobj;
32081 fail:
32082 {
32083 if (temp2)
32084 delete arg2;
32085 }
32086 return NULL;
32087 }
32088
32089
32090 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32091 PyObject *resultobj;
32092 wxWindow *arg1 = (wxWindow *) 0 ;
32093 wxString *arg2 = 0 ;
32094 bool temp2 = false ;
32095 PyObject * obj0 = 0 ;
32096 PyObject * obj1 = 0 ;
32097 char *kwnames[] = {
32098 (char *) "self",(char *) "text", NULL
32099 };
32100
32101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32103 if (SWIG_arg_fail(1)) SWIG_fail;
32104 {
32105 arg2 = wxString_in_helper(obj1);
32106 if (arg2 == NULL) SWIG_fail;
32107 temp2 = true;
32108 }
32109 {
32110 PyThreadState* __tstate = wxPyBeginAllowThreads();
32111 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32112
32113 wxPyEndAllowThreads(__tstate);
32114 if (PyErr_Occurred()) SWIG_fail;
32115 }
32116 Py_INCREF(Py_None); resultobj = Py_None;
32117 {
32118 if (temp2)
32119 delete arg2;
32120 }
32121 return resultobj;
32122 fail:
32123 {
32124 if (temp2)
32125 delete arg2;
32126 }
32127 return NULL;
32128 }
32129
32130
32131 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32132 PyObject *resultobj;
32133 wxWindow *arg1 = (wxWindow *) 0 ;
32134 wxString result;
32135 PyObject * obj0 = 0 ;
32136 char *kwnames[] = {
32137 (char *) "self", NULL
32138 };
32139
32140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32142 if (SWIG_arg_fail(1)) SWIG_fail;
32143 {
32144 PyThreadState* __tstate = wxPyBeginAllowThreads();
32145 result = ((wxWindow const *)arg1)->GetHelpText();
32146
32147 wxPyEndAllowThreads(__tstate);
32148 if (PyErr_Occurred()) SWIG_fail;
32149 }
32150 {
32151 #if wxUSE_UNICODE
32152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32153 #else
32154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32155 #endif
32156 }
32157 return resultobj;
32158 fail:
32159 return NULL;
32160 }
32161
32162
32163 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32164 PyObject *resultobj;
32165 wxWindow *arg1 = (wxWindow *) 0 ;
32166 wxString *arg2 = 0 ;
32167 bool temp2 = false ;
32168 PyObject * obj0 = 0 ;
32169 PyObject * obj1 = 0 ;
32170 char *kwnames[] = {
32171 (char *) "self",(char *) "tip", NULL
32172 };
32173
32174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32176 if (SWIG_arg_fail(1)) SWIG_fail;
32177 {
32178 arg2 = wxString_in_helper(obj1);
32179 if (arg2 == NULL) SWIG_fail;
32180 temp2 = true;
32181 }
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 (arg1)->SetToolTip((wxString const &)*arg2);
32185
32186 wxPyEndAllowThreads(__tstate);
32187 if (PyErr_Occurred()) SWIG_fail;
32188 }
32189 Py_INCREF(Py_None); resultobj = Py_None;
32190 {
32191 if (temp2)
32192 delete arg2;
32193 }
32194 return resultobj;
32195 fail:
32196 {
32197 if (temp2)
32198 delete arg2;
32199 }
32200 return NULL;
32201 }
32202
32203
32204 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32205 PyObject *resultobj;
32206 wxWindow *arg1 = (wxWindow *) 0 ;
32207 wxToolTip *arg2 = (wxToolTip *) 0 ;
32208 PyObject * obj0 = 0 ;
32209 PyObject * obj1 = 0 ;
32210 char *kwnames[] = {
32211 (char *) "self",(char *) "tip", NULL
32212 };
32213
32214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32216 if (SWIG_arg_fail(1)) SWIG_fail;
32217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
32218 if (SWIG_arg_fail(2)) SWIG_fail;
32219 {
32220 PyThreadState* __tstate = wxPyBeginAllowThreads();
32221 (arg1)->SetToolTip(arg2);
32222
32223 wxPyEndAllowThreads(__tstate);
32224 if (PyErr_Occurred()) SWIG_fail;
32225 }
32226 Py_INCREF(Py_None); resultobj = Py_None;
32227 return resultobj;
32228 fail:
32229 return NULL;
32230 }
32231
32232
32233 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32234 PyObject *resultobj;
32235 wxWindow *arg1 = (wxWindow *) 0 ;
32236 wxToolTip *result;
32237 PyObject * obj0 = 0 ;
32238 char *kwnames[] = {
32239 (char *) "self", NULL
32240 };
32241
32242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32244 if (SWIG_arg_fail(1)) SWIG_fail;
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32248
32249 wxPyEndAllowThreads(__tstate);
32250 if (PyErr_Occurred()) SWIG_fail;
32251 }
32252 {
32253 resultobj = wxPyMake_wxObject(result, 0);
32254 }
32255 return resultobj;
32256 fail:
32257 return NULL;
32258 }
32259
32260
32261 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32262 PyObject *resultobj;
32263 wxWindow *arg1 = (wxWindow *) 0 ;
32264 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32265 PyObject * obj0 = 0 ;
32266 PyObject * obj1 = 0 ;
32267 char *kwnames[] = {
32268 (char *) "self",(char *) "dropTarget", NULL
32269 };
32270
32271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32273 if (SWIG_arg_fail(1)) SWIG_fail;
32274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32275 if (SWIG_arg_fail(2)) SWIG_fail;
32276 {
32277 PyThreadState* __tstate = wxPyBeginAllowThreads();
32278 (arg1)->SetDropTarget(arg2);
32279
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 Py_INCREF(Py_None); resultobj = Py_None;
32284 return resultobj;
32285 fail:
32286 return NULL;
32287 }
32288
32289
32290 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32291 PyObject *resultobj;
32292 wxWindow *arg1 = (wxWindow *) 0 ;
32293 wxPyDropTarget *result;
32294 PyObject * obj0 = 0 ;
32295 char *kwnames[] = {
32296 (char *) "self", NULL
32297 };
32298
32299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32301 if (SWIG_arg_fail(1)) SWIG_fail;
32302 {
32303 PyThreadState* __tstate = wxPyBeginAllowThreads();
32304 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32305
32306 wxPyEndAllowThreads(__tstate);
32307 if (PyErr_Occurred()) SWIG_fail;
32308 }
32309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32310 return resultobj;
32311 fail:
32312 return NULL;
32313 }
32314
32315
32316 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32317 PyObject *resultobj;
32318 wxWindow *arg1 = (wxWindow *) 0 ;
32319 bool arg2 ;
32320 PyObject * obj0 = 0 ;
32321 PyObject * obj1 = 0 ;
32322 char *kwnames[] = {
32323 (char *) "self",(char *) "accept", NULL
32324 };
32325
32326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32328 if (SWIG_arg_fail(1)) SWIG_fail;
32329 {
32330 arg2 = (bool)(SWIG_As_bool(obj1));
32331 if (SWIG_arg_fail(2)) SWIG_fail;
32332 }
32333 {
32334 PyThreadState* __tstate = wxPyBeginAllowThreads();
32335 (arg1)->DragAcceptFiles(arg2);
32336
32337 wxPyEndAllowThreads(__tstate);
32338 if (PyErr_Occurred()) SWIG_fail;
32339 }
32340 Py_INCREF(Py_None); resultobj = Py_None;
32341 return resultobj;
32342 fail:
32343 return NULL;
32344 }
32345
32346
32347 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32348 PyObject *resultobj;
32349 wxWindow *arg1 = (wxWindow *) 0 ;
32350 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32351 PyObject * obj0 = 0 ;
32352 PyObject * obj1 = 0 ;
32353 char *kwnames[] = {
32354 (char *) "self",(char *) "constraints", NULL
32355 };
32356
32357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32359 if (SWIG_arg_fail(1)) SWIG_fail;
32360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32361 if (SWIG_arg_fail(2)) SWIG_fail;
32362 {
32363 PyThreadState* __tstate = wxPyBeginAllowThreads();
32364 (arg1)->SetConstraints(arg2);
32365
32366 wxPyEndAllowThreads(__tstate);
32367 if (PyErr_Occurred()) SWIG_fail;
32368 }
32369 Py_INCREF(Py_None); resultobj = Py_None;
32370 return resultobj;
32371 fail:
32372 return NULL;
32373 }
32374
32375
32376 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32377 PyObject *resultobj;
32378 wxWindow *arg1 = (wxWindow *) 0 ;
32379 wxLayoutConstraints *result;
32380 PyObject * obj0 = 0 ;
32381 char *kwnames[] = {
32382 (char *) "self", NULL
32383 };
32384
32385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32387 if (SWIG_arg_fail(1)) SWIG_fail;
32388 {
32389 PyThreadState* __tstate = wxPyBeginAllowThreads();
32390 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32391
32392 wxPyEndAllowThreads(__tstate);
32393 if (PyErr_Occurred()) SWIG_fail;
32394 }
32395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32396 return resultobj;
32397 fail:
32398 return NULL;
32399 }
32400
32401
32402 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32403 PyObject *resultobj;
32404 wxWindow *arg1 = (wxWindow *) 0 ;
32405 bool arg2 ;
32406 PyObject * obj0 = 0 ;
32407 PyObject * obj1 = 0 ;
32408 char *kwnames[] = {
32409 (char *) "self",(char *) "autoLayout", NULL
32410 };
32411
32412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32414 if (SWIG_arg_fail(1)) SWIG_fail;
32415 {
32416 arg2 = (bool)(SWIG_As_bool(obj1));
32417 if (SWIG_arg_fail(2)) SWIG_fail;
32418 }
32419 {
32420 PyThreadState* __tstate = wxPyBeginAllowThreads();
32421 (arg1)->SetAutoLayout(arg2);
32422
32423 wxPyEndAllowThreads(__tstate);
32424 if (PyErr_Occurred()) SWIG_fail;
32425 }
32426 Py_INCREF(Py_None); resultobj = Py_None;
32427 return resultobj;
32428 fail:
32429 return NULL;
32430 }
32431
32432
32433 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32434 PyObject *resultobj;
32435 wxWindow *arg1 = (wxWindow *) 0 ;
32436 bool result;
32437 PyObject * obj0 = 0 ;
32438 char *kwnames[] = {
32439 (char *) "self", NULL
32440 };
32441
32442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32444 if (SWIG_arg_fail(1)) SWIG_fail;
32445 {
32446 PyThreadState* __tstate = wxPyBeginAllowThreads();
32447 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32448
32449 wxPyEndAllowThreads(__tstate);
32450 if (PyErr_Occurred()) SWIG_fail;
32451 }
32452 {
32453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32454 }
32455 return resultobj;
32456 fail:
32457 return NULL;
32458 }
32459
32460
32461 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32462 PyObject *resultobj;
32463 wxWindow *arg1 = (wxWindow *) 0 ;
32464 bool result;
32465 PyObject * obj0 = 0 ;
32466 char *kwnames[] = {
32467 (char *) "self", NULL
32468 };
32469
32470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32472 if (SWIG_arg_fail(1)) SWIG_fail;
32473 {
32474 PyThreadState* __tstate = wxPyBeginAllowThreads();
32475 result = (bool)(arg1)->Layout();
32476
32477 wxPyEndAllowThreads(__tstate);
32478 if (PyErr_Occurred()) SWIG_fail;
32479 }
32480 {
32481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32482 }
32483 return resultobj;
32484 fail:
32485 return NULL;
32486 }
32487
32488
32489 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32490 PyObject *resultobj;
32491 wxWindow *arg1 = (wxWindow *) 0 ;
32492 wxSizer *arg2 = (wxSizer *) 0 ;
32493 bool arg3 = (bool) true ;
32494 PyObject * obj0 = 0 ;
32495 PyObject * obj1 = 0 ;
32496 PyObject * obj2 = 0 ;
32497 char *kwnames[] = {
32498 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32499 };
32500
32501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32503 if (SWIG_arg_fail(1)) SWIG_fail;
32504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32505 if (SWIG_arg_fail(2)) SWIG_fail;
32506 if (obj2) {
32507 {
32508 arg3 = (bool)(SWIG_As_bool(obj2));
32509 if (SWIG_arg_fail(3)) SWIG_fail;
32510 }
32511 }
32512 {
32513 PyThreadState* __tstate = wxPyBeginAllowThreads();
32514 (arg1)->SetSizer(arg2,arg3);
32515
32516 wxPyEndAllowThreads(__tstate);
32517 if (PyErr_Occurred()) SWIG_fail;
32518 }
32519 Py_INCREF(Py_None); resultobj = Py_None;
32520 return resultobj;
32521 fail:
32522 return NULL;
32523 }
32524
32525
32526 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32527 PyObject *resultobj;
32528 wxWindow *arg1 = (wxWindow *) 0 ;
32529 wxSizer *arg2 = (wxSizer *) 0 ;
32530 bool arg3 = (bool) true ;
32531 PyObject * obj0 = 0 ;
32532 PyObject * obj1 = 0 ;
32533 PyObject * obj2 = 0 ;
32534 char *kwnames[] = {
32535 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32536 };
32537
32538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32540 if (SWIG_arg_fail(1)) SWIG_fail;
32541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32542 if (SWIG_arg_fail(2)) SWIG_fail;
32543 if (obj2) {
32544 {
32545 arg3 = (bool)(SWIG_As_bool(obj2));
32546 if (SWIG_arg_fail(3)) SWIG_fail;
32547 }
32548 }
32549 {
32550 PyThreadState* __tstate = wxPyBeginAllowThreads();
32551 (arg1)->SetSizerAndFit(arg2,arg3);
32552
32553 wxPyEndAllowThreads(__tstate);
32554 if (PyErr_Occurred()) SWIG_fail;
32555 }
32556 Py_INCREF(Py_None); resultobj = Py_None;
32557 return resultobj;
32558 fail:
32559 return NULL;
32560 }
32561
32562
32563 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32564 PyObject *resultobj;
32565 wxWindow *arg1 = (wxWindow *) 0 ;
32566 wxSizer *result;
32567 PyObject * obj0 = 0 ;
32568 char *kwnames[] = {
32569 (char *) "self", NULL
32570 };
32571
32572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32574 if (SWIG_arg_fail(1)) SWIG_fail;
32575 {
32576 PyThreadState* __tstate = wxPyBeginAllowThreads();
32577 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32578
32579 wxPyEndAllowThreads(__tstate);
32580 if (PyErr_Occurred()) SWIG_fail;
32581 }
32582 {
32583 resultobj = wxPyMake_wxObject(result, 0);
32584 }
32585 return resultobj;
32586 fail:
32587 return NULL;
32588 }
32589
32590
32591 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32592 PyObject *resultobj;
32593 wxWindow *arg1 = (wxWindow *) 0 ;
32594 wxSizer *arg2 = (wxSizer *) 0 ;
32595 PyObject * obj0 = 0 ;
32596 PyObject * obj1 = 0 ;
32597 char *kwnames[] = {
32598 (char *) "self",(char *) "sizer", NULL
32599 };
32600
32601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32603 if (SWIG_arg_fail(1)) SWIG_fail;
32604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32605 if (SWIG_arg_fail(2)) SWIG_fail;
32606 {
32607 PyThreadState* __tstate = wxPyBeginAllowThreads();
32608 (arg1)->SetContainingSizer(arg2);
32609
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 Py_INCREF(Py_None); resultobj = Py_None;
32614 return resultobj;
32615 fail:
32616 return NULL;
32617 }
32618
32619
32620 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32621 PyObject *resultobj;
32622 wxWindow *arg1 = (wxWindow *) 0 ;
32623 wxSizer *result;
32624 PyObject * obj0 = 0 ;
32625 char *kwnames[] = {
32626 (char *) "self", NULL
32627 };
32628
32629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32631 if (SWIG_arg_fail(1)) SWIG_fail;
32632 {
32633 PyThreadState* __tstate = wxPyBeginAllowThreads();
32634 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32635
32636 wxPyEndAllowThreads(__tstate);
32637 if (PyErr_Occurred()) SWIG_fail;
32638 }
32639 {
32640 resultobj = wxPyMake_wxObject(result, 0);
32641 }
32642 return resultobj;
32643 fail:
32644 return NULL;
32645 }
32646
32647
32648 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32649 PyObject *resultobj;
32650 wxWindow *arg1 = (wxWindow *) 0 ;
32651 PyObject * obj0 = 0 ;
32652 char *kwnames[] = {
32653 (char *) "self", NULL
32654 };
32655
32656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32658 if (SWIG_arg_fail(1)) SWIG_fail;
32659 {
32660 PyThreadState* __tstate = wxPyBeginAllowThreads();
32661 (arg1)->InheritAttributes();
32662
32663 wxPyEndAllowThreads(__tstate);
32664 if (PyErr_Occurred()) SWIG_fail;
32665 }
32666 Py_INCREF(Py_None); resultobj = Py_None;
32667 return resultobj;
32668 fail:
32669 return NULL;
32670 }
32671
32672
32673 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32674 PyObject *resultobj;
32675 wxWindow *arg1 = (wxWindow *) 0 ;
32676 bool result;
32677 PyObject * obj0 = 0 ;
32678 char *kwnames[] = {
32679 (char *) "self", NULL
32680 };
32681
32682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32684 if (SWIG_arg_fail(1)) SWIG_fail;
32685 {
32686 PyThreadState* __tstate = wxPyBeginAllowThreads();
32687 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32688
32689 wxPyEndAllowThreads(__tstate);
32690 if (PyErr_Occurred()) SWIG_fail;
32691 }
32692 {
32693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32694 }
32695 return resultobj;
32696 fail:
32697 return NULL;
32698 }
32699
32700
32701 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32702 PyObject *obj;
32703 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32704 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32705 Py_INCREF(obj);
32706 return Py_BuildValue((char *)"");
32707 }
32708 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32709 PyObject *resultobj;
32710 long arg1 ;
32711 wxWindow *arg2 = (wxWindow *) NULL ;
32712 wxWindow *result;
32713 PyObject * obj0 = 0 ;
32714 PyObject * obj1 = 0 ;
32715 char *kwnames[] = {
32716 (char *) "id",(char *) "parent", NULL
32717 };
32718
32719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32720 {
32721 arg1 = (long)(SWIG_As_long(obj0));
32722 if (SWIG_arg_fail(1)) SWIG_fail;
32723 }
32724 if (obj1) {
32725 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32726 if (SWIG_arg_fail(2)) SWIG_fail;
32727 }
32728 {
32729 if (!wxPyCheckForApp()) SWIG_fail;
32730 PyThreadState* __tstate = wxPyBeginAllowThreads();
32731 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32732
32733 wxPyEndAllowThreads(__tstate);
32734 if (PyErr_Occurred()) SWIG_fail;
32735 }
32736 {
32737 resultobj = wxPyMake_wxObject(result, 0);
32738 }
32739 return resultobj;
32740 fail:
32741 return NULL;
32742 }
32743
32744
32745 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32746 PyObject *resultobj;
32747 wxString *arg1 = 0 ;
32748 wxWindow *arg2 = (wxWindow *) NULL ;
32749 wxWindow *result;
32750 bool temp1 = false ;
32751 PyObject * obj0 = 0 ;
32752 PyObject * obj1 = 0 ;
32753 char *kwnames[] = {
32754 (char *) "name",(char *) "parent", NULL
32755 };
32756
32757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32758 {
32759 arg1 = wxString_in_helper(obj0);
32760 if (arg1 == NULL) SWIG_fail;
32761 temp1 = true;
32762 }
32763 if (obj1) {
32764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32765 if (SWIG_arg_fail(2)) SWIG_fail;
32766 }
32767 {
32768 if (!wxPyCheckForApp()) SWIG_fail;
32769 PyThreadState* __tstate = wxPyBeginAllowThreads();
32770 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32771
32772 wxPyEndAllowThreads(__tstate);
32773 if (PyErr_Occurred()) SWIG_fail;
32774 }
32775 {
32776 resultobj = wxPyMake_wxObject(result, 0);
32777 }
32778 {
32779 if (temp1)
32780 delete arg1;
32781 }
32782 return resultobj;
32783 fail:
32784 {
32785 if (temp1)
32786 delete arg1;
32787 }
32788 return NULL;
32789 }
32790
32791
32792 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32793 PyObject *resultobj;
32794 wxString *arg1 = 0 ;
32795 wxWindow *arg2 = (wxWindow *) NULL ;
32796 wxWindow *result;
32797 bool temp1 = false ;
32798 PyObject * obj0 = 0 ;
32799 PyObject * obj1 = 0 ;
32800 char *kwnames[] = {
32801 (char *) "label",(char *) "parent", NULL
32802 };
32803
32804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32805 {
32806 arg1 = wxString_in_helper(obj0);
32807 if (arg1 == NULL) SWIG_fail;
32808 temp1 = true;
32809 }
32810 if (obj1) {
32811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32812 if (SWIG_arg_fail(2)) SWIG_fail;
32813 }
32814 {
32815 if (!wxPyCheckForApp()) SWIG_fail;
32816 PyThreadState* __tstate = wxPyBeginAllowThreads();
32817 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32818
32819 wxPyEndAllowThreads(__tstate);
32820 if (PyErr_Occurred()) SWIG_fail;
32821 }
32822 {
32823 resultobj = wxPyMake_wxObject(result, 0);
32824 }
32825 {
32826 if (temp1)
32827 delete arg1;
32828 }
32829 return resultobj;
32830 fail:
32831 {
32832 if (temp1)
32833 delete arg1;
32834 }
32835 return NULL;
32836 }
32837
32838
32839 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32840 PyObject *resultobj;
32841 wxWindow *arg1 = (wxWindow *) 0 ;
32842 unsigned long arg2 ;
32843 wxWindow *result;
32844 PyObject * obj0 = 0 ;
32845 PyObject * obj1 = 0 ;
32846 char *kwnames[] = {
32847 (char *) "parent",(char *) "_hWnd", NULL
32848 };
32849
32850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32852 if (SWIG_arg_fail(1)) SWIG_fail;
32853 {
32854 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32855 if (SWIG_arg_fail(2)) SWIG_fail;
32856 }
32857 {
32858 PyThreadState* __tstate = wxPyBeginAllowThreads();
32859 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32860
32861 wxPyEndAllowThreads(__tstate);
32862 if (PyErr_Occurred()) SWIG_fail;
32863 }
32864 {
32865 resultobj = wxPyMake_wxObject(result, 0);
32866 }
32867 return resultobj;
32868 fail:
32869 return NULL;
32870 }
32871
32872
32873 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32874 PyObject *resultobj;
32875 PyObject *result;
32876 char *kwnames[] = {
32877 NULL
32878 };
32879
32880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32881 {
32882 PyThreadState* __tstate = wxPyBeginAllowThreads();
32883 result = (PyObject *)GetTopLevelWindows();
32884
32885 wxPyEndAllowThreads(__tstate);
32886 if (PyErr_Occurred()) SWIG_fail;
32887 }
32888 resultobj = result;
32889 return resultobj;
32890 fail:
32891 return NULL;
32892 }
32893
32894
32895 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32896 PyObject *resultobj;
32897 wxValidator *result;
32898 char *kwnames[] = {
32899 NULL
32900 };
32901
32902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32903 {
32904 PyThreadState* __tstate = wxPyBeginAllowThreads();
32905 result = (wxValidator *)new wxValidator();
32906
32907 wxPyEndAllowThreads(__tstate);
32908 if (PyErr_Occurred()) SWIG_fail;
32909 }
32910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32911 return resultobj;
32912 fail:
32913 return NULL;
32914 }
32915
32916
32917 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32918 PyObject *resultobj;
32919 wxValidator *arg1 = (wxValidator *) 0 ;
32920 wxValidator *result;
32921 PyObject * obj0 = 0 ;
32922 char *kwnames[] = {
32923 (char *) "self", NULL
32924 };
32925
32926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32928 if (SWIG_arg_fail(1)) SWIG_fail;
32929 {
32930 PyThreadState* __tstate = wxPyBeginAllowThreads();
32931 result = (wxValidator *)(arg1)->Clone();
32932
32933 wxPyEndAllowThreads(__tstate);
32934 if (PyErr_Occurred()) SWIG_fail;
32935 }
32936 {
32937 resultobj = wxPyMake_wxObject(result, 0);
32938 }
32939 return resultobj;
32940 fail:
32941 return NULL;
32942 }
32943
32944
32945 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32946 PyObject *resultobj;
32947 wxValidator *arg1 = (wxValidator *) 0 ;
32948 wxWindow *arg2 = (wxWindow *) 0 ;
32949 bool result;
32950 PyObject * obj0 = 0 ;
32951 PyObject * obj1 = 0 ;
32952 char *kwnames[] = {
32953 (char *) "self",(char *) "parent", NULL
32954 };
32955
32956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32958 if (SWIG_arg_fail(1)) SWIG_fail;
32959 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32960 if (SWIG_arg_fail(2)) SWIG_fail;
32961 {
32962 PyThreadState* __tstate = wxPyBeginAllowThreads();
32963 result = (bool)(arg1)->Validate(arg2);
32964
32965 wxPyEndAllowThreads(__tstate);
32966 if (PyErr_Occurred()) SWIG_fail;
32967 }
32968 {
32969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32970 }
32971 return resultobj;
32972 fail:
32973 return NULL;
32974 }
32975
32976
32977 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32978 PyObject *resultobj;
32979 wxValidator *arg1 = (wxValidator *) 0 ;
32980 bool result;
32981 PyObject * obj0 = 0 ;
32982 char *kwnames[] = {
32983 (char *) "self", NULL
32984 };
32985
32986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32988 if (SWIG_arg_fail(1)) SWIG_fail;
32989 {
32990 PyThreadState* __tstate = wxPyBeginAllowThreads();
32991 result = (bool)(arg1)->TransferToWindow();
32992
32993 wxPyEndAllowThreads(__tstate);
32994 if (PyErr_Occurred()) SWIG_fail;
32995 }
32996 {
32997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32998 }
32999 return resultobj;
33000 fail:
33001 return NULL;
33002 }
33003
33004
33005 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33006 PyObject *resultobj;
33007 wxValidator *arg1 = (wxValidator *) 0 ;
33008 bool result;
33009 PyObject * obj0 = 0 ;
33010 char *kwnames[] = {
33011 (char *) "self", NULL
33012 };
33013
33014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33016 if (SWIG_arg_fail(1)) SWIG_fail;
33017 {
33018 PyThreadState* __tstate = wxPyBeginAllowThreads();
33019 result = (bool)(arg1)->TransferFromWindow();
33020
33021 wxPyEndAllowThreads(__tstate);
33022 if (PyErr_Occurred()) SWIG_fail;
33023 }
33024 {
33025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33026 }
33027 return resultobj;
33028 fail:
33029 return NULL;
33030 }
33031
33032
33033 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33034 PyObject *resultobj;
33035 wxValidator *arg1 = (wxValidator *) 0 ;
33036 wxWindow *result;
33037 PyObject * obj0 = 0 ;
33038 char *kwnames[] = {
33039 (char *) "self", NULL
33040 };
33041
33042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33044 if (SWIG_arg_fail(1)) SWIG_fail;
33045 {
33046 PyThreadState* __tstate = wxPyBeginAllowThreads();
33047 result = (wxWindow *)(arg1)->GetWindow();
33048
33049 wxPyEndAllowThreads(__tstate);
33050 if (PyErr_Occurred()) SWIG_fail;
33051 }
33052 {
33053 resultobj = wxPyMake_wxObject(result, 0);
33054 }
33055 return resultobj;
33056 fail:
33057 return NULL;
33058 }
33059
33060
33061 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33062 PyObject *resultobj;
33063 wxValidator *arg1 = (wxValidator *) 0 ;
33064 wxWindow *arg2 = (wxWindow *) 0 ;
33065 PyObject * obj0 = 0 ;
33066 PyObject * obj1 = 0 ;
33067 char *kwnames[] = {
33068 (char *) "self",(char *) "window", NULL
33069 };
33070
33071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33073 if (SWIG_arg_fail(1)) SWIG_fail;
33074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33075 if (SWIG_arg_fail(2)) SWIG_fail;
33076 {
33077 PyThreadState* __tstate = wxPyBeginAllowThreads();
33078 (arg1)->SetWindow(arg2);
33079
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 Py_INCREF(Py_None); resultobj = Py_None;
33084 return resultobj;
33085 fail:
33086 return NULL;
33087 }
33088
33089
33090 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33091 PyObject *resultobj;
33092 bool result;
33093 char *kwnames[] = {
33094 NULL
33095 };
33096
33097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 result = (bool)wxValidator::IsSilent();
33101
33102 wxPyEndAllowThreads(__tstate);
33103 if (PyErr_Occurred()) SWIG_fail;
33104 }
33105 {
33106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33107 }
33108 return resultobj;
33109 fail:
33110 return NULL;
33111 }
33112
33113
33114 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33115 PyObject *resultobj;
33116 int arg1 = (int) true ;
33117 PyObject * obj0 = 0 ;
33118 char *kwnames[] = {
33119 (char *) "doIt", NULL
33120 };
33121
33122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33123 if (obj0) {
33124 {
33125 arg1 = (int)(SWIG_As_int(obj0));
33126 if (SWIG_arg_fail(1)) SWIG_fail;
33127 }
33128 }
33129 {
33130 PyThreadState* __tstate = wxPyBeginAllowThreads();
33131 wxValidator::SetBellOnError(arg1);
33132
33133 wxPyEndAllowThreads(__tstate);
33134 if (PyErr_Occurred()) SWIG_fail;
33135 }
33136 Py_INCREF(Py_None); resultobj = Py_None;
33137 return resultobj;
33138 fail:
33139 return NULL;
33140 }
33141
33142
33143 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33144 PyObject *obj;
33145 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33146 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33147 Py_INCREF(obj);
33148 return Py_BuildValue((char *)"");
33149 }
33150 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33151 PyObject *resultobj;
33152 wxPyValidator *result;
33153 char *kwnames[] = {
33154 NULL
33155 };
33156
33157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33158 {
33159 PyThreadState* __tstate = wxPyBeginAllowThreads();
33160 result = (wxPyValidator *)new wxPyValidator();
33161
33162 wxPyEndAllowThreads(__tstate);
33163 if (PyErr_Occurred()) SWIG_fail;
33164 }
33165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33166 return resultobj;
33167 fail:
33168 return NULL;
33169 }
33170
33171
33172 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33173 PyObject *resultobj;
33174 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33175 PyObject *arg2 = (PyObject *) 0 ;
33176 PyObject *arg3 = (PyObject *) 0 ;
33177 int arg4 = (int) true ;
33178 PyObject * obj0 = 0 ;
33179 PyObject * obj1 = 0 ;
33180 PyObject * obj2 = 0 ;
33181 PyObject * obj3 = 0 ;
33182 char *kwnames[] = {
33183 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33184 };
33185
33186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33188 if (SWIG_arg_fail(1)) SWIG_fail;
33189 arg2 = obj1;
33190 arg3 = obj2;
33191 if (obj3) {
33192 {
33193 arg4 = (int)(SWIG_As_int(obj3));
33194 if (SWIG_arg_fail(4)) SWIG_fail;
33195 }
33196 }
33197 {
33198 PyThreadState* __tstate = wxPyBeginAllowThreads();
33199 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33200
33201 wxPyEndAllowThreads(__tstate);
33202 if (PyErr_Occurred()) SWIG_fail;
33203 }
33204 Py_INCREF(Py_None); resultobj = Py_None;
33205 return resultobj;
33206 fail:
33207 return NULL;
33208 }
33209
33210
33211 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33212 PyObject *obj;
33213 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33214 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33215 Py_INCREF(obj);
33216 return Py_BuildValue((char *)"");
33217 }
33218 static int _wrap_DefaultValidator_set(PyObject *) {
33219 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33220 return 1;
33221 }
33222
33223
33224 static PyObject *_wrap_DefaultValidator_get(void) {
33225 PyObject *pyobj;
33226
33227 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33228 return pyobj;
33229 }
33230
33231
33232 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33233 PyObject *resultobj;
33234 wxString const &arg1_defvalue = wxPyEmptyString ;
33235 wxString *arg1 = (wxString *) &arg1_defvalue ;
33236 long arg2 = (long) 0 ;
33237 wxMenu *result;
33238 bool temp1 = false ;
33239 PyObject * obj0 = 0 ;
33240 PyObject * obj1 = 0 ;
33241 char *kwnames[] = {
33242 (char *) "title",(char *) "style", NULL
33243 };
33244
33245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33246 if (obj0) {
33247 {
33248 arg1 = wxString_in_helper(obj0);
33249 if (arg1 == NULL) SWIG_fail;
33250 temp1 = true;
33251 }
33252 }
33253 if (obj1) {
33254 {
33255 arg2 = (long)(SWIG_As_long(obj1));
33256 if (SWIG_arg_fail(2)) SWIG_fail;
33257 }
33258 }
33259 {
33260 if (!wxPyCheckForApp()) SWIG_fail;
33261 PyThreadState* __tstate = wxPyBeginAllowThreads();
33262 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33263
33264 wxPyEndAllowThreads(__tstate);
33265 if (PyErr_Occurred()) SWIG_fail;
33266 }
33267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33268 {
33269 if (temp1)
33270 delete arg1;
33271 }
33272 return resultobj;
33273 fail:
33274 {
33275 if (temp1)
33276 delete arg1;
33277 }
33278 return NULL;
33279 }
33280
33281
33282 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33283 PyObject *resultobj;
33284 wxMenu *arg1 = (wxMenu *) 0 ;
33285 int arg2 ;
33286 wxString *arg3 = 0 ;
33287 wxString const &arg4_defvalue = wxPyEmptyString ;
33288 wxString *arg4 = (wxString *) &arg4_defvalue ;
33289 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33290 wxMenuItem *result;
33291 bool temp3 = false ;
33292 bool temp4 = false ;
33293 PyObject * obj0 = 0 ;
33294 PyObject * obj1 = 0 ;
33295 PyObject * obj2 = 0 ;
33296 PyObject * obj3 = 0 ;
33297 PyObject * obj4 = 0 ;
33298 char *kwnames[] = {
33299 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33300 };
33301
33302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33304 if (SWIG_arg_fail(1)) SWIG_fail;
33305 {
33306 arg2 = (int)(SWIG_As_int(obj1));
33307 if (SWIG_arg_fail(2)) SWIG_fail;
33308 }
33309 {
33310 arg3 = wxString_in_helper(obj2);
33311 if (arg3 == NULL) SWIG_fail;
33312 temp3 = true;
33313 }
33314 if (obj3) {
33315 {
33316 arg4 = wxString_in_helper(obj3);
33317 if (arg4 == NULL) SWIG_fail;
33318 temp4 = true;
33319 }
33320 }
33321 if (obj4) {
33322 {
33323 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33324 if (SWIG_arg_fail(5)) SWIG_fail;
33325 }
33326 }
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33330
33331 wxPyEndAllowThreads(__tstate);
33332 if (PyErr_Occurred()) SWIG_fail;
33333 }
33334 {
33335 resultobj = wxPyMake_wxObject(result, 0);
33336 }
33337 {
33338 if (temp3)
33339 delete arg3;
33340 }
33341 {
33342 if (temp4)
33343 delete arg4;
33344 }
33345 return resultobj;
33346 fail:
33347 {
33348 if (temp3)
33349 delete arg3;
33350 }
33351 {
33352 if (temp4)
33353 delete arg4;
33354 }
33355 return NULL;
33356 }
33357
33358
33359 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33360 PyObject *resultobj;
33361 wxMenu *arg1 = (wxMenu *) 0 ;
33362 wxMenuItem *result;
33363 PyObject * obj0 = 0 ;
33364 char *kwnames[] = {
33365 (char *) "self", NULL
33366 };
33367
33368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33370 if (SWIG_arg_fail(1)) SWIG_fail;
33371 {
33372 PyThreadState* __tstate = wxPyBeginAllowThreads();
33373 result = (wxMenuItem *)(arg1)->AppendSeparator();
33374
33375 wxPyEndAllowThreads(__tstate);
33376 if (PyErr_Occurred()) SWIG_fail;
33377 }
33378 {
33379 resultobj = wxPyMake_wxObject(result, 0);
33380 }
33381 return resultobj;
33382 fail:
33383 return NULL;
33384 }
33385
33386
33387 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33388 PyObject *resultobj;
33389 wxMenu *arg1 = (wxMenu *) 0 ;
33390 int arg2 ;
33391 wxString *arg3 = 0 ;
33392 wxString const &arg4_defvalue = wxPyEmptyString ;
33393 wxString *arg4 = (wxString *) &arg4_defvalue ;
33394 wxMenuItem *result;
33395 bool temp3 = false ;
33396 bool temp4 = false ;
33397 PyObject * obj0 = 0 ;
33398 PyObject * obj1 = 0 ;
33399 PyObject * obj2 = 0 ;
33400 PyObject * obj3 = 0 ;
33401 char *kwnames[] = {
33402 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33403 };
33404
33405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33407 if (SWIG_arg_fail(1)) SWIG_fail;
33408 {
33409 arg2 = (int)(SWIG_As_int(obj1));
33410 if (SWIG_arg_fail(2)) SWIG_fail;
33411 }
33412 {
33413 arg3 = wxString_in_helper(obj2);
33414 if (arg3 == NULL) SWIG_fail;
33415 temp3 = true;
33416 }
33417 if (obj3) {
33418 {
33419 arg4 = wxString_in_helper(obj3);
33420 if (arg4 == NULL) SWIG_fail;
33421 temp4 = true;
33422 }
33423 }
33424 {
33425 PyThreadState* __tstate = wxPyBeginAllowThreads();
33426 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33427
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 {
33432 resultobj = wxPyMake_wxObject(result, 0);
33433 }
33434 {
33435 if (temp3)
33436 delete arg3;
33437 }
33438 {
33439 if (temp4)
33440 delete arg4;
33441 }
33442 return resultobj;
33443 fail:
33444 {
33445 if (temp3)
33446 delete arg3;
33447 }
33448 {
33449 if (temp4)
33450 delete arg4;
33451 }
33452 return NULL;
33453 }
33454
33455
33456 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33457 PyObject *resultobj;
33458 wxMenu *arg1 = (wxMenu *) 0 ;
33459 int arg2 ;
33460 wxString *arg3 = 0 ;
33461 wxString const &arg4_defvalue = wxPyEmptyString ;
33462 wxString *arg4 = (wxString *) &arg4_defvalue ;
33463 wxMenuItem *result;
33464 bool temp3 = false ;
33465 bool temp4 = false ;
33466 PyObject * obj0 = 0 ;
33467 PyObject * obj1 = 0 ;
33468 PyObject * obj2 = 0 ;
33469 PyObject * obj3 = 0 ;
33470 char *kwnames[] = {
33471 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33472 };
33473
33474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33476 if (SWIG_arg_fail(1)) SWIG_fail;
33477 {
33478 arg2 = (int)(SWIG_As_int(obj1));
33479 if (SWIG_arg_fail(2)) SWIG_fail;
33480 }
33481 {
33482 arg3 = wxString_in_helper(obj2);
33483 if (arg3 == NULL) SWIG_fail;
33484 temp3 = true;
33485 }
33486 if (obj3) {
33487 {
33488 arg4 = wxString_in_helper(obj3);
33489 if (arg4 == NULL) SWIG_fail;
33490 temp4 = true;
33491 }
33492 }
33493 {
33494 PyThreadState* __tstate = wxPyBeginAllowThreads();
33495 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33496
33497 wxPyEndAllowThreads(__tstate);
33498 if (PyErr_Occurred()) SWIG_fail;
33499 }
33500 {
33501 resultobj = wxPyMake_wxObject(result, 0);
33502 }
33503 {
33504 if (temp3)
33505 delete arg3;
33506 }
33507 {
33508 if (temp4)
33509 delete arg4;
33510 }
33511 return resultobj;
33512 fail:
33513 {
33514 if (temp3)
33515 delete arg3;
33516 }
33517 {
33518 if (temp4)
33519 delete arg4;
33520 }
33521 return NULL;
33522 }
33523
33524
33525 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33526 PyObject *resultobj;
33527 wxMenu *arg1 = (wxMenu *) 0 ;
33528 int arg2 ;
33529 wxString *arg3 = 0 ;
33530 wxMenu *arg4 = (wxMenu *) 0 ;
33531 wxString const &arg5_defvalue = wxPyEmptyString ;
33532 wxString *arg5 = (wxString *) &arg5_defvalue ;
33533 wxMenuItem *result;
33534 bool temp3 = false ;
33535 bool temp5 = false ;
33536 PyObject * obj0 = 0 ;
33537 PyObject * obj1 = 0 ;
33538 PyObject * obj2 = 0 ;
33539 PyObject * obj3 = 0 ;
33540 PyObject * obj4 = 0 ;
33541 char *kwnames[] = {
33542 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33543 };
33544
33545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33547 if (SWIG_arg_fail(1)) SWIG_fail;
33548 {
33549 arg2 = (int)(SWIG_As_int(obj1));
33550 if (SWIG_arg_fail(2)) SWIG_fail;
33551 }
33552 {
33553 arg3 = wxString_in_helper(obj2);
33554 if (arg3 == NULL) SWIG_fail;
33555 temp3 = true;
33556 }
33557 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33558 if (SWIG_arg_fail(4)) SWIG_fail;
33559 if (obj4) {
33560 {
33561 arg5 = wxString_in_helper(obj4);
33562 if (arg5 == NULL) SWIG_fail;
33563 temp5 = true;
33564 }
33565 }
33566 {
33567 PyThreadState* __tstate = wxPyBeginAllowThreads();
33568 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33569
33570 wxPyEndAllowThreads(__tstate);
33571 if (PyErr_Occurred()) SWIG_fail;
33572 }
33573 {
33574 resultobj = wxPyMake_wxObject(result, 0);
33575 }
33576 {
33577 if (temp3)
33578 delete arg3;
33579 }
33580 {
33581 if (temp5)
33582 delete arg5;
33583 }
33584 return resultobj;
33585 fail:
33586 {
33587 if (temp3)
33588 delete arg3;
33589 }
33590 {
33591 if (temp5)
33592 delete arg5;
33593 }
33594 return NULL;
33595 }
33596
33597
33598 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33599 PyObject *resultobj;
33600 wxMenu *arg1 = (wxMenu *) 0 ;
33601 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33602 wxMenuItem *result;
33603 PyObject * obj0 = 0 ;
33604 PyObject * obj1 = 0 ;
33605 char *kwnames[] = {
33606 (char *) "self",(char *) "item", NULL
33607 };
33608
33609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33611 if (SWIG_arg_fail(1)) SWIG_fail;
33612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33613 if (SWIG_arg_fail(2)) SWIG_fail;
33614 {
33615 PyThreadState* __tstate = wxPyBeginAllowThreads();
33616 result = (wxMenuItem *)(arg1)->Append(arg2);
33617
33618 wxPyEndAllowThreads(__tstate);
33619 if (PyErr_Occurred()) SWIG_fail;
33620 }
33621 {
33622 resultobj = wxPyMake_wxObject(result, 0);
33623 }
33624 return resultobj;
33625 fail:
33626 return NULL;
33627 }
33628
33629
33630 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33631 PyObject *resultobj;
33632 wxMenu *arg1 = (wxMenu *) 0 ;
33633 PyObject * obj0 = 0 ;
33634 char *kwnames[] = {
33635 (char *) "self", NULL
33636 };
33637
33638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33640 if (SWIG_arg_fail(1)) SWIG_fail;
33641 {
33642 PyThreadState* __tstate = wxPyBeginAllowThreads();
33643 (arg1)->Break();
33644
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 Py_INCREF(Py_None); resultobj = Py_None;
33649 return resultobj;
33650 fail:
33651 return NULL;
33652 }
33653
33654
33655 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33656 PyObject *resultobj;
33657 wxMenu *arg1 = (wxMenu *) 0 ;
33658 size_t arg2 ;
33659 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33660 wxMenuItem *result;
33661 PyObject * obj0 = 0 ;
33662 PyObject * obj1 = 0 ;
33663 PyObject * obj2 = 0 ;
33664 char *kwnames[] = {
33665 (char *) "self",(char *) "pos",(char *) "item", NULL
33666 };
33667
33668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33670 if (SWIG_arg_fail(1)) SWIG_fail;
33671 {
33672 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33673 if (SWIG_arg_fail(2)) SWIG_fail;
33674 }
33675 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33676 if (SWIG_arg_fail(3)) SWIG_fail;
33677 {
33678 PyThreadState* __tstate = wxPyBeginAllowThreads();
33679 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33680
33681 wxPyEndAllowThreads(__tstate);
33682 if (PyErr_Occurred()) SWIG_fail;
33683 }
33684 {
33685 resultobj = wxPyMake_wxObject(result, 0);
33686 }
33687 return resultobj;
33688 fail:
33689 return NULL;
33690 }
33691
33692
33693 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33694 PyObject *resultobj;
33695 wxMenu *arg1 = (wxMenu *) 0 ;
33696 size_t arg2 ;
33697 int arg3 ;
33698 wxString *arg4 = 0 ;
33699 wxString const &arg5_defvalue = wxPyEmptyString ;
33700 wxString *arg5 = (wxString *) &arg5_defvalue ;
33701 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33702 wxMenuItem *result;
33703 bool temp4 = false ;
33704 bool temp5 = false ;
33705 PyObject * obj0 = 0 ;
33706 PyObject * obj1 = 0 ;
33707 PyObject * obj2 = 0 ;
33708 PyObject * obj3 = 0 ;
33709 PyObject * obj4 = 0 ;
33710 PyObject * obj5 = 0 ;
33711 char *kwnames[] = {
33712 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33713 };
33714
33715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33717 if (SWIG_arg_fail(1)) SWIG_fail;
33718 {
33719 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33720 if (SWIG_arg_fail(2)) SWIG_fail;
33721 }
33722 {
33723 arg3 = (int)(SWIG_As_int(obj2));
33724 if (SWIG_arg_fail(3)) SWIG_fail;
33725 }
33726 {
33727 arg4 = wxString_in_helper(obj3);
33728 if (arg4 == NULL) SWIG_fail;
33729 temp4 = true;
33730 }
33731 if (obj4) {
33732 {
33733 arg5 = wxString_in_helper(obj4);
33734 if (arg5 == NULL) SWIG_fail;
33735 temp5 = true;
33736 }
33737 }
33738 if (obj5) {
33739 {
33740 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33741 if (SWIG_arg_fail(6)) SWIG_fail;
33742 }
33743 }
33744 {
33745 PyThreadState* __tstate = wxPyBeginAllowThreads();
33746 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33747
33748 wxPyEndAllowThreads(__tstate);
33749 if (PyErr_Occurred()) SWIG_fail;
33750 }
33751 {
33752 resultobj = wxPyMake_wxObject(result, 0);
33753 }
33754 {
33755 if (temp4)
33756 delete arg4;
33757 }
33758 {
33759 if (temp5)
33760 delete arg5;
33761 }
33762 return resultobj;
33763 fail:
33764 {
33765 if (temp4)
33766 delete arg4;
33767 }
33768 {
33769 if (temp5)
33770 delete arg5;
33771 }
33772 return NULL;
33773 }
33774
33775
33776 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33777 PyObject *resultobj;
33778 wxMenu *arg1 = (wxMenu *) 0 ;
33779 size_t arg2 ;
33780 wxMenuItem *result;
33781 PyObject * obj0 = 0 ;
33782 PyObject * obj1 = 0 ;
33783 char *kwnames[] = {
33784 (char *) "self",(char *) "pos", NULL
33785 };
33786
33787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33789 if (SWIG_arg_fail(1)) SWIG_fail;
33790 {
33791 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33792 if (SWIG_arg_fail(2)) SWIG_fail;
33793 }
33794 {
33795 PyThreadState* __tstate = wxPyBeginAllowThreads();
33796 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33797
33798 wxPyEndAllowThreads(__tstate);
33799 if (PyErr_Occurred()) SWIG_fail;
33800 }
33801 {
33802 resultobj = wxPyMake_wxObject(result, 0);
33803 }
33804 return resultobj;
33805 fail:
33806 return NULL;
33807 }
33808
33809
33810 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33811 PyObject *resultobj;
33812 wxMenu *arg1 = (wxMenu *) 0 ;
33813 size_t arg2 ;
33814 int arg3 ;
33815 wxString *arg4 = 0 ;
33816 wxString const &arg5_defvalue = wxPyEmptyString ;
33817 wxString *arg5 = (wxString *) &arg5_defvalue ;
33818 wxMenuItem *result;
33819 bool temp4 = false ;
33820 bool temp5 = false ;
33821 PyObject * obj0 = 0 ;
33822 PyObject * obj1 = 0 ;
33823 PyObject * obj2 = 0 ;
33824 PyObject * obj3 = 0 ;
33825 PyObject * obj4 = 0 ;
33826 char *kwnames[] = {
33827 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33828 };
33829
33830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33832 if (SWIG_arg_fail(1)) SWIG_fail;
33833 {
33834 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33835 if (SWIG_arg_fail(2)) SWIG_fail;
33836 }
33837 {
33838 arg3 = (int)(SWIG_As_int(obj2));
33839 if (SWIG_arg_fail(3)) SWIG_fail;
33840 }
33841 {
33842 arg4 = wxString_in_helper(obj3);
33843 if (arg4 == NULL) SWIG_fail;
33844 temp4 = true;
33845 }
33846 if (obj4) {
33847 {
33848 arg5 = wxString_in_helper(obj4);
33849 if (arg5 == NULL) SWIG_fail;
33850 temp5 = true;
33851 }
33852 }
33853 {
33854 PyThreadState* __tstate = wxPyBeginAllowThreads();
33855 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33856
33857 wxPyEndAllowThreads(__tstate);
33858 if (PyErr_Occurred()) SWIG_fail;
33859 }
33860 {
33861 resultobj = wxPyMake_wxObject(result, 0);
33862 }
33863 {
33864 if (temp4)
33865 delete arg4;
33866 }
33867 {
33868 if (temp5)
33869 delete arg5;
33870 }
33871 return resultobj;
33872 fail:
33873 {
33874 if (temp4)
33875 delete arg4;
33876 }
33877 {
33878 if (temp5)
33879 delete arg5;
33880 }
33881 return NULL;
33882 }
33883
33884
33885 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33886 PyObject *resultobj;
33887 wxMenu *arg1 = (wxMenu *) 0 ;
33888 size_t arg2 ;
33889 int arg3 ;
33890 wxString *arg4 = 0 ;
33891 wxString const &arg5_defvalue = wxPyEmptyString ;
33892 wxString *arg5 = (wxString *) &arg5_defvalue ;
33893 wxMenuItem *result;
33894 bool temp4 = false ;
33895 bool temp5 = false ;
33896 PyObject * obj0 = 0 ;
33897 PyObject * obj1 = 0 ;
33898 PyObject * obj2 = 0 ;
33899 PyObject * obj3 = 0 ;
33900 PyObject * obj4 = 0 ;
33901 char *kwnames[] = {
33902 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33903 };
33904
33905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33907 if (SWIG_arg_fail(1)) SWIG_fail;
33908 {
33909 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33910 if (SWIG_arg_fail(2)) SWIG_fail;
33911 }
33912 {
33913 arg3 = (int)(SWIG_As_int(obj2));
33914 if (SWIG_arg_fail(3)) SWIG_fail;
33915 }
33916 {
33917 arg4 = wxString_in_helper(obj3);
33918 if (arg4 == NULL) SWIG_fail;
33919 temp4 = true;
33920 }
33921 if (obj4) {
33922 {
33923 arg5 = wxString_in_helper(obj4);
33924 if (arg5 == NULL) SWIG_fail;
33925 temp5 = true;
33926 }
33927 }
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33931
33932 wxPyEndAllowThreads(__tstate);
33933 if (PyErr_Occurred()) SWIG_fail;
33934 }
33935 {
33936 resultobj = wxPyMake_wxObject(result, 0);
33937 }
33938 {
33939 if (temp4)
33940 delete arg4;
33941 }
33942 {
33943 if (temp5)
33944 delete arg5;
33945 }
33946 return resultobj;
33947 fail:
33948 {
33949 if (temp4)
33950 delete arg4;
33951 }
33952 {
33953 if (temp5)
33954 delete arg5;
33955 }
33956 return NULL;
33957 }
33958
33959
33960 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33961 PyObject *resultobj;
33962 wxMenu *arg1 = (wxMenu *) 0 ;
33963 size_t arg2 ;
33964 int arg3 ;
33965 wxString *arg4 = 0 ;
33966 wxMenu *arg5 = (wxMenu *) 0 ;
33967 wxString const &arg6_defvalue = wxPyEmptyString ;
33968 wxString *arg6 = (wxString *) &arg6_defvalue ;
33969 wxMenuItem *result;
33970 bool temp4 = false ;
33971 bool temp6 = false ;
33972 PyObject * obj0 = 0 ;
33973 PyObject * obj1 = 0 ;
33974 PyObject * obj2 = 0 ;
33975 PyObject * obj3 = 0 ;
33976 PyObject * obj4 = 0 ;
33977 PyObject * obj5 = 0 ;
33978 char *kwnames[] = {
33979 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33980 };
33981
33982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33984 if (SWIG_arg_fail(1)) SWIG_fail;
33985 {
33986 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33987 if (SWIG_arg_fail(2)) SWIG_fail;
33988 }
33989 {
33990 arg3 = (int)(SWIG_As_int(obj2));
33991 if (SWIG_arg_fail(3)) SWIG_fail;
33992 }
33993 {
33994 arg4 = wxString_in_helper(obj3);
33995 if (arg4 == NULL) SWIG_fail;
33996 temp4 = true;
33997 }
33998 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33999 if (SWIG_arg_fail(5)) SWIG_fail;
34000 if (obj5) {
34001 {
34002 arg6 = wxString_in_helper(obj5);
34003 if (arg6 == NULL) SWIG_fail;
34004 temp6 = true;
34005 }
34006 }
34007 {
34008 PyThreadState* __tstate = wxPyBeginAllowThreads();
34009 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34010
34011 wxPyEndAllowThreads(__tstate);
34012 if (PyErr_Occurred()) SWIG_fail;
34013 }
34014 {
34015 resultobj = wxPyMake_wxObject(result, 0);
34016 }
34017 {
34018 if (temp4)
34019 delete arg4;
34020 }
34021 {
34022 if (temp6)
34023 delete arg6;
34024 }
34025 return resultobj;
34026 fail:
34027 {
34028 if (temp4)
34029 delete arg4;
34030 }
34031 {
34032 if (temp6)
34033 delete arg6;
34034 }
34035 return NULL;
34036 }
34037
34038
34039 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 wxMenu *arg1 = (wxMenu *) 0 ;
34042 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34043 wxMenuItem *result;
34044 PyObject * obj0 = 0 ;
34045 PyObject * obj1 = 0 ;
34046 char *kwnames[] = {
34047 (char *) "self",(char *) "item", NULL
34048 };
34049
34050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34052 if (SWIG_arg_fail(1)) SWIG_fail;
34053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34054 if (SWIG_arg_fail(2)) SWIG_fail;
34055 {
34056 PyThreadState* __tstate = wxPyBeginAllowThreads();
34057 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34058
34059 wxPyEndAllowThreads(__tstate);
34060 if (PyErr_Occurred()) SWIG_fail;
34061 }
34062 {
34063 resultobj = wxPyMake_wxObject(result, 0);
34064 }
34065 return resultobj;
34066 fail:
34067 return NULL;
34068 }
34069
34070
34071 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34072 PyObject *resultobj;
34073 wxMenu *arg1 = (wxMenu *) 0 ;
34074 int arg2 ;
34075 wxString *arg3 = 0 ;
34076 wxString const &arg4_defvalue = wxPyEmptyString ;
34077 wxString *arg4 = (wxString *) &arg4_defvalue ;
34078 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34079 wxMenuItem *result;
34080 bool temp3 = false ;
34081 bool temp4 = false ;
34082 PyObject * obj0 = 0 ;
34083 PyObject * obj1 = 0 ;
34084 PyObject * obj2 = 0 ;
34085 PyObject * obj3 = 0 ;
34086 PyObject * obj4 = 0 ;
34087 char *kwnames[] = {
34088 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34089 };
34090
34091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34093 if (SWIG_arg_fail(1)) SWIG_fail;
34094 {
34095 arg2 = (int)(SWIG_As_int(obj1));
34096 if (SWIG_arg_fail(2)) SWIG_fail;
34097 }
34098 {
34099 arg3 = wxString_in_helper(obj2);
34100 if (arg3 == NULL) SWIG_fail;
34101 temp3 = true;
34102 }
34103 if (obj3) {
34104 {
34105 arg4 = wxString_in_helper(obj3);
34106 if (arg4 == NULL) SWIG_fail;
34107 temp4 = true;
34108 }
34109 }
34110 if (obj4) {
34111 {
34112 arg5 = (wxItemKind)(SWIG_As_int(obj4));
34113 if (SWIG_arg_fail(5)) SWIG_fail;
34114 }
34115 }
34116 {
34117 PyThreadState* __tstate = wxPyBeginAllowThreads();
34118 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
34119
34120 wxPyEndAllowThreads(__tstate);
34121 if (PyErr_Occurred()) SWIG_fail;
34122 }
34123 {
34124 resultobj = wxPyMake_wxObject(result, 0);
34125 }
34126 {
34127 if (temp3)
34128 delete arg3;
34129 }
34130 {
34131 if (temp4)
34132 delete arg4;
34133 }
34134 return resultobj;
34135 fail:
34136 {
34137 if (temp3)
34138 delete arg3;
34139 }
34140 {
34141 if (temp4)
34142 delete arg4;
34143 }
34144 return NULL;
34145 }
34146
34147
34148 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34149 PyObject *resultobj;
34150 wxMenu *arg1 = (wxMenu *) 0 ;
34151 wxMenuItem *result;
34152 PyObject * obj0 = 0 ;
34153 char *kwnames[] = {
34154 (char *) "self", NULL
34155 };
34156
34157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34159 if (SWIG_arg_fail(1)) SWIG_fail;
34160 {
34161 PyThreadState* __tstate = wxPyBeginAllowThreads();
34162 result = (wxMenuItem *)(arg1)->PrependSeparator();
34163
34164 wxPyEndAllowThreads(__tstate);
34165 if (PyErr_Occurred()) SWIG_fail;
34166 }
34167 {
34168 resultobj = wxPyMake_wxObject(result, 0);
34169 }
34170 return resultobj;
34171 fail:
34172 return NULL;
34173 }
34174
34175
34176 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34177 PyObject *resultobj;
34178 wxMenu *arg1 = (wxMenu *) 0 ;
34179 int arg2 ;
34180 wxString *arg3 = 0 ;
34181 wxString const &arg4_defvalue = wxPyEmptyString ;
34182 wxString *arg4 = (wxString *) &arg4_defvalue ;
34183 wxMenuItem *result;
34184 bool temp3 = false ;
34185 bool temp4 = false ;
34186 PyObject * obj0 = 0 ;
34187 PyObject * obj1 = 0 ;
34188 PyObject * obj2 = 0 ;
34189 PyObject * obj3 = 0 ;
34190 char *kwnames[] = {
34191 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34192 };
34193
34194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34196 if (SWIG_arg_fail(1)) SWIG_fail;
34197 {
34198 arg2 = (int)(SWIG_As_int(obj1));
34199 if (SWIG_arg_fail(2)) SWIG_fail;
34200 }
34201 {
34202 arg3 = wxString_in_helper(obj2);
34203 if (arg3 == NULL) SWIG_fail;
34204 temp3 = true;
34205 }
34206 if (obj3) {
34207 {
34208 arg4 = wxString_in_helper(obj3);
34209 if (arg4 == NULL) SWIG_fail;
34210 temp4 = true;
34211 }
34212 }
34213 {
34214 PyThreadState* __tstate = wxPyBeginAllowThreads();
34215 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34216
34217 wxPyEndAllowThreads(__tstate);
34218 if (PyErr_Occurred()) SWIG_fail;
34219 }
34220 {
34221 resultobj = wxPyMake_wxObject(result, 0);
34222 }
34223 {
34224 if (temp3)
34225 delete arg3;
34226 }
34227 {
34228 if (temp4)
34229 delete arg4;
34230 }
34231 return resultobj;
34232 fail:
34233 {
34234 if (temp3)
34235 delete arg3;
34236 }
34237 {
34238 if (temp4)
34239 delete arg4;
34240 }
34241 return NULL;
34242 }
34243
34244
34245 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34246 PyObject *resultobj;
34247 wxMenu *arg1 = (wxMenu *) 0 ;
34248 int arg2 ;
34249 wxString *arg3 = 0 ;
34250 wxString const &arg4_defvalue = wxPyEmptyString ;
34251 wxString *arg4 = (wxString *) &arg4_defvalue ;
34252 wxMenuItem *result;
34253 bool temp3 = false ;
34254 bool temp4 = false ;
34255 PyObject * obj0 = 0 ;
34256 PyObject * obj1 = 0 ;
34257 PyObject * obj2 = 0 ;
34258 PyObject * obj3 = 0 ;
34259 char *kwnames[] = {
34260 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34261 };
34262
34263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34265 if (SWIG_arg_fail(1)) SWIG_fail;
34266 {
34267 arg2 = (int)(SWIG_As_int(obj1));
34268 if (SWIG_arg_fail(2)) SWIG_fail;
34269 }
34270 {
34271 arg3 = wxString_in_helper(obj2);
34272 if (arg3 == NULL) SWIG_fail;
34273 temp3 = true;
34274 }
34275 if (obj3) {
34276 {
34277 arg4 = wxString_in_helper(obj3);
34278 if (arg4 == NULL) SWIG_fail;
34279 temp4 = true;
34280 }
34281 }
34282 {
34283 PyThreadState* __tstate = wxPyBeginAllowThreads();
34284 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34285
34286 wxPyEndAllowThreads(__tstate);
34287 if (PyErr_Occurred()) SWIG_fail;
34288 }
34289 {
34290 resultobj = wxPyMake_wxObject(result, 0);
34291 }
34292 {
34293 if (temp3)
34294 delete arg3;
34295 }
34296 {
34297 if (temp4)
34298 delete arg4;
34299 }
34300 return resultobj;
34301 fail:
34302 {
34303 if (temp3)
34304 delete arg3;
34305 }
34306 {
34307 if (temp4)
34308 delete arg4;
34309 }
34310 return NULL;
34311 }
34312
34313
34314 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34315 PyObject *resultobj;
34316 wxMenu *arg1 = (wxMenu *) 0 ;
34317 int arg2 ;
34318 wxString *arg3 = 0 ;
34319 wxMenu *arg4 = (wxMenu *) 0 ;
34320 wxString const &arg5_defvalue = wxPyEmptyString ;
34321 wxString *arg5 = (wxString *) &arg5_defvalue ;
34322 wxMenuItem *result;
34323 bool temp3 = false ;
34324 bool temp5 = false ;
34325 PyObject * obj0 = 0 ;
34326 PyObject * obj1 = 0 ;
34327 PyObject * obj2 = 0 ;
34328 PyObject * obj3 = 0 ;
34329 PyObject * obj4 = 0 ;
34330 char *kwnames[] = {
34331 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34332 };
34333
34334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34336 if (SWIG_arg_fail(1)) SWIG_fail;
34337 {
34338 arg2 = (int)(SWIG_As_int(obj1));
34339 if (SWIG_arg_fail(2)) SWIG_fail;
34340 }
34341 {
34342 arg3 = wxString_in_helper(obj2);
34343 if (arg3 == NULL) SWIG_fail;
34344 temp3 = true;
34345 }
34346 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34347 if (SWIG_arg_fail(4)) SWIG_fail;
34348 if (obj4) {
34349 {
34350 arg5 = wxString_in_helper(obj4);
34351 if (arg5 == NULL) SWIG_fail;
34352 temp5 = true;
34353 }
34354 }
34355 {
34356 PyThreadState* __tstate = wxPyBeginAllowThreads();
34357 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34358
34359 wxPyEndAllowThreads(__tstate);
34360 if (PyErr_Occurred()) SWIG_fail;
34361 }
34362 {
34363 resultobj = wxPyMake_wxObject(result, 0);
34364 }
34365 {
34366 if (temp3)
34367 delete arg3;
34368 }
34369 {
34370 if (temp5)
34371 delete arg5;
34372 }
34373 return resultobj;
34374 fail:
34375 {
34376 if (temp3)
34377 delete arg3;
34378 }
34379 {
34380 if (temp5)
34381 delete arg5;
34382 }
34383 return NULL;
34384 }
34385
34386
34387 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34388 PyObject *resultobj;
34389 wxMenu *arg1 = (wxMenu *) 0 ;
34390 int arg2 ;
34391 wxMenuItem *result;
34392 PyObject * obj0 = 0 ;
34393 PyObject * obj1 = 0 ;
34394 char *kwnames[] = {
34395 (char *) "self",(char *) "id", NULL
34396 };
34397
34398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34400 if (SWIG_arg_fail(1)) SWIG_fail;
34401 {
34402 arg2 = (int)(SWIG_As_int(obj1));
34403 if (SWIG_arg_fail(2)) SWIG_fail;
34404 }
34405 {
34406 PyThreadState* __tstate = wxPyBeginAllowThreads();
34407 result = (wxMenuItem *)(arg1)->Remove(arg2);
34408
34409 wxPyEndAllowThreads(__tstate);
34410 if (PyErr_Occurred()) SWIG_fail;
34411 }
34412 {
34413 resultobj = wxPyMake_wxObject(result, 0);
34414 }
34415 return resultobj;
34416 fail:
34417 return NULL;
34418 }
34419
34420
34421 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34422 PyObject *resultobj;
34423 wxMenu *arg1 = (wxMenu *) 0 ;
34424 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34425 wxMenuItem *result;
34426 PyObject * obj0 = 0 ;
34427 PyObject * obj1 = 0 ;
34428 char *kwnames[] = {
34429 (char *) "self",(char *) "item", NULL
34430 };
34431
34432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34434 if (SWIG_arg_fail(1)) SWIG_fail;
34435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34436 if (SWIG_arg_fail(2)) SWIG_fail;
34437 {
34438 PyThreadState* __tstate = wxPyBeginAllowThreads();
34439 result = (wxMenuItem *)(arg1)->Remove(arg2);
34440
34441 wxPyEndAllowThreads(__tstate);
34442 if (PyErr_Occurred()) SWIG_fail;
34443 }
34444 {
34445 resultobj = wxPyMake_wxObject(result, 0);
34446 }
34447 return resultobj;
34448 fail:
34449 return NULL;
34450 }
34451
34452
34453 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34454 PyObject *resultobj;
34455 wxMenu *arg1 = (wxMenu *) 0 ;
34456 int arg2 ;
34457 bool result;
34458 PyObject * obj0 = 0 ;
34459 PyObject * obj1 = 0 ;
34460 char *kwnames[] = {
34461 (char *) "self",(char *) "id", NULL
34462 };
34463
34464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34466 if (SWIG_arg_fail(1)) SWIG_fail;
34467 {
34468 arg2 = (int)(SWIG_As_int(obj1));
34469 if (SWIG_arg_fail(2)) SWIG_fail;
34470 }
34471 {
34472 PyThreadState* __tstate = wxPyBeginAllowThreads();
34473 result = (bool)(arg1)->Delete(arg2);
34474
34475 wxPyEndAllowThreads(__tstate);
34476 if (PyErr_Occurred()) SWIG_fail;
34477 }
34478 {
34479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34480 }
34481 return resultobj;
34482 fail:
34483 return NULL;
34484 }
34485
34486
34487 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34488 PyObject *resultobj;
34489 wxMenu *arg1 = (wxMenu *) 0 ;
34490 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34491 bool result;
34492 PyObject * obj0 = 0 ;
34493 PyObject * obj1 = 0 ;
34494 char *kwnames[] = {
34495 (char *) "self",(char *) "item", NULL
34496 };
34497
34498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34500 if (SWIG_arg_fail(1)) SWIG_fail;
34501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34502 if (SWIG_arg_fail(2)) SWIG_fail;
34503 {
34504 PyThreadState* __tstate = wxPyBeginAllowThreads();
34505 result = (bool)(arg1)->Delete(arg2);
34506
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 {
34511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34512 }
34513 return resultobj;
34514 fail:
34515 return NULL;
34516 }
34517
34518
34519 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34520 PyObject *resultobj;
34521 wxMenu *arg1 = (wxMenu *) 0 ;
34522 PyObject * obj0 = 0 ;
34523 char *kwnames[] = {
34524 (char *) "self", NULL
34525 };
34526
34527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34529 if (SWIG_arg_fail(1)) SWIG_fail;
34530 {
34531 PyThreadState* __tstate = wxPyBeginAllowThreads();
34532 wxMenu_Destroy(arg1);
34533
34534 wxPyEndAllowThreads(__tstate);
34535 if (PyErr_Occurred()) SWIG_fail;
34536 }
34537 Py_INCREF(Py_None); resultobj = Py_None;
34538 return resultobj;
34539 fail:
34540 return NULL;
34541 }
34542
34543
34544 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34545 PyObject *resultobj;
34546 wxMenu *arg1 = (wxMenu *) 0 ;
34547 int arg2 ;
34548 bool result;
34549 PyObject * obj0 = 0 ;
34550 PyObject * obj1 = 0 ;
34551 char *kwnames[] = {
34552 (char *) "self",(char *) "id", NULL
34553 };
34554
34555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34557 if (SWIG_arg_fail(1)) SWIG_fail;
34558 {
34559 arg2 = (int)(SWIG_As_int(obj1));
34560 if (SWIG_arg_fail(2)) SWIG_fail;
34561 }
34562 {
34563 PyThreadState* __tstate = wxPyBeginAllowThreads();
34564 result = (bool)(arg1)->Destroy(arg2);
34565
34566 wxPyEndAllowThreads(__tstate);
34567 if (PyErr_Occurred()) SWIG_fail;
34568 }
34569 {
34570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34571 }
34572 return resultobj;
34573 fail:
34574 return NULL;
34575 }
34576
34577
34578 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34579 PyObject *resultobj;
34580 wxMenu *arg1 = (wxMenu *) 0 ;
34581 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34582 bool result;
34583 PyObject * obj0 = 0 ;
34584 PyObject * obj1 = 0 ;
34585 char *kwnames[] = {
34586 (char *) "self",(char *) "item", NULL
34587 };
34588
34589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34591 if (SWIG_arg_fail(1)) SWIG_fail;
34592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34593 if (SWIG_arg_fail(2)) SWIG_fail;
34594 {
34595 PyThreadState* __tstate = wxPyBeginAllowThreads();
34596 result = (bool)(arg1)->Destroy(arg2);
34597
34598 wxPyEndAllowThreads(__tstate);
34599 if (PyErr_Occurred()) SWIG_fail;
34600 }
34601 {
34602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34603 }
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34611 PyObject *resultobj;
34612 wxMenu *arg1 = (wxMenu *) 0 ;
34613 size_t result;
34614 PyObject * obj0 = 0 ;
34615 char *kwnames[] = {
34616 (char *) "self", NULL
34617 };
34618
34619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34621 if (SWIG_arg_fail(1)) SWIG_fail;
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34625
34626 wxPyEndAllowThreads(__tstate);
34627 if (PyErr_Occurred()) SWIG_fail;
34628 }
34629 {
34630 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34631 }
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34639 PyObject *resultobj;
34640 wxMenu *arg1 = (wxMenu *) 0 ;
34641 PyObject *result;
34642 PyObject * obj0 = 0 ;
34643 char *kwnames[] = {
34644 (char *) "self", NULL
34645 };
34646
34647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34649 if (SWIG_arg_fail(1)) SWIG_fail;
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34653
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 resultobj = result;
34658 return resultobj;
34659 fail:
34660 return NULL;
34661 }
34662
34663
34664 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34665 PyObject *resultobj;
34666 wxMenu *arg1 = (wxMenu *) 0 ;
34667 wxString *arg2 = 0 ;
34668 int result;
34669 bool temp2 = false ;
34670 PyObject * obj0 = 0 ;
34671 PyObject * obj1 = 0 ;
34672 char *kwnames[] = {
34673 (char *) "self",(char *) "item", NULL
34674 };
34675
34676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34678 if (SWIG_arg_fail(1)) SWIG_fail;
34679 {
34680 arg2 = wxString_in_helper(obj1);
34681 if (arg2 == NULL) SWIG_fail;
34682 temp2 = true;
34683 }
34684 {
34685 PyThreadState* __tstate = wxPyBeginAllowThreads();
34686 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34687
34688 wxPyEndAllowThreads(__tstate);
34689 if (PyErr_Occurred()) SWIG_fail;
34690 }
34691 {
34692 resultobj = SWIG_From_int((int)(result));
34693 }
34694 {
34695 if (temp2)
34696 delete arg2;
34697 }
34698 return resultobj;
34699 fail:
34700 {
34701 if (temp2)
34702 delete arg2;
34703 }
34704 return NULL;
34705 }
34706
34707
34708 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34709 PyObject *resultobj;
34710 wxMenu *arg1 = (wxMenu *) 0 ;
34711 int arg2 ;
34712 wxMenuItem *result;
34713 PyObject * obj0 = 0 ;
34714 PyObject * obj1 = 0 ;
34715 char *kwnames[] = {
34716 (char *) "self",(char *) "id", NULL
34717 };
34718
34719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34721 if (SWIG_arg_fail(1)) SWIG_fail;
34722 {
34723 arg2 = (int)(SWIG_As_int(obj1));
34724 if (SWIG_arg_fail(2)) SWIG_fail;
34725 }
34726 {
34727 PyThreadState* __tstate = wxPyBeginAllowThreads();
34728 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34729
34730 wxPyEndAllowThreads(__tstate);
34731 if (PyErr_Occurred()) SWIG_fail;
34732 }
34733 {
34734 resultobj = wxPyMake_wxObject(result, 0);
34735 }
34736 return resultobj;
34737 fail:
34738 return NULL;
34739 }
34740
34741
34742 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34743 PyObject *resultobj;
34744 wxMenu *arg1 = (wxMenu *) 0 ;
34745 size_t arg2 ;
34746 wxMenuItem *result;
34747 PyObject * obj0 = 0 ;
34748 PyObject * obj1 = 0 ;
34749 char *kwnames[] = {
34750 (char *) "self",(char *) "position", NULL
34751 };
34752
34753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34755 if (SWIG_arg_fail(1)) SWIG_fail;
34756 {
34757 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34758 if (SWIG_arg_fail(2)) SWIG_fail;
34759 }
34760 {
34761 PyThreadState* __tstate = wxPyBeginAllowThreads();
34762 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34763
34764 wxPyEndAllowThreads(__tstate);
34765 if (PyErr_Occurred()) SWIG_fail;
34766 }
34767 {
34768 resultobj = wxPyMake_wxObject(result, 0);
34769 }
34770 return resultobj;
34771 fail:
34772 return NULL;
34773 }
34774
34775
34776 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34777 PyObject *resultobj;
34778 wxMenu *arg1 = (wxMenu *) 0 ;
34779 int arg2 ;
34780 bool arg3 ;
34781 PyObject * obj0 = 0 ;
34782 PyObject * obj1 = 0 ;
34783 PyObject * obj2 = 0 ;
34784 char *kwnames[] = {
34785 (char *) "self",(char *) "id",(char *) "enable", NULL
34786 };
34787
34788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34790 if (SWIG_arg_fail(1)) SWIG_fail;
34791 {
34792 arg2 = (int)(SWIG_As_int(obj1));
34793 if (SWIG_arg_fail(2)) SWIG_fail;
34794 }
34795 {
34796 arg3 = (bool)(SWIG_As_bool(obj2));
34797 if (SWIG_arg_fail(3)) SWIG_fail;
34798 }
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 (arg1)->Enable(arg2,arg3);
34802
34803 wxPyEndAllowThreads(__tstate);
34804 if (PyErr_Occurred()) SWIG_fail;
34805 }
34806 Py_INCREF(Py_None); resultobj = Py_None;
34807 return resultobj;
34808 fail:
34809 return NULL;
34810 }
34811
34812
34813 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34814 PyObject *resultobj;
34815 wxMenu *arg1 = (wxMenu *) 0 ;
34816 int arg2 ;
34817 bool result;
34818 PyObject * obj0 = 0 ;
34819 PyObject * obj1 = 0 ;
34820 char *kwnames[] = {
34821 (char *) "self",(char *) "id", NULL
34822 };
34823
34824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34826 if (SWIG_arg_fail(1)) SWIG_fail;
34827 {
34828 arg2 = (int)(SWIG_As_int(obj1));
34829 if (SWIG_arg_fail(2)) SWIG_fail;
34830 }
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34834
34835 wxPyEndAllowThreads(__tstate);
34836 if (PyErr_Occurred()) SWIG_fail;
34837 }
34838 {
34839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34840 }
34841 return resultobj;
34842 fail:
34843 return NULL;
34844 }
34845
34846
34847 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34848 PyObject *resultobj;
34849 wxMenu *arg1 = (wxMenu *) 0 ;
34850 int arg2 ;
34851 bool arg3 ;
34852 PyObject * obj0 = 0 ;
34853 PyObject * obj1 = 0 ;
34854 PyObject * obj2 = 0 ;
34855 char *kwnames[] = {
34856 (char *) "self",(char *) "id",(char *) "check", NULL
34857 };
34858
34859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34861 if (SWIG_arg_fail(1)) SWIG_fail;
34862 {
34863 arg2 = (int)(SWIG_As_int(obj1));
34864 if (SWIG_arg_fail(2)) SWIG_fail;
34865 }
34866 {
34867 arg3 = (bool)(SWIG_As_bool(obj2));
34868 if (SWIG_arg_fail(3)) SWIG_fail;
34869 }
34870 {
34871 PyThreadState* __tstate = wxPyBeginAllowThreads();
34872 (arg1)->Check(arg2,arg3);
34873
34874 wxPyEndAllowThreads(__tstate);
34875 if (PyErr_Occurred()) SWIG_fail;
34876 }
34877 Py_INCREF(Py_None); resultobj = Py_None;
34878 return resultobj;
34879 fail:
34880 return NULL;
34881 }
34882
34883
34884 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34885 PyObject *resultobj;
34886 wxMenu *arg1 = (wxMenu *) 0 ;
34887 int arg2 ;
34888 bool result;
34889 PyObject * obj0 = 0 ;
34890 PyObject * obj1 = 0 ;
34891 char *kwnames[] = {
34892 (char *) "self",(char *) "id", NULL
34893 };
34894
34895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34897 if (SWIG_arg_fail(1)) SWIG_fail;
34898 {
34899 arg2 = (int)(SWIG_As_int(obj1));
34900 if (SWIG_arg_fail(2)) SWIG_fail;
34901 }
34902 {
34903 PyThreadState* __tstate = wxPyBeginAllowThreads();
34904 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34905
34906 wxPyEndAllowThreads(__tstate);
34907 if (PyErr_Occurred()) SWIG_fail;
34908 }
34909 {
34910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34911 }
34912 return resultobj;
34913 fail:
34914 return NULL;
34915 }
34916
34917
34918 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34919 PyObject *resultobj;
34920 wxMenu *arg1 = (wxMenu *) 0 ;
34921 int arg2 ;
34922 wxString *arg3 = 0 ;
34923 bool temp3 = false ;
34924 PyObject * obj0 = 0 ;
34925 PyObject * obj1 = 0 ;
34926 PyObject * obj2 = 0 ;
34927 char *kwnames[] = {
34928 (char *) "self",(char *) "id",(char *) "label", NULL
34929 };
34930
34931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34933 if (SWIG_arg_fail(1)) SWIG_fail;
34934 {
34935 arg2 = (int)(SWIG_As_int(obj1));
34936 if (SWIG_arg_fail(2)) SWIG_fail;
34937 }
34938 {
34939 arg3 = wxString_in_helper(obj2);
34940 if (arg3 == NULL) SWIG_fail;
34941 temp3 = true;
34942 }
34943 {
34944 PyThreadState* __tstate = wxPyBeginAllowThreads();
34945 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34946
34947 wxPyEndAllowThreads(__tstate);
34948 if (PyErr_Occurred()) SWIG_fail;
34949 }
34950 Py_INCREF(Py_None); resultobj = Py_None;
34951 {
34952 if (temp3)
34953 delete arg3;
34954 }
34955 return resultobj;
34956 fail:
34957 {
34958 if (temp3)
34959 delete arg3;
34960 }
34961 return NULL;
34962 }
34963
34964
34965 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34966 PyObject *resultobj;
34967 wxMenu *arg1 = (wxMenu *) 0 ;
34968 int arg2 ;
34969 wxString result;
34970 PyObject * obj0 = 0 ;
34971 PyObject * obj1 = 0 ;
34972 char *kwnames[] = {
34973 (char *) "self",(char *) "id", NULL
34974 };
34975
34976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34978 if (SWIG_arg_fail(1)) SWIG_fail;
34979 {
34980 arg2 = (int)(SWIG_As_int(obj1));
34981 if (SWIG_arg_fail(2)) SWIG_fail;
34982 }
34983 {
34984 PyThreadState* __tstate = wxPyBeginAllowThreads();
34985 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34986
34987 wxPyEndAllowThreads(__tstate);
34988 if (PyErr_Occurred()) SWIG_fail;
34989 }
34990 {
34991 #if wxUSE_UNICODE
34992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34993 #else
34994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34995 #endif
34996 }
34997 return resultobj;
34998 fail:
34999 return NULL;
35000 }
35001
35002
35003 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35004 PyObject *resultobj;
35005 wxMenu *arg1 = (wxMenu *) 0 ;
35006 int arg2 ;
35007 wxString *arg3 = 0 ;
35008 bool temp3 = false ;
35009 PyObject * obj0 = 0 ;
35010 PyObject * obj1 = 0 ;
35011 PyObject * obj2 = 0 ;
35012 char *kwnames[] = {
35013 (char *) "self",(char *) "id",(char *) "helpString", NULL
35014 };
35015
35016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35018 if (SWIG_arg_fail(1)) SWIG_fail;
35019 {
35020 arg2 = (int)(SWIG_As_int(obj1));
35021 if (SWIG_arg_fail(2)) SWIG_fail;
35022 }
35023 {
35024 arg3 = wxString_in_helper(obj2);
35025 if (arg3 == NULL) SWIG_fail;
35026 temp3 = true;
35027 }
35028 {
35029 PyThreadState* __tstate = wxPyBeginAllowThreads();
35030 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35031
35032 wxPyEndAllowThreads(__tstate);
35033 if (PyErr_Occurred()) SWIG_fail;
35034 }
35035 Py_INCREF(Py_None); resultobj = Py_None;
35036 {
35037 if (temp3)
35038 delete arg3;
35039 }
35040 return resultobj;
35041 fail:
35042 {
35043 if (temp3)
35044 delete arg3;
35045 }
35046 return NULL;
35047 }
35048
35049
35050 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35051 PyObject *resultobj;
35052 wxMenu *arg1 = (wxMenu *) 0 ;
35053 int arg2 ;
35054 wxString result;
35055 PyObject * obj0 = 0 ;
35056 PyObject * obj1 = 0 ;
35057 char *kwnames[] = {
35058 (char *) "self",(char *) "id", NULL
35059 };
35060
35061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35063 if (SWIG_arg_fail(1)) SWIG_fail;
35064 {
35065 arg2 = (int)(SWIG_As_int(obj1));
35066 if (SWIG_arg_fail(2)) SWIG_fail;
35067 }
35068 {
35069 PyThreadState* __tstate = wxPyBeginAllowThreads();
35070 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35071
35072 wxPyEndAllowThreads(__tstate);
35073 if (PyErr_Occurred()) SWIG_fail;
35074 }
35075 {
35076 #if wxUSE_UNICODE
35077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35078 #else
35079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35080 #endif
35081 }
35082 return resultobj;
35083 fail:
35084 return NULL;
35085 }
35086
35087
35088 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35089 PyObject *resultobj;
35090 wxMenu *arg1 = (wxMenu *) 0 ;
35091 wxString *arg2 = 0 ;
35092 bool temp2 = false ;
35093 PyObject * obj0 = 0 ;
35094 PyObject * obj1 = 0 ;
35095 char *kwnames[] = {
35096 (char *) "self",(char *) "title", NULL
35097 };
35098
35099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35101 if (SWIG_arg_fail(1)) SWIG_fail;
35102 {
35103 arg2 = wxString_in_helper(obj1);
35104 if (arg2 == NULL) SWIG_fail;
35105 temp2 = true;
35106 }
35107 {
35108 PyThreadState* __tstate = wxPyBeginAllowThreads();
35109 (arg1)->SetTitle((wxString const &)*arg2);
35110
35111 wxPyEndAllowThreads(__tstate);
35112 if (PyErr_Occurred()) SWIG_fail;
35113 }
35114 Py_INCREF(Py_None); resultobj = Py_None;
35115 {
35116 if (temp2)
35117 delete arg2;
35118 }
35119 return resultobj;
35120 fail:
35121 {
35122 if (temp2)
35123 delete arg2;
35124 }
35125 return NULL;
35126 }
35127
35128
35129 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35130 PyObject *resultobj;
35131 wxMenu *arg1 = (wxMenu *) 0 ;
35132 wxString result;
35133 PyObject * obj0 = 0 ;
35134 char *kwnames[] = {
35135 (char *) "self", NULL
35136 };
35137
35138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35140 if (SWIG_arg_fail(1)) SWIG_fail;
35141 {
35142 PyThreadState* __tstate = wxPyBeginAllowThreads();
35143 result = ((wxMenu const *)arg1)->GetTitle();
35144
35145 wxPyEndAllowThreads(__tstate);
35146 if (PyErr_Occurred()) SWIG_fail;
35147 }
35148 {
35149 #if wxUSE_UNICODE
35150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35151 #else
35152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35153 #endif
35154 }
35155 return resultobj;
35156 fail:
35157 return NULL;
35158 }
35159
35160
35161 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35162 PyObject *resultobj;
35163 wxMenu *arg1 = (wxMenu *) 0 ;
35164 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35165 PyObject * obj0 = 0 ;
35166 PyObject * obj1 = 0 ;
35167 char *kwnames[] = {
35168 (char *) "self",(char *) "handler", NULL
35169 };
35170
35171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35173 if (SWIG_arg_fail(1)) SWIG_fail;
35174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35175 if (SWIG_arg_fail(2)) SWIG_fail;
35176 {
35177 PyThreadState* __tstate = wxPyBeginAllowThreads();
35178 (arg1)->SetEventHandler(arg2);
35179
35180 wxPyEndAllowThreads(__tstate);
35181 if (PyErr_Occurred()) SWIG_fail;
35182 }
35183 Py_INCREF(Py_None); resultobj = Py_None;
35184 return resultobj;
35185 fail:
35186 return NULL;
35187 }
35188
35189
35190 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35191 PyObject *resultobj;
35192 wxMenu *arg1 = (wxMenu *) 0 ;
35193 wxEvtHandler *result;
35194 PyObject * obj0 = 0 ;
35195 char *kwnames[] = {
35196 (char *) "self", NULL
35197 };
35198
35199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35201 if (SWIG_arg_fail(1)) SWIG_fail;
35202 {
35203 PyThreadState* __tstate = wxPyBeginAllowThreads();
35204 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35205
35206 wxPyEndAllowThreads(__tstate);
35207 if (PyErr_Occurred()) SWIG_fail;
35208 }
35209 {
35210 resultobj = wxPyMake_wxObject(result, 0);
35211 }
35212 return resultobj;
35213 fail:
35214 return NULL;
35215 }
35216
35217
35218 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35219 PyObject *resultobj;
35220 wxMenu *arg1 = (wxMenu *) 0 ;
35221 wxWindow *arg2 = (wxWindow *) 0 ;
35222 PyObject * obj0 = 0 ;
35223 PyObject * obj1 = 0 ;
35224 char *kwnames[] = {
35225 (char *) "self",(char *) "win", NULL
35226 };
35227
35228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35230 if (SWIG_arg_fail(1)) SWIG_fail;
35231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35232 if (SWIG_arg_fail(2)) SWIG_fail;
35233 {
35234 PyThreadState* __tstate = wxPyBeginAllowThreads();
35235 (arg1)->SetInvokingWindow(arg2);
35236
35237 wxPyEndAllowThreads(__tstate);
35238 if (PyErr_Occurred()) SWIG_fail;
35239 }
35240 Py_INCREF(Py_None); resultobj = Py_None;
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35248 PyObject *resultobj;
35249 wxMenu *arg1 = (wxMenu *) 0 ;
35250 wxWindow *result;
35251 PyObject * obj0 = 0 ;
35252 char *kwnames[] = {
35253 (char *) "self", NULL
35254 };
35255
35256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35258 if (SWIG_arg_fail(1)) SWIG_fail;
35259 {
35260 PyThreadState* __tstate = wxPyBeginAllowThreads();
35261 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35262
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 {
35267 resultobj = wxPyMake_wxObject(result, 0);
35268 }
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35276 PyObject *resultobj;
35277 wxMenu *arg1 = (wxMenu *) 0 ;
35278 long result;
35279 PyObject * obj0 = 0 ;
35280 char *kwnames[] = {
35281 (char *) "self", NULL
35282 };
35283
35284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35286 if (SWIG_arg_fail(1)) SWIG_fail;
35287 {
35288 PyThreadState* __tstate = wxPyBeginAllowThreads();
35289 result = (long)((wxMenu const *)arg1)->GetStyle();
35290
35291 wxPyEndAllowThreads(__tstate);
35292 if (PyErr_Occurred()) SWIG_fail;
35293 }
35294 {
35295 resultobj = SWIG_From_long((long)(result));
35296 }
35297 return resultobj;
35298 fail:
35299 return NULL;
35300 }
35301
35302
35303 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35304 PyObject *resultobj;
35305 wxMenu *arg1 = (wxMenu *) 0 ;
35306 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35307 PyObject * obj0 = 0 ;
35308 PyObject * obj1 = 0 ;
35309 char *kwnames[] = {
35310 (char *) "self",(char *) "source", NULL
35311 };
35312
35313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35315 if (SWIG_arg_fail(1)) SWIG_fail;
35316 if (obj1) {
35317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35318 if (SWIG_arg_fail(2)) SWIG_fail;
35319 }
35320 {
35321 PyThreadState* __tstate = wxPyBeginAllowThreads();
35322 (arg1)->UpdateUI(arg2);
35323
35324 wxPyEndAllowThreads(__tstate);
35325 if (PyErr_Occurred()) SWIG_fail;
35326 }
35327 Py_INCREF(Py_None); resultobj = Py_None;
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35335 PyObject *resultobj;
35336 wxMenu *arg1 = (wxMenu *) 0 ;
35337 wxMenuBar *result;
35338 PyObject * obj0 = 0 ;
35339 char *kwnames[] = {
35340 (char *) "self", NULL
35341 };
35342
35343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35345 if (SWIG_arg_fail(1)) SWIG_fail;
35346 {
35347 PyThreadState* __tstate = wxPyBeginAllowThreads();
35348 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35349
35350 wxPyEndAllowThreads(__tstate);
35351 if (PyErr_Occurred()) SWIG_fail;
35352 }
35353 {
35354 resultobj = wxPyMake_wxObject(result, 0);
35355 }
35356 return resultobj;
35357 fail:
35358 return NULL;
35359 }
35360
35361
35362 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35363 PyObject *resultobj;
35364 wxMenu *arg1 = (wxMenu *) 0 ;
35365 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35366 PyObject * obj0 = 0 ;
35367 PyObject * obj1 = 0 ;
35368 char *kwnames[] = {
35369 (char *) "self",(char *) "menubar", NULL
35370 };
35371
35372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35374 if (SWIG_arg_fail(1)) SWIG_fail;
35375 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35376 if (SWIG_arg_fail(2)) SWIG_fail;
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 (arg1)->Attach(arg2);
35380
35381 wxPyEndAllowThreads(__tstate);
35382 if (PyErr_Occurred()) SWIG_fail;
35383 }
35384 Py_INCREF(Py_None); resultobj = Py_None;
35385 return resultobj;
35386 fail:
35387 return NULL;
35388 }
35389
35390
35391 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35392 PyObject *resultobj;
35393 wxMenu *arg1 = (wxMenu *) 0 ;
35394 PyObject * obj0 = 0 ;
35395 char *kwnames[] = {
35396 (char *) "self", NULL
35397 };
35398
35399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35401 if (SWIG_arg_fail(1)) SWIG_fail;
35402 {
35403 PyThreadState* __tstate = wxPyBeginAllowThreads();
35404 (arg1)->Detach();
35405
35406 wxPyEndAllowThreads(__tstate);
35407 if (PyErr_Occurred()) SWIG_fail;
35408 }
35409 Py_INCREF(Py_None); resultobj = Py_None;
35410 return resultobj;
35411 fail:
35412 return NULL;
35413 }
35414
35415
35416 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35417 PyObject *resultobj;
35418 wxMenu *arg1 = (wxMenu *) 0 ;
35419 bool result;
35420 PyObject * obj0 = 0 ;
35421 char *kwnames[] = {
35422 (char *) "self", NULL
35423 };
35424
35425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35427 if (SWIG_arg_fail(1)) SWIG_fail;
35428 {
35429 PyThreadState* __tstate = wxPyBeginAllowThreads();
35430 result = (bool)((wxMenu const *)arg1)->IsAttached();
35431
35432 wxPyEndAllowThreads(__tstate);
35433 if (PyErr_Occurred()) SWIG_fail;
35434 }
35435 {
35436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35437 }
35438 return resultobj;
35439 fail:
35440 return NULL;
35441 }
35442
35443
35444 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35445 PyObject *resultobj;
35446 wxMenu *arg1 = (wxMenu *) 0 ;
35447 wxMenu *arg2 = (wxMenu *) 0 ;
35448 PyObject * obj0 = 0 ;
35449 PyObject * obj1 = 0 ;
35450 char *kwnames[] = {
35451 (char *) "self",(char *) "parent", NULL
35452 };
35453
35454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35456 if (SWIG_arg_fail(1)) SWIG_fail;
35457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35458 if (SWIG_arg_fail(2)) SWIG_fail;
35459 {
35460 PyThreadState* __tstate = wxPyBeginAllowThreads();
35461 (arg1)->SetParent(arg2);
35462
35463 wxPyEndAllowThreads(__tstate);
35464 if (PyErr_Occurred()) SWIG_fail;
35465 }
35466 Py_INCREF(Py_None); resultobj = Py_None;
35467 return resultobj;
35468 fail:
35469 return NULL;
35470 }
35471
35472
35473 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35474 PyObject *resultobj;
35475 wxMenu *arg1 = (wxMenu *) 0 ;
35476 wxMenu *result;
35477 PyObject * obj0 = 0 ;
35478 char *kwnames[] = {
35479 (char *) "self", NULL
35480 };
35481
35482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35484 if (SWIG_arg_fail(1)) SWIG_fail;
35485 {
35486 PyThreadState* __tstate = wxPyBeginAllowThreads();
35487 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35488
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 {
35493 resultobj = wxPyMake_wxObject(result, 0);
35494 }
35495 return resultobj;
35496 fail:
35497 return NULL;
35498 }
35499
35500
35501 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35502 PyObject *obj;
35503 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35504 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35505 Py_INCREF(obj);
35506 return Py_BuildValue((char *)"");
35507 }
35508 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35509 PyObject *resultobj;
35510 long arg1 = (long) 0 ;
35511 wxMenuBar *result;
35512 PyObject * obj0 = 0 ;
35513 char *kwnames[] = {
35514 (char *) "style", NULL
35515 };
35516
35517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35518 if (obj0) {
35519 {
35520 arg1 = (long)(SWIG_As_long(obj0));
35521 if (SWIG_arg_fail(1)) SWIG_fail;
35522 }
35523 }
35524 {
35525 if (!wxPyCheckForApp()) SWIG_fail;
35526 PyThreadState* __tstate = wxPyBeginAllowThreads();
35527 result = (wxMenuBar *)new wxMenuBar(arg1);
35528
35529 wxPyEndAllowThreads(__tstate);
35530 if (PyErr_Occurred()) SWIG_fail;
35531 }
35532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35533 return resultobj;
35534 fail:
35535 return NULL;
35536 }
35537
35538
35539 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35540 PyObject *resultobj;
35541 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35542 wxMenu *arg2 = (wxMenu *) 0 ;
35543 wxString *arg3 = 0 ;
35544 bool result;
35545 bool temp3 = false ;
35546 PyObject * obj0 = 0 ;
35547 PyObject * obj1 = 0 ;
35548 PyObject * obj2 = 0 ;
35549 char *kwnames[] = {
35550 (char *) "self",(char *) "menu",(char *) "title", NULL
35551 };
35552
35553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35555 if (SWIG_arg_fail(1)) SWIG_fail;
35556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35557 if (SWIG_arg_fail(2)) SWIG_fail;
35558 {
35559 arg3 = wxString_in_helper(obj2);
35560 if (arg3 == NULL) SWIG_fail;
35561 temp3 = true;
35562 }
35563 {
35564 PyThreadState* __tstate = wxPyBeginAllowThreads();
35565 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35566
35567 wxPyEndAllowThreads(__tstate);
35568 if (PyErr_Occurred()) SWIG_fail;
35569 }
35570 {
35571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35572 }
35573 {
35574 if (temp3)
35575 delete arg3;
35576 }
35577 return resultobj;
35578 fail:
35579 {
35580 if (temp3)
35581 delete arg3;
35582 }
35583 return NULL;
35584 }
35585
35586
35587 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35588 PyObject *resultobj;
35589 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35590 size_t arg2 ;
35591 wxMenu *arg3 = (wxMenu *) 0 ;
35592 wxString *arg4 = 0 ;
35593 bool result;
35594 bool temp4 = false ;
35595 PyObject * obj0 = 0 ;
35596 PyObject * obj1 = 0 ;
35597 PyObject * obj2 = 0 ;
35598 PyObject * obj3 = 0 ;
35599 char *kwnames[] = {
35600 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35601 };
35602
35603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35605 if (SWIG_arg_fail(1)) SWIG_fail;
35606 {
35607 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35608 if (SWIG_arg_fail(2)) SWIG_fail;
35609 }
35610 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35611 if (SWIG_arg_fail(3)) SWIG_fail;
35612 {
35613 arg4 = wxString_in_helper(obj3);
35614 if (arg4 == NULL) SWIG_fail;
35615 temp4 = true;
35616 }
35617 {
35618 PyThreadState* __tstate = wxPyBeginAllowThreads();
35619 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35620
35621 wxPyEndAllowThreads(__tstate);
35622 if (PyErr_Occurred()) SWIG_fail;
35623 }
35624 {
35625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35626 }
35627 {
35628 if (temp4)
35629 delete arg4;
35630 }
35631 return resultobj;
35632 fail:
35633 {
35634 if (temp4)
35635 delete arg4;
35636 }
35637 return NULL;
35638 }
35639
35640
35641 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35642 PyObject *resultobj;
35643 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35644 size_t result;
35645 PyObject * obj0 = 0 ;
35646 char *kwnames[] = {
35647 (char *) "self", NULL
35648 };
35649
35650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35652 if (SWIG_arg_fail(1)) SWIG_fail;
35653 {
35654 PyThreadState* __tstate = wxPyBeginAllowThreads();
35655 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35656
35657 wxPyEndAllowThreads(__tstate);
35658 if (PyErr_Occurred()) SWIG_fail;
35659 }
35660 {
35661 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35662 }
35663 return resultobj;
35664 fail:
35665 return NULL;
35666 }
35667
35668
35669 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35670 PyObject *resultobj;
35671 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35672 size_t arg2 ;
35673 wxMenu *result;
35674 PyObject * obj0 = 0 ;
35675 PyObject * obj1 = 0 ;
35676 char *kwnames[] = {
35677 (char *) "self",(char *) "pos", NULL
35678 };
35679
35680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35682 if (SWIG_arg_fail(1)) SWIG_fail;
35683 {
35684 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35685 if (SWIG_arg_fail(2)) SWIG_fail;
35686 }
35687 {
35688 PyThreadState* __tstate = wxPyBeginAllowThreads();
35689 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35690
35691 wxPyEndAllowThreads(__tstate);
35692 if (PyErr_Occurred()) SWIG_fail;
35693 }
35694 {
35695 resultobj = wxPyMake_wxObject(result, 0);
35696 }
35697 return resultobj;
35698 fail:
35699 return NULL;
35700 }
35701
35702
35703 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35704 PyObject *resultobj;
35705 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35706 size_t arg2 ;
35707 wxMenu *arg3 = (wxMenu *) 0 ;
35708 wxString *arg4 = 0 ;
35709 wxMenu *result;
35710 bool temp4 = false ;
35711 PyObject * obj0 = 0 ;
35712 PyObject * obj1 = 0 ;
35713 PyObject * obj2 = 0 ;
35714 PyObject * obj3 = 0 ;
35715 char *kwnames[] = {
35716 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35717 };
35718
35719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35721 if (SWIG_arg_fail(1)) SWIG_fail;
35722 {
35723 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35724 if (SWIG_arg_fail(2)) SWIG_fail;
35725 }
35726 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35727 if (SWIG_arg_fail(3)) SWIG_fail;
35728 {
35729 arg4 = wxString_in_helper(obj3);
35730 if (arg4 == NULL) SWIG_fail;
35731 temp4 = true;
35732 }
35733 {
35734 PyThreadState* __tstate = wxPyBeginAllowThreads();
35735 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35736
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 {
35741 resultobj = wxPyMake_wxObject(result, 0);
35742 }
35743 {
35744 if (temp4)
35745 delete arg4;
35746 }
35747 return resultobj;
35748 fail:
35749 {
35750 if (temp4)
35751 delete arg4;
35752 }
35753 return NULL;
35754 }
35755
35756
35757 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35758 PyObject *resultobj;
35759 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35760 size_t arg2 ;
35761 wxMenu *result;
35762 PyObject * obj0 = 0 ;
35763 PyObject * obj1 = 0 ;
35764 char *kwnames[] = {
35765 (char *) "self",(char *) "pos", NULL
35766 };
35767
35768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35770 if (SWIG_arg_fail(1)) SWIG_fail;
35771 {
35772 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35773 if (SWIG_arg_fail(2)) SWIG_fail;
35774 }
35775 {
35776 PyThreadState* __tstate = wxPyBeginAllowThreads();
35777 result = (wxMenu *)(arg1)->Remove(arg2);
35778
35779 wxPyEndAllowThreads(__tstate);
35780 if (PyErr_Occurred()) SWIG_fail;
35781 }
35782 {
35783 resultobj = wxPyMake_wxObject(result, 0);
35784 }
35785 return resultobj;
35786 fail:
35787 return NULL;
35788 }
35789
35790
35791 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35792 PyObject *resultobj;
35793 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35794 size_t arg2 ;
35795 bool arg3 ;
35796 PyObject * obj0 = 0 ;
35797 PyObject * obj1 = 0 ;
35798 PyObject * obj2 = 0 ;
35799 char *kwnames[] = {
35800 (char *) "self",(char *) "pos",(char *) "enable", NULL
35801 };
35802
35803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35805 if (SWIG_arg_fail(1)) SWIG_fail;
35806 {
35807 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35808 if (SWIG_arg_fail(2)) SWIG_fail;
35809 }
35810 {
35811 arg3 = (bool)(SWIG_As_bool(obj2));
35812 if (SWIG_arg_fail(3)) SWIG_fail;
35813 }
35814 {
35815 PyThreadState* __tstate = wxPyBeginAllowThreads();
35816 (arg1)->EnableTop(arg2,arg3);
35817
35818 wxPyEndAllowThreads(__tstate);
35819 if (PyErr_Occurred()) SWIG_fail;
35820 }
35821 Py_INCREF(Py_None); resultobj = Py_None;
35822 return resultobj;
35823 fail:
35824 return NULL;
35825 }
35826
35827
35828 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35829 PyObject *resultobj;
35830 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35831 size_t arg2 ;
35832 bool result;
35833 PyObject * obj0 = 0 ;
35834 PyObject * obj1 = 0 ;
35835 char *kwnames[] = {
35836 (char *) "self",(char *) "pos", NULL
35837 };
35838
35839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35841 if (SWIG_arg_fail(1)) SWIG_fail;
35842 {
35843 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35844 if (SWIG_arg_fail(2)) SWIG_fail;
35845 }
35846 {
35847 PyThreadState* __tstate = wxPyBeginAllowThreads();
35848 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35849
35850 wxPyEndAllowThreads(__tstate);
35851 if (PyErr_Occurred()) SWIG_fail;
35852 }
35853 {
35854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35855 }
35856 return resultobj;
35857 fail:
35858 return NULL;
35859 }
35860
35861
35862 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35863 PyObject *resultobj;
35864 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35865 size_t arg2 ;
35866 wxString *arg3 = 0 ;
35867 bool temp3 = false ;
35868 PyObject * obj0 = 0 ;
35869 PyObject * obj1 = 0 ;
35870 PyObject * obj2 = 0 ;
35871 char *kwnames[] = {
35872 (char *) "self",(char *) "pos",(char *) "label", NULL
35873 };
35874
35875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35877 if (SWIG_arg_fail(1)) SWIG_fail;
35878 {
35879 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35880 if (SWIG_arg_fail(2)) SWIG_fail;
35881 }
35882 {
35883 arg3 = wxString_in_helper(obj2);
35884 if (arg3 == NULL) SWIG_fail;
35885 temp3 = true;
35886 }
35887 {
35888 PyThreadState* __tstate = wxPyBeginAllowThreads();
35889 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35890
35891 wxPyEndAllowThreads(__tstate);
35892 if (PyErr_Occurred()) SWIG_fail;
35893 }
35894 Py_INCREF(Py_None); resultobj = Py_None;
35895 {
35896 if (temp3)
35897 delete arg3;
35898 }
35899 return resultobj;
35900 fail:
35901 {
35902 if (temp3)
35903 delete arg3;
35904 }
35905 return NULL;
35906 }
35907
35908
35909 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35910 PyObject *resultobj;
35911 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35912 size_t arg2 ;
35913 wxString result;
35914 PyObject * obj0 = 0 ;
35915 PyObject * obj1 = 0 ;
35916 char *kwnames[] = {
35917 (char *) "self",(char *) "pos", NULL
35918 };
35919
35920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35922 if (SWIG_arg_fail(1)) SWIG_fail;
35923 {
35924 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35925 if (SWIG_arg_fail(2)) SWIG_fail;
35926 }
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35930
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 {
35935 #if wxUSE_UNICODE
35936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35937 #else
35938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35939 #endif
35940 }
35941 return resultobj;
35942 fail:
35943 return NULL;
35944 }
35945
35946
35947 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35948 PyObject *resultobj;
35949 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35950 wxString *arg2 = 0 ;
35951 wxString *arg3 = 0 ;
35952 int result;
35953 bool temp2 = false ;
35954 bool temp3 = false ;
35955 PyObject * obj0 = 0 ;
35956 PyObject * obj1 = 0 ;
35957 PyObject * obj2 = 0 ;
35958 char *kwnames[] = {
35959 (char *) "self",(char *) "menu",(char *) "item", NULL
35960 };
35961
35962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35964 if (SWIG_arg_fail(1)) SWIG_fail;
35965 {
35966 arg2 = wxString_in_helper(obj1);
35967 if (arg2 == NULL) SWIG_fail;
35968 temp2 = true;
35969 }
35970 {
35971 arg3 = wxString_in_helper(obj2);
35972 if (arg3 == NULL) SWIG_fail;
35973 temp3 = true;
35974 }
35975 {
35976 PyThreadState* __tstate = wxPyBeginAllowThreads();
35977 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35978
35979 wxPyEndAllowThreads(__tstate);
35980 if (PyErr_Occurred()) SWIG_fail;
35981 }
35982 {
35983 resultobj = SWIG_From_int((int)(result));
35984 }
35985 {
35986 if (temp2)
35987 delete arg2;
35988 }
35989 {
35990 if (temp3)
35991 delete arg3;
35992 }
35993 return resultobj;
35994 fail:
35995 {
35996 if (temp2)
35997 delete arg2;
35998 }
35999 {
36000 if (temp3)
36001 delete arg3;
36002 }
36003 return NULL;
36004 }
36005
36006
36007 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36008 PyObject *resultobj;
36009 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36010 int arg2 ;
36011 wxMenuItem *result;
36012 PyObject * obj0 = 0 ;
36013 PyObject * obj1 = 0 ;
36014 char *kwnames[] = {
36015 (char *) "self",(char *) "id", NULL
36016 };
36017
36018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36020 if (SWIG_arg_fail(1)) SWIG_fail;
36021 {
36022 arg2 = (int)(SWIG_As_int(obj1));
36023 if (SWIG_arg_fail(2)) SWIG_fail;
36024 }
36025 {
36026 PyThreadState* __tstate = wxPyBeginAllowThreads();
36027 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36028
36029 wxPyEndAllowThreads(__tstate);
36030 if (PyErr_Occurred()) SWIG_fail;
36031 }
36032 {
36033 resultobj = wxPyMake_wxObject(result, 0);
36034 }
36035 return resultobj;
36036 fail:
36037 return NULL;
36038 }
36039
36040
36041 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36042 PyObject *resultobj;
36043 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36044 wxString *arg2 = 0 ;
36045 int result;
36046 bool temp2 = false ;
36047 PyObject * obj0 = 0 ;
36048 PyObject * obj1 = 0 ;
36049 char *kwnames[] = {
36050 (char *) "self",(char *) "title", NULL
36051 };
36052
36053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36055 if (SWIG_arg_fail(1)) SWIG_fail;
36056 {
36057 arg2 = wxString_in_helper(obj1);
36058 if (arg2 == NULL) SWIG_fail;
36059 temp2 = true;
36060 }
36061 {
36062 PyThreadState* __tstate = wxPyBeginAllowThreads();
36063 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36064
36065 wxPyEndAllowThreads(__tstate);
36066 if (PyErr_Occurred()) SWIG_fail;
36067 }
36068 {
36069 resultobj = SWIG_From_int((int)(result));
36070 }
36071 {
36072 if (temp2)
36073 delete arg2;
36074 }
36075 return resultobj;
36076 fail:
36077 {
36078 if (temp2)
36079 delete arg2;
36080 }
36081 return NULL;
36082 }
36083
36084
36085 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36086 PyObject *resultobj;
36087 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36088 int arg2 ;
36089 bool arg3 ;
36090 PyObject * obj0 = 0 ;
36091 PyObject * obj1 = 0 ;
36092 PyObject * obj2 = 0 ;
36093 char *kwnames[] = {
36094 (char *) "self",(char *) "id",(char *) "enable", NULL
36095 };
36096
36097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36099 if (SWIG_arg_fail(1)) SWIG_fail;
36100 {
36101 arg2 = (int)(SWIG_As_int(obj1));
36102 if (SWIG_arg_fail(2)) SWIG_fail;
36103 }
36104 {
36105 arg3 = (bool)(SWIG_As_bool(obj2));
36106 if (SWIG_arg_fail(3)) SWIG_fail;
36107 }
36108 {
36109 PyThreadState* __tstate = wxPyBeginAllowThreads();
36110 (arg1)->Enable(arg2,arg3);
36111
36112 wxPyEndAllowThreads(__tstate);
36113 if (PyErr_Occurred()) SWIG_fail;
36114 }
36115 Py_INCREF(Py_None); resultobj = Py_None;
36116 return resultobj;
36117 fail:
36118 return NULL;
36119 }
36120
36121
36122 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36123 PyObject *resultobj;
36124 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36125 int arg2 ;
36126 bool arg3 ;
36127 PyObject * obj0 = 0 ;
36128 PyObject * obj1 = 0 ;
36129 PyObject * obj2 = 0 ;
36130 char *kwnames[] = {
36131 (char *) "self",(char *) "id",(char *) "check", NULL
36132 };
36133
36134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36136 if (SWIG_arg_fail(1)) SWIG_fail;
36137 {
36138 arg2 = (int)(SWIG_As_int(obj1));
36139 if (SWIG_arg_fail(2)) SWIG_fail;
36140 }
36141 {
36142 arg3 = (bool)(SWIG_As_bool(obj2));
36143 if (SWIG_arg_fail(3)) SWIG_fail;
36144 }
36145 {
36146 PyThreadState* __tstate = wxPyBeginAllowThreads();
36147 (arg1)->Check(arg2,arg3);
36148
36149 wxPyEndAllowThreads(__tstate);
36150 if (PyErr_Occurred()) SWIG_fail;
36151 }
36152 Py_INCREF(Py_None); resultobj = Py_None;
36153 return resultobj;
36154 fail:
36155 return NULL;
36156 }
36157
36158
36159 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36160 PyObject *resultobj;
36161 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36162 int arg2 ;
36163 bool result;
36164 PyObject * obj0 = 0 ;
36165 PyObject * obj1 = 0 ;
36166 char *kwnames[] = {
36167 (char *) "self",(char *) "id", NULL
36168 };
36169
36170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36172 if (SWIG_arg_fail(1)) SWIG_fail;
36173 {
36174 arg2 = (int)(SWIG_As_int(obj1));
36175 if (SWIG_arg_fail(2)) SWIG_fail;
36176 }
36177 {
36178 PyThreadState* __tstate = wxPyBeginAllowThreads();
36179 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36180
36181 wxPyEndAllowThreads(__tstate);
36182 if (PyErr_Occurred()) SWIG_fail;
36183 }
36184 {
36185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36186 }
36187 return resultobj;
36188 fail:
36189 return NULL;
36190 }
36191
36192
36193 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36194 PyObject *resultobj;
36195 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36196 int arg2 ;
36197 bool result;
36198 PyObject * obj0 = 0 ;
36199 PyObject * obj1 = 0 ;
36200 char *kwnames[] = {
36201 (char *) "self",(char *) "id", NULL
36202 };
36203
36204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36206 if (SWIG_arg_fail(1)) SWIG_fail;
36207 {
36208 arg2 = (int)(SWIG_As_int(obj1));
36209 if (SWIG_arg_fail(2)) SWIG_fail;
36210 }
36211 {
36212 PyThreadState* __tstate = wxPyBeginAllowThreads();
36213 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36214
36215 wxPyEndAllowThreads(__tstate);
36216 if (PyErr_Occurred()) SWIG_fail;
36217 }
36218 {
36219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36220 }
36221 return resultobj;
36222 fail:
36223 return NULL;
36224 }
36225
36226
36227 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36228 PyObject *resultobj;
36229 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36230 int arg2 ;
36231 wxString *arg3 = 0 ;
36232 bool temp3 = false ;
36233 PyObject * obj0 = 0 ;
36234 PyObject * obj1 = 0 ;
36235 PyObject * obj2 = 0 ;
36236 char *kwnames[] = {
36237 (char *) "self",(char *) "id",(char *) "label", NULL
36238 };
36239
36240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36242 if (SWIG_arg_fail(1)) SWIG_fail;
36243 {
36244 arg2 = (int)(SWIG_As_int(obj1));
36245 if (SWIG_arg_fail(2)) SWIG_fail;
36246 }
36247 {
36248 arg3 = wxString_in_helper(obj2);
36249 if (arg3 == NULL) SWIG_fail;
36250 temp3 = true;
36251 }
36252 {
36253 PyThreadState* __tstate = wxPyBeginAllowThreads();
36254 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36255
36256 wxPyEndAllowThreads(__tstate);
36257 if (PyErr_Occurred()) SWIG_fail;
36258 }
36259 Py_INCREF(Py_None); resultobj = Py_None;
36260 {
36261 if (temp3)
36262 delete arg3;
36263 }
36264 return resultobj;
36265 fail:
36266 {
36267 if (temp3)
36268 delete arg3;
36269 }
36270 return NULL;
36271 }
36272
36273
36274 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36275 PyObject *resultobj;
36276 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36277 int arg2 ;
36278 wxString result;
36279 PyObject * obj0 = 0 ;
36280 PyObject * obj1 = 0 ;
36281 char *kwnames[] = {
36282 (char *) "self",(char *) "id", NULL
36283 };
36284
36285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36287 if (SWIG_arg_fail(1)) SWIG_fail;
36288 {
36289 arg2 = (int)(SWIG_As_int(obj1));
36290 if (SWIG_arg_fail(2)) SWIG_fail;
36291 }
36292 {
36293 PyThreadState* __tstate = wxPyBeginAllowThreads();
36294 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36295
36296 wxPyEndAllowThreads(__tstate);
36297 if (PyErr_Occurred()) SWIG_fail;
36298 }
36299 {
36300 #if wxUSE_UNICODE
36301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36302 #else
36303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36304 #endif
36305 }
36306 return resultobj;
36307 fail:
36308 return NULL;
36309 }
36310
36311
36312 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36313 PyObject *resultobj;
36314 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36315 int arg2 ;
36316 wxString *arg3 = 0 ;
36317 bool temp3 = false ;
36318 PyObject * obj0 = 0 ;
36319 PyObject * obj1 = 0 ;
36320 PyObject * obj2 = 0 ;
36321 char *kwnames[] = {
36322 (char *) "self",(char *) "id",(char *) "helpString", NULL
36323 };
36324
36325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36327 if (SWIG_arg_fail(1)) SWIG_fail;
36328 {
36329 arg2 = (int)(SWIG_As_int(obj1));
36330 if (SWIG_arg_fail(2)) SWIG_fail;
36331 }
36332 {
36333 arg3 = wxString_in_helper(obj2);
36334 if (arg3 == NULL) SWIG_fail;
36335 temp3 = true;
36336 }
36337 {
36338 PyThreadState* __tstate = wxPyBeginAllowThreads();
36339 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36340
36341 wxPyEndAllowThreads(__tstate);
36342 if (PyErr_Occurred()) SWIG_fail;
36343 }
36344 Py_INCREF(Py_None); resultobj = Py_None;
36345 {
36346 if (temp3)
36347 delete arg3;
36348 }
36349 return resultobj;
36350 fail:
36351 {
36352 if (temp3)
36353 delete arg3;
36354 }
36355 return NULL;
36356 }
36357
36358
36359 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36360 PyObject *resultobj;
36361 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36362 int arg2 ;
36363 wxString result;
36364 PyObject * obj0 = 0 ;
36365 PyObject * obj1 = 0 ;
36366 char *kwnames[] = {
36367 (char *) "self",(char *) "id", NULL
36368 };
36369
36370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36372 if (SWIG_arg_fail(1)) SWIG_fail;
36373 {
36374 arg2 = (int)(SWIG_As_int(obj1));
36375 if (SWIG_arg_fail(2)) SWIG_fail;
36376 }
36377 {
36378 PyThreadState* __tstate = wxPyBeginAllowThreads();
36379 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36380
36381 wxPyEndAllowThreads(__tstate);
36382 if (PyErr_Occurred()) SWIG_fail;
36383 }
36384 {
36385 #if wxUSE_UNICODE
36386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36387 #else
36388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36389 #endif
36390 }
36391 return resultobj;
36392 fail:
36393 return NULL;
36394 }
36395
36396
36397 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36398 PyObject *resultobj;
36399 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36400 wxFrame *result;
36401 PyObject * obj0 = 0 ;
36402 char *kwnames[] = {
36403 (char *) "self", NULL
36404 };
36405
36406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36408 if (SWIG_arg_fail(1)) SWIG_fail;
36409 {
36410 PyThreadState* __tstate = wxPyBeginAllowThreads();
36411 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36412
36413 wxPyEndAllowThreads(__tstate);
36414 if (PyErr_Occurred()) SWIG_fail;
36415 }
36416 {
36417 resultobj = wxPyMake_wxObject(result, 0);
36418 }
36419 return resultobj;
36420 fail:
36421 return NULL;
36422 }
36423
36424
36425 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36426 PyObject *resultobj;
36427 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36428 bool result;
36429 PyObject * obj0 = 0 ;
36430 char *kwnames[] = {
36431 (char *) "self", NULL
36432 };
36433
36434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36436 if (SWIG_arg_fail(1)) SWIG_fail;
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36440
36441 wxPyEndAllowThreads(__tstate);
36442 if (PyErr_Occurred()) SWIG_fail;
36443 }
36444 {
36445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36446 }
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36454 PyObject *resultobj;
36455 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36456 wxFrame *arg2 = (wxFrame *) 0 ;
36457 PyObject * obj0 = 0 ;
36458 PyObject * obj1 = 0 ;
36459 char *kwnames[] = {
36460 (char *) "self",(char *) "frame", NULL
36461 };
36462
36463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36465 if (SWIG_arg_fail(1)) SWIG_fail;
36466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36467 if (SWIG_arg_fail(2)) SWIG_fail;
36468 {
36469 PyThreadState* __tstate = wxPyBeginAllowThreads();
36470 (arg1)->Attach(arg2);
36471
36472 wxPyEndAllowThreads(__tstate);
36473 if (PyErr_Occurred()) SWIG_fail;
36474 }
36475 Py_INCREF(Py_None); resultobj = Py_None;
36476 return resultobj;
36477 fail:
36478 return NULL;
36479 }
36480
36481
36482 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36483 PyObject *resultobj;
36484 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36485 PyObject * obj0 = 0 ;
36486 char *kwnames[] = {
36487 (char *) "self", NULL
36488 };
36489
36490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36492 if (SWIG_arg_fail(1)) SWIG_fail;
36493 {
36494 PyThreadState* __tstate = wxPyBeginAllowThreads();
36495 (arg1)->Detach();
36496
36497 wxPyEndAllowThreads(__tstate);
36498 if (PyErr_Occurred()) SWIG_fail;
36499 }
36500 Py_INCREF(Py_None); resultobj = Py_None;
36501 return resultobj;
36502 fail:
36503 return NULL;
36504 }
36505
36506
36507 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36508 PyObject *resultobj;
36509 bool arg1 ;
36510 PyObject * obj0 = 0 ;
36511 char *kwnames[] = {
36512 (char *) "enable", NULL
36513 };
36514
36515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36516 {
36517 arg1 = (bool)(SWIG_As_bool(obj0));
36518 if (SWIG_arg_fail(1)) SWIG_fail;
36519 }
36520 {
36521 PyThreadState* __tstate = wxPyBeginAllowThreads();
36522 MenuBar_SetAutoWindowMenu(arg1);
36523
36524 wxPyEndAllowThreads(__tstate);
36525 if (PyErr_Occurred()) SWIG_fail;
36526 }
36527 Py_INCREF(Py_None); resultobj = Py_None;
36528 return resultobj;
36529 fail:
36530 return NULL;
36531 }
36532
36533
36534 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36535 PyObject *resultobj;
36536 bool result;
36537 char *kwnames[] = {
36538 NULL
36539 };
36540
36541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36542 {
36543 PyThreadState* __tstate = wxPyBeginAllowThreads();
36544 result = (bool)MenuBar_GetAutoWindowMenu();
36545
36546 wxPyEndAllowThreads(__tstate);
36547 if (PyErr_Occurred()) SWIG_fail;
36548 }
36549 {
36550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36551 }
36552 return resultobj;
36553 fail:
36554 return NULL;
36555 }
36556
36557
36558 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36559 PyObject *obj;
36560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36561 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36562 Py_INCREF(obj);
36563 return Py_BuildValue((char *)"");
36564 }
36565 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36566 PyObject *resultobj;
36567 wxMenu *arg1 = (wxMenu *) NULL ;
36568 int arg2 = (int) wxID_ANY ;
36569 wxString const &arg3_defvalue = wxPyEmptyString ;
36570 wxString *arg3 = (wxString *) &arg3_defvalue ;
36571 wxString const &arg4_defvalue = wxPyEmptyString ;
36572 wxString *arg4 = (wxString *) &arg4_defvalue ;
36573 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36574 wxMenu *arg6 = (wxMenu *) NULL ;
36575 wxMenuItem *result;
36576 bool temp3 = false ;
36577 bool temp4 = false ;
36578 PyObject * obj0 = 0 ;
36579 PyObject * obj1 = 0 ;
36580 PyObject * obj2 = 0 ;
36581 PyObject * obj3 = 0 ;
36582 PyObject * obj4 = 0 ;
36583 PyObject * obj5 = 0 ;
36584 char *kwnames[] = {
36585 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36586 };
36587
36588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36589 if (obj0) {
36590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36591 if (SWIG_arg_fail(1)) SWIG_fail;
36592 }
36593 if (obj1) {
36594 {
36595 arg2 = (int)(SWIG_As_int(obj1));
36596 if (SWIG_arg_fail(2)) SWIG_fail;
36597 }
36598 }
36599 if (obj2) {
36600 {
36601 arg3 = wxString_in_helper(obj2);
36602 if (arg3 == NULL) SWIG_fail;
36603 temp3 = true;
36604 }
36605 }
36606 if (obj3) {
36607 {
36608 arg4 = wxString_in_helper(obj3);
36609 if (arg4 == NULL) SWIG_fail;
36610 temp4 = true;
36611 }
36612 }
36613 if (obj4) {
36614 {
36615 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36616 if (SWIG_arg_fail(5)) SWIG_fail;
36617 }
36618 }
36619 if (obj5) {
36620 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36621 if (SWIG_arg_fail(6)) SWIG_fail;
36622 }
36623 {
36624 PyThreadState* __tstate = wxPyBeginAllowThreads();
36625 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36626
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 {
36631 resultobj = wxPyMake_wxObject(result, 1);
36632 }
36633 {
36634 if (temp3)
36635 delete arg3;
36636 }
36637 {
36638 if (temp4)
36639 delete arg4;
36640 }
36641 return resultobj;
36642 fail:
36643 {
36644 if (temp3)
36645 delete arg3;
36646 }
36647 {
36648 if (temp4)
36649 delete arg4;
36650 }
36651 return NULL;
36652 }
36653
36654
36655 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36656 PyObject *resultobj;
36657 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36658 wxMenu *result;
36659 PyObject * obj0 = 0 ;
36660 char *kwnames[] = {
36661 (char *) "self", NULL
36662 };
36663
36664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36666 if (SWIG_arg_fail(1)) SWIG_fail;
36667 {
36668 PyThreadState* __tstate = wxPyBeginAllowThreads();
36669 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36670
36671 wxPyEndAllowThreads(__tstate);
36672 if (PyErr_Occurred()) SWIG_fail;
36673 }
36674 {
36675 resultobj = wxPyMake_wxObject(result, 0);
36676 }
36677 return resultobj;
36678 fail:
36679 return NULL;
36680 }
36681
36682
36683 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36684 PyObject *resultobj;
36685 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36686 wxMenu *arg2 = (wxMenu *) 0 ;
36687 PyObject * obj0 = 0 ;
36688 PyObject * obj1 = 0 ;
36689 char *kwnames[] = {
36690 (char *) "self",(char *) "menu", NULL
36691 };
36692
36693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36695 if (SWIG_arg_fail(1)) SWIG_fail;
36696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36697 if (SWIG_arg_fail(2)) SWIG_fail;
36698 {
36699 PyThreadState* __tstate = wxPyBeginAllowThreads();
36700 (arg1)->SetMenu(arg2);
36701
36702 wxPyEndAllowThreads(__tstate);
36703 if (PyErr_Occurred()) SWIG_fail;
36704 }
36705 Py_INCREF(Py_None); resultobj = Py_None;
36706 return resultobj;
36707 fail:
36708 return NULL;
36709 }
36710
36711
36712 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36713 PyObject *resultobj;
36714 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36715 int arg2 ;
36716 PyObject * obj0 = 0 ;
36717 PyObject * obj1 = 0 ;
36718 char *kwnames[] = {
36719 (char *) "self",(char *) "id", NULL
36720 };
36721
36722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36724 if (SWIG_arg_fail(1)) SWIG_fail;
36725 {
36726 arg2 = (int)(SWIG_As_int(obj1));
36727 if (SWIG_arg_fail(2)) SWIG_fail;
36728 }
36729 {
36730 PyThreadState* __tstate = wxPyBeginAllowThreads();
36731 (arg1)->SetId(arg2);
36732
36733 wxPyEndAllowThreads(__tstate);
36734 if (PyErr_Occurred()) SWIG_fail;
36735 }
36736 Py_INCREF(Py_None); resultobj = Py_None;
36737 return resultobj;
36738 fail:
36739 return NULL;
36740 }
36741
36742
36743 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36744 PyObject *resultobj;
36745 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36746 int result;
36747 PyObject * obj0 = 0 ;
36748 char *kwnames[] = {
36749 (char *) "self", NULL
36750 };
36751
36752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36754 if (SWIG_arg_fail(1)) SWIG_fail;
36755 {
36756 PyThreadState* __tstate = wxPyBeginAllowThreads();
36757 result = (int)((wxMenuItem const *)arg1)->GetId();
36758
36759 wxPyEndAllowThreads(__tstate);
36760 if (PyErr_Occurred()) SWIG_fail;
36761 }
36762 {
36763 resultobj = SWIG_From_int((int)(result));
36764 }
36765 return resultobj;
36766 fail:
36767 return NULL;
36768 }
36769
36770
36771 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36772 PyObject *resultobj;
36773 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36774 bool result;
36775 PyObject * obj0 = 0 ;
36776 char *kwnames[] = {
36777 (char *) "self", NULL
36778 };
36779
36780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36782 if (SWIG_arg_fail(1)) SWIG_fail;
36783 {
36784 PyThreadState* __tstate = wxPyBeginAllowThreads();
36785 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36786
36787 wxPyEndAllowThreads(__tstate);
36788 if (PyErr_Occurred()) SWIG_fail;
36789 }
36790 {
36791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36792 }
36793 return resultobj;
36794 fail:
36795 return NULL;
36796 }
36797
36798
36799 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36800 PyObject *resultobj;
36801 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36802 wxString *arg2 = 0 ;
36803 bool temp2 = false ;
36804 PyObject * obj0 = 0 ;
36805 PyObject * obj1 = 0 ;
36806 char *kwnames[] = {
36807 (char *) "self",(char *) "str", NULL
36808 };
36809
36810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36812 if (SWIG_arg_fail(1)) SWIG_fail;
36813 {
36814 arg2 = wxString_in_helper(obj1);
36815 if (arg2 == NULL) SWIG_fail;
36816 temp2 = true;
36817 }
36818 {
36819 PyThreadState* __tstate = wxPyBeginAllowThreads();
36820 (arg1)->SetText((wxString const &)*arg2);
36821
36822 wxPyEndAllowThreads(__tstate);
36823 if (PyErr_Occurred()) SWIG_fail;
36824 }
36825 Py_INCREF(Py_None); resultobj = Py_None;
36826 {
36827 if (temp2)
36828 delete arg2;
36829 }
36830 return resultobj;
36831 fail:
36832 {
36833 if (temp2)
36834 delete arg2;
36835 }
36836 return NULL;
36837 }
36838
36839
36840 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36841 PyObject *resultobj;
36842 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36843 wxString result;
36844 PyObject * obj0 = 0 ;
36845 char *kwnames[] = {
36846 (char *) "self", NULL
36847 };
36848
36849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36851 if (SWIG_arg_fail(1)) SWIG_fail;
36852 {
36853 PyThreadState* __tstate = wxPyBeginAllowThreads();
36854 result = ((wxMenuItem const *)arg1)->GetLabel();
36855
36856 wxPyEndAllowThreads(__tstate);
36857 if (PyErr_Occurred()) SWIG_fail;
36858 }
36859 {
36860 #if wxUSE_UNICODE
36861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36862 #else
36863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36864 #endif
36865 }
36866 return resultobj;
36867 fail:
36868 return NULL;
36869 }
36870
36871
36872 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36873 PyObject *resultobj;
36874 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36875 wxString *result;
36876 PyObject * obj0 = 0 ;
36877 char *kwnames[] = {
36878 (char *) "self", NULL
36879 };
36880
36881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36883 if (SWIG_arg_fail(1)) SWIG_fail;
36884 {
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 {
36887 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36888 result = (wxString *) &_result_ref;
36889 }
36890
36891 wxPyEndAllowThreads(__tstate);
36892 if (PyErr_Occurred()) SWIG_fail;
36893 }
36894 {
36895 #if wxUSE_UNICODE
36896 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36897 #else
36898 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36899 #endif
36900 }
36901 return resultobj;
36902 fail:
36903 return NULL;
36904 }
36905
36906
36907 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36908 PyObject *resultobj;
36909 wxString *arg1 = 0 ;
36910 wxString result;
36911 bool temp1 = false ;
36912 PyObject * obj0 = 0 ;
36913 char *kwnames[] = {
36914 (char *) "text", NULL
36915 };
36916
36917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36918 {
36919 arg1 = wxString_in_helper(obj0);
36920 if (arg1 == NULL) SWIG_fail;
36921 temp1 = true;
36922 }
36923 {
36924 PyThreadState* __tstate = wxPyBeginAllowThreads();
36925 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36926
36927 wxPyEndAllowThreads(__tstate);
36928 if (PyErr_Occurred()) SWIG_fail;
36929 }
36930 {
36931 #if wxUSE_UNICODE
36932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36933 #else
36934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36935 #endif
36936 }
36937 {
36938 if (temp1)
36939 delete arg1;
36940 }
36941 return resultobj;
36942 fail:
36943 {
36944 if (temp1)
36945 delete arg1;
36946 }
36947 return NULL;
36948 }
36949
36950
36951 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36952 PyObject *resultobj;
36953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36954 wxItemKind result;
36955 PyObject * obj0 = 0 ;
36956 char *kwnames[] = {
36957 (char *) "self", NULL
36958 };
36959
36960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36962 if (SWIG_arg_fail(1)) SWIG_fail;
36963 {
36964 PyThreadState* __tstate = wxPyBeginAllowThreads();
36965 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36966
36967 wxPyEndAllowThreads(__tstate);
36968 if (PyErr_Occurred()) SWIG_fail;
36969 }
36970 resultobj = SWIG_From_int((result));
36971 return resultobj;
36972 fail:
36973 return NULL;
36974 }
36975
36976
36977 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36978 PyObject *resultobj;
36979 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36980 wxItemKind arg2 ;
36981 PyObject * obj0 = 0 ;
36982 PyObject * obj1 = 0 ;
36983 char *kwnames[] = {
36984 (char *) "self",(char *) "kind", NULL
36985 };
36986
36987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36989 if (SWIG_arg_fail(1)) SWIG_fail;
36990 {
36991 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36992 if (SWIG_arg_fail(2)) SWIG_fail;
36993 }
36994 {
36995 PyThreadState* __tstate = wxPyBeginAllowThreads();
36996 (arg1)->SetKind((wxItemKind )arg2);
36997
36998 wxPyEndAllowThreads(__tstate);
36999 if (PyErr_Occurred()) SWIG_fail;
37000 }
37001 Py_INCREF(Py_None); resultobj = Py_None;
37002 return resultobj;
37003 fail:
37004 return NULL;
37005 }
37006
37007
37008 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37009 PyObject *resultobj;
37010 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37011 bool arg2 ;
37012 PyObject * obj0 = 0 ;
37013 PyObject * obj1 = 0 ;
37014 char *kwnames[] = {
37015 (char *) "self",(char *) "checkable", NULL
37016 };
37017
37018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37020 if (SWIG_arg_fail(1)) SWIG_fail;
37021 {
37022 arg2 = (bool)(SWIG_As_bool(obj1));
37023 if (SWIG_arg_fail(2)) SWIG_fail;
37024 }
37025 {
37026 PyThreadState* __tstate = wxPyBeginAllowThreads();
37027 (arg1)->SetCheckable(arg2);
37028
37029 wxPyEndAllowThreads(__tstate);
37030 if (PyErr_Occurred()) SWIG_fail;
37031 }
37032 Py_INCREF(Py_None); resultobj = Py_None;
37033 return resultobj;
37034 fail:
37035 return NULL;
37036 }
37037
37038
37039 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37040 PyObject *resultobj;
37041 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37042 bool result;
37043 PyObject * obj0 = 0 ;
37044 char *kwnames[] = {
37045 (char *) "self", NULL
37046 };
37047
37048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37050 if (SWIG_arg_fail(1)) SWIG_fail;
37051 {
37052 PyThreadState* __tstate = wxPyBeginAllowThreads();
37053 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37054
37055 wxPyEndAllowThreads(__tstate);
37056 if (PyErr_Occurred()) SWIG_fail;
37057 }
37058 {
37059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37060 }
37061 return resultobj;
37062 fail:
37063 return NULL;
37064 }
37065
37066
37067 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37068 PyObject *resultobj;
37069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37070 bool result;
37071 PyObject * obj0 = 0 ;
37072 char *kwnames[] = {
37073 (char *) "self", NULL
37074 };
37075
37076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37078 if (SWIG_arg_fail(1)) SWIG_fail;
37079 {
37080 PyThreadState* __tstate = wxPyBeginAllowThreads();
37081 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37082
37083 wxPyEndAllowThreads(__tstate);
37084 if (PyErr_Occurred()) SWIG_fail;
37085 }
37086 {
37087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37088 }
37089 return resultobj;
37090 fail:
37091 return NULL;
37092 }
37093
37094
37095 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37096 PyObject *resultobj;
37097 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37098 wxMenu *arg2 = (wxMenu *) 0 ;
37099 PyObject * obj0 = 0 ;
37100 PyObject * obj1 = 0 ;
37101 char *kwnames[] = {
37102 (char *) "self",(char *) "menu", NULL
37103 };
37104
37105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37107 if (SWIG_arg_fail(1)) SWIG_fail;
37108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37109 if (SWIG_arg_fail(2)) SWIG_fail;
37110 {
37111 PyThreadState* __tstate = wxPyBeginAllowThreads();
37112 (arg1)->SetSubMenu(arg2);
37113
37114 wxPyEndAllowThreads(__tstate);
37115 if (PyErr_Occurred()) SWIG_fail;
37116 }
37117 Py_INCREF(Py_None); resultobj = Py_None;
37118 return resultobj;
37119 fail:
37120 return NULL;
37121 }
37122
37123
37124 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37125 PyObject *resultobj;
37126 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37127 wxMenu *result;
37128 PyObject * obj0 = 0 ;
37129 char *kwnames[] = {
37130 (char *) "self", NULL
37131 };
37132
37133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37135 if (SWIG_arg_fail(1)) SWIG_fail;
37136 {
37137 PyThreadState* __tstate = wxPyBeginAllowThreads();
37138 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37139
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 {
37144 resultobj = wxPyMake_wxObject(result, 0);
37145 }
37146 return resultobj;
37147 fail:
37148 return NULL;
37149 }
37150
37151
37152 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37153 PyObject *resultobj;
37154 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37155 bool arg2 = (bool) true ;
37156 PyObject * obj0 = 0 ;
37157 PyObject * obj1 = 0 ;
37158 char *kwnames[] = {
37159 (char *) "self",(char *) "enable", NULL
37160 };
37161
37162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37164 if (SWIG_arg_fail(1)) SWIG_fail;
37165 if (obj1) {
37166 {
37167 arg2 = (bool)(SWIG_As_bool(obj1));
37168 if (SWIG_arg_fail(2)) SWIG_fail;
37169 }
37170 }
37171 {
37172 PyThreadState* __tstate = wxPyBeginAllowThreads();
37173 (arg1)->Enable(arg2);
37174
37175 wxPyEndAllowThreads(__tstate);
37176 if (PyErr_Occurred()) SWIG_fail;
37177 }
37178 Py_INCREF(Py_None); resultobj = Py_None;
37179 return resultobj;
37180 fail:
37181 return NULL;
37182 }
37183
37184
37185 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37186 PyObject *resultobj;
37187 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37188 bool result;
37189 PyObject * obj0 = 0 ;
37190 char *kwnames[] = {
37191 (char *) "self", NULL
37192 };
37193
37194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37196 if (SWIG_arg_fail(1)) SWIG_fail;
37197 {
37198 PyThreadState* __tstate = wxPyBeginAllowThreads();
37199 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37200
37201 wxPyEndAllowThreads(__tstate);
37202 if (PyErr_Occurred()) SWIG_fail;
37203 }
37204 {
37205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37206 }
37207 return resultobj;
37208 fail:
37209 return NULL;
37210 }
37211
37212
37213 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37214 PyObject *resultobj;
37215 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37216 bool arg2 = (bool) true ;
37217 PyObject * obj0 = 0 ;
37218 PyObject * obj1 = 0 ;
37219 char *kwnames[] = {
37220 (char *) "self",(char *) "check", NULL
37221 };
37222
37223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37225 if (SWIG_arg_fail(1)) SWIG_fail;
37226 if (obj1) {
37227 {
37228 arg2 = (bool)(SWIG_As_bool(obj1));
37229 if (SWIG_arg_fail(2)) SWIG_fail;
37230 }
37231 }
37232 {
37233 PyThreadState* __tstate = wxPyBeginAllowThreads();
37234 (arg1)->Check(arg2);
37235
37236 wxPyEndAllowThreads(__tstate);
37237 if (PyErr_Occurred()) SWIG_fail;
37238 }
37239 Py_INCREF(Py_None); resultobj = Py_None;
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj;
37248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37249 bool result;
37250 PyObject * obj0 = 0 ;
37251 char *kwnames[] = {
37252 (char *) "self", NULL
37253 };
37254
37255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37257 if (SWIG_arg_fail(1)) SWIG_fail;
37258 {
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37261
37262 wxPyEndAllowThreads(__tstate);
37263 if (PyErr_Occurred()) SWIG_fail;
37264 }
37265 {
37266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37267 }
37268 return resultobj;
37269 fail:
37270 return NULL;
37271 }
37272
37273
37274 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37275 PyObject *resultobj;
37276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37277 PyObject * obj0 = 0 ;
37278 char *kwnames[] = {
37279 (char *) "self", NULL
37280 };
37281
37282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37284 if (SWIG_arg_fail(1)) SWIG_fail;
37285 {
37286 PyThreadState* __tstate = wxPyBeginAllowThreads();
37287 (arg1)->Toggle();
37288
37289 wxPyEndAllowThreads(__tstate);
37290 if (PyErr_Occurred()) SWIG_fail;
37291 }
37292 Py_INCREF(Py_None); resultobj = Py_None;
37293 return resultobj;
37294 fail:
37295 return NULL;
37296 }
37297
37298
37299 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37300 PyObject *resultobj;
37301 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37302 wxString *arg2 = 0 ;
37303 bool temp2 = false ;
37304 PyObject * obj0 = 0 ;
37305 PyObject * obj1 = 0 ;
37306 char *kwnames[] = {
37307 (char *) "self",(char *) "str", NULL
37308 };
37309
37310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37312 if (SWIG_arg_fail(1)) SWIG_fail;
37313 {
37314 arg2 = wxString_in_helper(obj1);
37315 if (arg2 == NULL) SWIG_fail;
37316 temp2 = true;
37317 }
37318 {
37319 PyThreadState* __tstate = wxPyBeginAllowThreads();
37320 (arg1)->SetHelp((wxString const &)*arg2);
37321
37322 wxPyEndAllowThreads(__tstate);
37323 if (PyErr_Occurred()) SWIG_fail;
37324 }
37325 Py_INCREF(Py_None); resultobj = Py_None;
37326 {
37327 if (temp2)
37328 delete arg2;
37329 }
37330 return resultobj;
37331 fail:
37332 {
37333 if (temp2)
37334 delete arg2;
37335 }
37336 return NULL;
37337 }
37338
37339
37340 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37341 PyObject *resultobj;
37342 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37343 wxString *result;
37344 PyObject * obj0 = 0 ;
37345 char *kwnames[] = {
37346 (char *) "self", NULL
37347 };
37348
37349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37351 if (SWIG_arg_fail(1)) SWIG_fail;
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 {
37355 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37356 result = (wxString *) &_result_ref;
37357 }
37358
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 {
37363 #if wxUSE_UNICODE
37364 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37365 #else
37366 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37367 #endif
37368 }
37369 return resultobj;
37370 fail:
37371 return NULL;
37372 }
37373
37374
37375 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37376 PyObject *resultobj;
37377 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37378 wxAcceleratorEntry *result;
37379 PyObject * obj0 = 0 ;
37380 char *kwnames[] = {
37381 (char *) "self", NULL
37382 };
37383
37384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37386 if (SWIG_arg_fail(1)) SWIG_fail;
37387 {
37388 PyThreadState* __tstate = wxPyBeginAllowThreads();
37389 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37390
37391 wxPyEndAllowThreads(__tstate);
37392 if (PyErr_Occurred()) SWIG_fail;
37393 }
37394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37395 return resultobj;
37396 fail:
37397 return NULL;
37398 }
37399
37400
37401 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37402 PyObject *resultobj;
37403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37404 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37405 PyObject * obj0 = 0 ;
37406 PyObject * obj1 = 0 ;
37407 char *kwnames[] = {
37408 (char *) "self",(char *) "accel", NULL
37409 };
37410
37411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37413 if (SWIG_arg_fail(1)) SWIG_fail;
37414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37415 if (SWIG_arg_fail(2)) SWIG_fail;
37416 {
37417 PyThreadState* __tstate = wxPyBeginAllowThreads();
37418 (arg1)->SetAccel(arg2);
37419
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 Py_INCREF(Py_None); resultobj = Py_None;
37424 return resultobj;
37425 fail:
37426 return NULL;
37427 }
37428
37429
37430 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37431 PyObject *resultobj;
37432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37433 wxFont *arg2 = 0 ;
37434 PyObject * obj0 = 0 ;
37435 PyObject * obj1 = 0 ;
37436 char *kwnames[] = {
37437 (char *) "self",(char *) "font", NULL
37438 };
37439
37440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37442 if (SWIG_arg_fail(1)) SWIG_fail;
37443 {
37444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37445 if (SWIG_arg_fail(2)) SWIG_fail;
37446 if (arg2 == NULL) {
37447 SWIG_null_ref("wxFont");
37448 }
37449 if (SWIG_arg_fail(2)) SWIG_fail;
37450 }
37451 {
37452 PyThreadState* __tstate = wxPyBeginAllowThreads();
37453 (arg1)->SetFont((wxFont const &)*arg2);
37454
37455 wxPyEndAllowThreads(__tstate);
37456 if (PyErr_Occurred()) SWIG_fail;
37457 }
37458 Py_INCREF(Py_None); resultobj = Py_None;
37459 return resultobj;
37460 fail:
37461 return NULL;
37462 }
37463
37464
37465 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37466 PyObject *resultobj;
37467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37468 wxFont result;
37469 PyObject * obj0 = 0 ;
37470 char *kwnames[] = {
37471 (char *) "self", NULL
37472 };
37473
37474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37476 if (SWIG_arg_fail(1)) SWIG_fail;
37477 {
37478 PyThreadState* __tstate = wxPyBeginAllowThreads();
37479 result = (arg1)->GetFont();
37480
37481 wxPyEndAllowThreads(__tstate);
37482 if (PyErr_Occurred()) SWIG_fail;
37483 }
37484 {
37485 wxFont * resultptr;
37486 resultptr = new wxFont((wxFont &)(result));
37487 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37488 }
37489 return resultobj;
37490 fail:
37491 return NULL;
37492 }
37493
37494
37495 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37496 PyObject *resultobj;
37497 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37498 wxColour *arg2 = 0 ;
37499 wxColour temp2 ;
37500 PyObject * obj0 = 0 ;
37501 PyObject * obj1 = 0 ;
37502 char *kwnames[] = {
37503 (char *) "self",(char *) "colText", NULL
37504 };
37505
37506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37508 if (SWIG_arg_fail(1)) SWIG_fail;
37509 {
37510 arg2 = &temp2;
37511 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37512 }
37513 {
37514 PyThreadState* __tstate = wxPyBeginAllowThreads();
37515 (arg1)->SetTextColour((wxColour const &)*arg2);
37516
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 Py_INCREF(Py_None); resultobj = Py_None;
37521 return resultobj;
37522 fail:
37523 return NULL;
37524 }
37525
37526
37527 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37528 PyObject *resultobj;
37529 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37530 wxColour result;
37531 PyObject * obj0 = 0 ;
37532 char *kwnames[] = {
37533 (char *) "self", NULL
37534 };
37535
37536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37538 if (SWIG_arg_fail(1)) SWIG_fail;
37539 {
37540 PyThreadState* __tstate = wxPyBeginAllowThreads();
37541 result = (arg1)->GetTextColour();
37542
37543 wxPyEndAllowThreads(__tstate);
37544 if (PyErr_Occurred()) SWIG_fail;
37545 }
37546 {
37547 wxColour * resultptr;
37548 resultptr = new wxColour((wxColour &)(result));
37549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37550 }
37551 return resultobj;
37552 fail:
37553 return NULL;
37554 }
37555
37556
37557 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37558 PyObject *resultobj;
37559 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37560 wxColour *arg2 = 0 ;
37561 wxColour temp2 ;
37562 PyObject * obj0 = 0 ;
37563 PyObject * obj1 = 0 ;
37564 char *kwnames[] = {
37565 (char *) "self",(char *) "colBack", NULL
37566 };
37567
37568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37570 if (SWIG_arg_fail(1)) SWIG_fail;
37571 {
37572 arg2 = &temp2;
37573 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37574 }
37575 {
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
37578
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 Py_INCREF(Py_None); resultobj = Py_None;
37583 return resultobj;
37584 fail:
37585 return NULL;
37586 }
37587
37588
37589 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37590 PyObject *resultobj;
37591 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37592 wxColour result;
37593 PyObject * obj0 = 0 ;
37594 char *kwnames[] = {
37595 (char *) "self", NULL
37596 };
37597
37598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37600 if (SWIG_arg_fail(1)) SWIG_fail;
37601 {
37602 PyThreadState* __tstate = wxPyBeginAllowThreads();
37603 result = (arg1)->GetBackgroundColour();
37604
37605 wxPyEndAllowThreads(__tstate);
37606 if (PyErr_Occurred()) SWIG_fail;
37607 }
37608 {
37609 wxColour * resultptr;
37610 resultptr = new wxColour((wxColour &)(result));
37611 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37612 }
37613 return resultobj;
37614 fail:
37615 return NULL;
37616 }
37617
37618
37619 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37620 PyObject *resultobj;
37621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37622 wxBitmap *arg2 = 0 ;
37623 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37624 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37625 PyObject * obj0 = 0 ;
37626 PyObject * obj1 = 0 ;
37627 PyObject * obj2 = 0 ;
37628 char *kwnames[] = {
37629 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37630 };
37631
37632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37634 if (SWIG_arg_fail(1)) SWIG_fail;
37635 {
37636 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37637 if (SWIG_arg_fail(2)) SWIG_fail;
37638 if (arg2 == NULL) {
37639 SWIG_null_ref("wxBitmap");
37640 }
37641 if (SWIG_arg_fail(2)) SWIG_fail;
37642 }
37643 if (obj2) {
37644 {
37645 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37646 if (SWIG_arg_fail(3)) SWIG_fail;
37647 if (arg3 == NULL) {
37648 SWIG_null_ref("wxBitmap");
37649 }
37650 if (SWIG_arg_fail(3)) SWIG_fail;
37651 }
37652 }
37653 {
37654 PyThreadState* __tstate = wxPyBeginAllowThreads();
37655 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37656
37657 wxPyEndAllowThreads(__tstate);
37658 if (PyErr_Occurred()) SWIG_fail;
37659 }
37660 Py_INCREF(Py_None); resultobj = Py_None;
37661 return resultobj;
37662 fail:
37663 return NULL;
37664 }
37665
37666
37667 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37668 PyObject *resultobj;
37669 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37670 wxBitmap *arg2 = 0 ;
37671 PyObject * obj0 = 0 ;
37672 PyObject * obj1 = 0 ;
37673 char *kwnames[] = {
37674 (char *) "self",(char *) "bmpDisabled", NULL
37675 };
37676
37677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37679 if (SWIG_arg_fail(1)) SWIG_fail;
37680 {
37681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37682 if (SWIG_arg_fail(2)) SWIG_fail;
37683 if (arg2 == NULL) {
37684 SWIG_null_ref("wxBitmap");
37685 }
37686 if (SWIG_arg_fail(2)) SWIG_fail;
37687 }
37688 {
37689 PyThreadState* __tstate = wxPyBeginAllowThreads();
37690 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
37691
37692 wxPyEndAllowThreads(__tstate);
37693 if (PyErr_Occurred()) SWIG_fail;
37694 }
37695 Py_INCREF(Py_None); resultobj = Py_None;
37696 return resultobj;
37697 fail:
37698 return NULL;
37699 }
37700
37701
37702 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37703 PyObject *resultobj;
37704 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37705 wxBitmap *result;
37706 PyObject * obj0 = 0 ;
37707 char *kwnames[] = {
37708 (char *) "self", NULL
37709 };
37710
37711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37713 if (SWIG_arg_fail(1)) SWIG_fail;
37714 {
37715 PyThreadState* __tstate = wxPyBeginAllowThreads();
37716 {
37717 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
37718 result = (wxBitmap *) &_result_ref;
37719 }
37720
37721 wxPyEndAllowThreads(__tstate);
37722 if (PyErr_Occurred()) SWIG_fail;
37723 }
37724 {
37725 wxBitmap* resultptr = new wxBitmap(*result);
37726 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37727 }
37728 return resultobj;
37729 fail:
37730 return NULL;
37731 }
37732
37733
37734 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37735 PyObject *resultobj;
37736 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37737 int arg2 ;
37738 PyObject * obj0 = 0 ;
37739 PyObject * obj1 = 0 ;
37740 char *kwnames[] = {
37741 (char *) "self",(char *) "nWidth", NULL
37742 };
37743
37744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37746 if (SWIG_arg_fail(1)) SWIG_fail;
37747 {
37748 arg2 = (int)(SWIG_As_int(obj1));
37749 if (SWIG_arg_fail(2)) SWIG_fail;
37750 }
37751 {
37752 PyThreadState* __tstate = wxPyBeginAllowThreads();
37753 (arg1)->SetMarginWidth(arg2);
37754
37755 wxPyEndAllowThreads(__tstate);
37756 if (PyErr_Occurred()) SWIG_fail;
37757 }
37758 Py_INCREF(Py_None); resultobj = Py_None;
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37766 PyObject *resultobj;
37767 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37768 int result;
37769 PyObject * obj0 = 0 ;
37770 char *kwnames[] = {
37771 (char *) "self", NULL
37772 };
37773
37774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37776 if (SWIG_arg_fail(1)) SWIG_fail;
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (int)(arg1)->GetMarginWidth();
37780
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 {
37785 resultobj = SWIG_From_int((int)(result));
37786 }
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37794 PyObject *resultobj;
37795 int result;
37796 char *kwnames[] = {
37797 NULL
37798 };
37799
37800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37801 {
37802 PyThreadState* __tstate = wxPyBeginAllowThreads();
37803 result = (int)wxMenuItem::GetDefaultMarginWidth();
37804
37805 wxPyEndAllowThreads(__tstate);
37806 if (PyErr_Occurred()) SWIG_fail;
37807 }
37808 {
37809 resultobj = SWIG_From_int((int)(result));
37810 }
37811 return resultobj;
37812 fail:
37813 return NULL;
37814 }
37815
37816
37817 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37818 PyObject *resultobj;
37819 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37820 bool result;
37821 PyObject * obj0 = 0 ;
37822 char *kwnames[] = {
37823 (char *) "self", NULL
37824 };
37825
37826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37828 if (SWIG_arg_fail(1)) SWIG_fail;
37829 {
37830 PyThreadState* __tstate = wxPyBeginAllowThreads();
37831 result = (bool)(arg1)->IsOwnerDrawn();
37832
37833 wxPyEndAllowThreads(__tstate);
37834 if (PyErr_Occurred()) SWIG_fail;
37835 }
37836 {
37837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37838 }
37839 return resultobj;
37840 fail:
37841 return NULL;
37842 }
37843
37844
37845 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37846 PyObject *resultobj;
37847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37848 bool arg2 = (bool) true ;
37849 PyObject * obj0 = 0 ;
37850 PyObject * obj1 = 0 ;
37851 char *kwnames[] = {
37852 (char *) "self",(char *) "ownerDrawn", NULL
37853 };
37854
37855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37857 if (SWIG_arg_fail(1)) SWIG_fail;
37858 if (obj1) {
37859 {
37860 arg2 = (bool)(SWIG_As_bool(obj1));
37861 if (SWIG_arg_fail(2)) SWIG_fail;
37862 }
37863 }
37864 {
37865 PyThreadState* __tstate = wxPyBeginAllowThreads();
37866 (arg1)->SetOwnerDrawn(arg2);
37867
37868 wxPyEndAllowThreads(__tstate);
37869 if (PyErr_Occurred()) SWIG_fail;
37870 }
37871 Py_INCREF(Py_None); resultobj = Py_None;
37872 return resultobj;
37873 fail:
37874 return NULL;
37875 }
37876
37877
37878 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37879 PyObject *resultobj;
37880 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37881 PyObject * obj0 = 0 ;
37882 char *kwnames[] = {
37883 (char *) "self", NULL
37884 };
37885
37886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37888 if (SWIG_arg_fail(1)) SWIG_fail;
37889 {
37890 PyThreadState* __tstate = wxPyBeginAllowThreads();
37891 (arg1)->ResetOwnerDrawn();
37892
37893 wxPyEndAllowThreads(__tstate);
37894 if (PyErr_Occurred()) SWIG_fail;
37895 }
37896 Py_INCREF(Py_None); resultobj = Py_None;
37897 return resultobj;
37898 fail:
37899 return NULL;
37900 }
37901
37902
37903 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37904 PyObject *resultobj;
37905 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37906 wxBitmap *arg2 = 0 ;
37907 PyObject * obj0 = 0 ;
37908 PyObject * obj1 = 0 ;
37909 char *kwnames[] = {
37910 (char *) "self",(char *) "bitmap", NULL
37911 };
37912
37913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37915 if (SWIG_arg_fail(1)) SWIG_fail;
37916 {
37917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37918 if (SWIG_arg_fail(2)) SWIG_fail;
37919 if (arg2 == NULL) {
37920 SWIG_null_ref("wxBitmap");
37921 }
37922 if (SWIG_arg_fail(2)) SWIG_fail;
37923 }
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37927
37928 wxPyEndAllowThreads(__tstate);
37929 if (PyErr_Occurred()) SWIG_fail;
37930 }
37931 Py_INCREF(Py_None); resultobj = Py_None;
37932 return resultobj;
37933 fail:
37934 return NULL;
37935 }
37936
37937
37938 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37939 PyObject *resultobj;
37940 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37941 wxBitmap *result;
37942 PyObject * obj0 = 0 ;
37943 char *kwnames[] = {
37944 (char *) "self", NULL
37945 };
37946
37947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37949 if (SWIG_arg_fail(1)) SWIG_fail;
37950 {
37951 PyThreadState* __tstate = wxPyBeginAllowThreads();
37952 {
37953 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37954 result = (wxBitmap *) &_result_ref;
37955 }
37956
37957 wxPyEndAllowThreads(__tstate);
37958 if (PyErr_Occurred()) SWIG_fail;
37959 }
37960 {
37961 wxBitmap* resultptr = new wxBitmap(*result);
37962 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37963 }
37964 return resultobj;
37965 fail:
37966 return NULL;
37967 }
37968
37969
37970 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37971 PyObject *obj;
37972 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37973 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37974 Py_INCREF(obj);
37975 return Py_BuildValue((char *)"");
37976 }
37977 static int _wrap_ControlNameStr_set(PyObject *) {
37978 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37979 return 1;
37980 }
37981
37982
37983 static PyObject *_wrap_ControlNameStr_get(void) {
37984 PyObject *pyobj;
37985
37986 {
37987 #if wxUSE_UNICODE
37988 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37989 #else
37990 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37991 #endif
37992 }
37993 return pyobj;
37994 }
37995
37996
37997 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37998 PyObject *resultobj;
37999 wxWindow *arg1 = (wxWindow *) 0 ;
38000 int arg2 = (int) -1 ;
38001 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38002 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38003 wxSize const &arg4_defvalue = wxDefaultSize ;
38004 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38005 long arg5 = (long) 0 ;
38006 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38007 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38008 wxString const &arg7_defvalue = wxPyControlNameStr ;
38009 wxString *arg7 = (wxString *) &arg7_defvalue ;
38010 wxControl *result;
38011 wxPoint temp3 ;
38012 wxSize temp4 ;
38013 bool temp7 = false ;
38014 PyObject * obj0 = 0 ;
38015 PyObject * obj1 = 0 ;
38016 PyObject * obj2 = 0 ;
38017 PyObject * obj3 = 0 ;
38018 PyObject * obj4 = 0 ;
38019 PyObject * obj5 = 0 ;
38020 PyObject * obj6 = 0 ;
38021 char *kwnames[] = {
38022 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38023 };
38024
38025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38027 if (SWIG_arg_fail(1)) SWIG_fail;
38028 if (obj1) {
38029 {
38030 arg2 = (int)(SWIG_As_int(obj1));
38031 if (SWIG_arg_fail(2)) SWIG_fail;
38032 }
38033 }
38034 if (obj2) {
38035 {
38036 arg3 = &temp3;
38037 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38038 }
38039 }
38040 if (obj3) {
38041 {
38042 arg4 = &temp4;
38043 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38044 }
38045 }
38046 if (obj4) {
38047 {
38048 arg5 = (long)(SWIG_As_long(obj4));
38049 if (SWIG_arg_fail(5)) SWIG_fail;
38050 }
38051 }
38052 if (obj5) {
38053 {
38054 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38055 if (SWIG_arg_fail(6)) SWIG_fail;
38056 if (arg6 == NULL) {
38057 SWIG_null_ref("wxValidator");
38058 }
38059 if (SWIG_arg_fail(6)) SWIG_fail;
38060 }
38061 }
38062 if (obj6) {
38063 {
38064 arg7 = wxString_in_helper(obj6);
38065 if (arg7 == NULL) SWIG_fail;
38066 temp7 = true;
38067 }
38068 }
38069 {
38070 if (!wxPyCheckForApp()) SWIG_fail;
38071 PyThreadState* __tstate = wxPyBeginAllowThreads();
38072 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38073
38074 wxPyEndAllowThreads(__tstate);
38075 if (PyErr_Occurred()) SWIG_fail;
38076 }
38077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38078 {
38079 if (temp7)
38080 delete arg7;
38081 }
38082 return resultobj;
38083 fail:
38084 {
38085 if (temp7)
38086 delete arg7;
38087 }
38088 return NULL;
38089 }
38090
38091
38092 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38093 PyObject *resultobj;
38094 wxControl *result;
38095 char *kwnames[] = {
38096 NULL
38097 };
38098
38099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38100 {
38101 if (!wxPyCheckForApp()) SWIG_fail;
38102 PyThreadState* __tstate = wxPyBeginAllowThreads();
38103 result = (wxControl *)new wxControl();
38104
38105 wxPyEndAllowThreads(__tstate);
38106 if (PyErr_Occurred()) SWIG_fail;
38107 }
38108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38109 return resultobj;
38110 fail:
38111 return NULL;
38112 }
38113
38114
38115 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38116 PyObject *resultobj;
38117 wxControl *arg1 = (wxControl *) 0 ;
38118 wxWindow *arg2 = (wxWindow *) 0 ;
38119 int arg3 = (int) -1 ;
38120 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38121 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38122 wxSize const &arg5_defvalue = wxDefaultSize ;
38123 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38124 long arg6 = (long) 0 ;
38125 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38126 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38127 wxString const &arg8_defvalue = wxPyControlNameStr ;
38128 wxString *arg8 = (wxString *) &arg8_defvalue ;
38129 bool result;
38130 wxPoint temp4 ;
38131 wxSize temp5 ;
38132 bool temp8 = false ;
38133 PyObject * obj0 = 0 ;
38134 PyObject * obj1 = 0 ;
38135 PyObject * obj2 = 0 ;
38136 PyObject * obj3 = 0 ;
38137 PyObject * obj4 = 0 ;
38138 PyObject * obj5 = 0 ;
38139 PyObject * obj6 = 0 ;
38140 PyObject * obj7 = 0 ;
38141 char *kwnames[] = {
38142 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38143 };
38144
38145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38147 if (SWIG_arg_fail(1)) SWIG_fail;
38148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38149 if (SWIG_arg_fail(2)) SWIG_fail;
38150 if (obj2) {
38151 {
38152 arg3 = (int)(SWIG_As_int(obj2));
38153 if (SWIG_arg_fail(3)) SWIG_fail;
38154 }
38155 }
38156 if (obj3) {
38157 {
38158 arg4 = &temp4;
38159 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38160 }
38161 }
38162 if (obj4) {
38163 {
38164 arg5 = &temp5;
38165 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38166 }
38167 }
38168 if (obj5) {
38169 {
38170 arg6 = (long)(SWIG_As_long(obj5));
38171 if (SWIG_arg_fail(6)) SWIG_fail;
38172 }
38173 }
38174 if (obj6) {
38175 {
38176 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38177 if (SWIG_arg_fail(7)) SWIG_fail;
38178 if (arg7 == NULL) {
38179 SWIG_null_ref("wxValidator");
38180 }
38181 if (SWIG_arg_fail(7)) SWIG_fail;
38182 }
38183 }
38184 if (obj7) {
38185 {
38186 arg8 = wxString_in_helper(obj7);
38187 if (arg8 == NULL) SWIG_fail;
38188 temp8 = true;
38189 }
38190 }
38191 {
38192 PyThreadState* __tstate = wxPyBeginAllowThreads();
38193 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38194
38195 wxPyEndAllowThreads(__tstate);
38196 if (PyErr_Occurred()) SWIG_fail;
38197 }
38198 {
38199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38200 }
38201 {
38202 if (temp8)
38203 delete arg8;
38204 }
38205 return resultobj;
38206 fail:
38207 {
38208 if (temp8)
38209 delete arg8;
38210 }
38211 return NULL;
38212 }
38213
38214
38215 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj;
38217 wxControl *arg1 = (wxControl *) 0 ;
38218 wxCommandEvent *arg2 = 0 ;
38219 PyObject * obj0 = 0 ;
38220 PyObject * obj1 = 0 ;
38221 char *kwnames[] = {
38222 (char *) "self",(char *) "event", NULL
38223 };
38224
38225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38227 if (SWIG_arg_fail(1)) SWIG_fail;
38228 {
38229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38230 if (SWIG_arg_fail(2)) SWIG_fail;
38231 if (arg2 == NULL) {
38232 SWIG_null_ref("wxCommandEvent");
38233 }
38234 if (SWIG_arg_fail(2)) SWIG_fail;
38235 }
38236 {
38237 PyThreadState* __tstate = wxPyBeginAllowThreads();
38238 (arg1)->Command(*arg2);
38239
38240 wxPyEndAllowThreads(__tstate);
38241 if (PyErr_Occurred()) SWIG_fail;
38242 }
38243 Py_INCREF(Py_None); resultobj = Py_None;
38244 return resultobj;
38245 fail:
38246 return NULL;
38247 }
38248
38249
38250 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38251 PyObject *resultobj;
38252 wxControl *arg1 = (wxControl *) 0 ;
38253 wxString result;
38254 PyObject * obj0 = 0 ;
38255 char *kwnames[] = {
38256 (char *) "self", NULL
38257 };
38258
38259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38261 if (SWIG_arg_fail(1)) SWIG_fail;
38262 {
38263 PyThreadState* __tstate = wxPyBeginAllowThreads();
38264 result = (arg1)->GetLabel();
38265
38266 wxPyEndAllowThreads(__tstate);
38267 if (PyErr_Occurred()) SWIG_fail;
38268 }
38269 {
38270 #if wxUSE_UNICODE
38271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38272 #else
38273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38274 #endif
38275 }
38276 return resultobj;
38277 fail:
38278 return NULL;
38279 }
38280
38281
38282 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38283 PyObject *resultobj;
38284 wxControl *arg1 = (wxControl *) 0 ;
38285 wxString *arg2 = 0 ;
38286 bool temp2 = false ;
38287 PyObject * obj0 = 0 ;
38288 PyObject * obj1 = 0 ;
38289 char *kwnames[] = {
38290 (char *) "self",(char *) "label", NULL
38291 };
38292
38293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38295 if (SWIG_arg_fail(1)) SWIG_fail;
38296 {
38297 arg2 = wxString_in_helper(obj1);
38298 if (arg2 == NULL) SWIG_fail;
38299 temp2 = true;
38300 }
38301 {
38302 PyThreadState* __tstate = wxPyBeginAllowThreads();
38303 (arg1)->SetLabel((wxString const &)*arg2);
38304
38305 wxPyEndAllowThreads(__tstate);
38306 if (PyErr_Occurred()) SWIG_fail;
38307 }
38308 Py_INCREF(Py_None); resultobj = Py_None;
38309 {
38310 if (temp2)
38311 delete arg2;
38312 }
38313 return resultobj;
38314 fail:
38315 {
38316 if (temp2)
38317 delete arg2;
38318 }
38319 return NULL;
38320 }
38321
38322
38323 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38324 PyObject *resultobj;
38325 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38326 wxVisualAttributes result;
38327 PyObject * obj0 = 0 ;
38328 char *kwnames[] = {
38329 (char *) "variant", NULL
38330 };
38331
38332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38333 if (obj0) {
38334 {
38335 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
38336 if (SWIG_arg_fail(1)) SWIG_fail;
38337 }
38338 }
38339 {
38340 if (!wxPyCheckForApp()) SWIG_fail;
38341 PyThreadState* __tstate = wxPyBeginAllowThreads();
38342 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
38343
38344 wxPyEndAllowThreads(__tstate);
38345 if (PyErr_Occurred()) SWIG_fail;
38346 }
38347 {
38348 wxVisualAttributes * resultptr;
38349 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
38350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38351 }
38352 return resultobj;
38353 fail:
38354 return NULL;
38355 }
38356
38357
38358 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38359 PyObject *obj;
38360 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38361 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38362 Py_INCREF(obj);
38363 return Py_BuildValue((char *)"");
38364 }
38365 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38366 PyObject *resultobj;
38367 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38368 wxString *arg2 = 0 ;
38369 PyObject *arg3 = (PyObject *) NULL ;
38370 int result;
38371 bool temp2 = false ;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 PyObject * obj2 = 0 ;
38375 char *kwnames[] = {
38376 (char *) "self",(char *) "item",(char *) "clientData", NULL
38377 };
38378
38379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38381 if (SWIG_arg_fail(1)) SWIG_fail;
38382 {
38383 arg2 = wxString_in_helper(obj1);
38384 if (arg2 == NULL) SWIG_fail;
38385 temp2 = true;
38386 }
38387 if (obj2) {
38388 arg3 = obj2;
38389 }
38390 {
38391 PyThreadState* __tstate = wxPyBeginAllowThreads();
38392 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38393
38394 wxPyEndAllowThreads(__tstate);
38395 if (PyErr_Occurred()) SWIG_fail;
38396 }
38397 {
38398 resultobj = SWIG_From_int((int)(result));
38399 }
38400 {
38401 if (temp2)
38402 delete arg2;
38403 }
38404 return resultobj;
38405 fail:
38406 {
38407 if (temp2)
38408 delete arg2;
38409 }
38410 return NULL;
38411 }
38412
38413
38414 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38415 PyObject *resultobj;
38416 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38417 wxArrayString *arg2 = 0 ;
38418 bool temp2 = false ;
38419 PyObject * obj0 = 0 ;
38420 PyObject * obj1 = 0 ;
38421 char *kwnames[] = {
38422 (char *) "self",(char *) "strings", NULL
38423 };
38424
38425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38427 if (SWIG_arg_fail(1)) SWIG_fail;
38428 {
38429 if (! PySequence_Check(obj1)) {
38430 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38431 SWIG_fail;
38432 }
38433 arg2 = new wxArrayString;
38434 temp2 = true;
38435 int i, len=PySequence_Length(obj1);
38436 for (i=0; i<len; i++) {
38437 PyObject* item = PySequence_GetItem(obj1, i);
38438 wxString* s = wxString_in_helper(item);
38439 if (PyErr_Occurred()) SWIG_fail;
38440 arg2->Add(*s);
38441 delete s;
38442 Py_DECREF(item);
38443 }
38444 }
38445 {
38446 PyThreadState* __tstate = wxPyBeginAllowThreads();
38447 (arg1)->Append((wxArrayString const &)*arg2);
38448
38449 wxPyEndAllowThreads(__tstate);
38450 if (PyErr_Occurred()) SWIG_fail;
38451 }
38452 Py_INCREF(Py_None); resultobj = Py_None;
38453 {
38454 if (temp2) delete arg2;
38455 }
38456 return resultobj;
38457 fail:
38458 {
38459 if (temp2) delete arg2;
38460 }
38461 return NULL;
38462 }
38463
38464
38465 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38466 PyObject *resultobj;
38467 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38468 wxString *arg2 = 0 ;
38469 int arg3 ;
38470 PyObject *arg4 = (PyObject *) NULL ;
38471 int result;
38472 bool temp2 = false ;
38473 PyObject * obj0 = 0 ;
38474 PyObject * obj1 = 0 ;
38475 PyObject * obj2 = 0 ;
38476 PyObject * obj3 = 0 ;
38477 char *kwnames[] = {
38478 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38479 };
38480
38481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38483 if (SWIG_arg_fail(1)) SWIG_fail;
38484 {
38485 arg2 = wxString_in_helper(obj1);
38486 if (arg2 == NULL) SWIG_fail;
38487 temp2 = true;
38488 }
38489 {
38490 arg3 = (int)(SWIG_As_int(obj2));
38491 if (SWIG_arg_fail(3)) SWIG_fail;
38492 }
38493 if (obj3) {
38494 arg4 = obj3;
38495 }
38496 {
38497 PyThreadState* __tstate = wxPyBeginAllowThreads();
38498 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38499
38500 wxPyEndAllowThreads(__tstate);
38501 if (PyErr_Occurred()) SWIG_fail;
38502 }
38503 {
38504 resultobj = SWIG_From_int((int)(result));
38505 }
38506 {
38507 if (temp2)
38508 delete arg2;
38509 }
38510 return resultobj;
38511 fail:
38512 {
38513 if (temp2)
38514 delete arg2;
38515 }
38516 return NULL;
38517 }
38518
38519
38520 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38521 PyObject *resultobj;
38522 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38523 PyObject * obj0 = 0 ;
38524 char *kwnames[] = {
38525 (char *) "self", NULL
38526 };
38527
38528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38530 if (SWIG_arg_fail(1)) SWIG_fail;
38531 {
38532 PyThreadState* __tstate = wxPyBeginAllowThreads();
38533 (arg1)->Clear();
38534
38535 wxPyEndAllowThreads(__tstate);
38536 if (PyErr_Occurred()) SWIG_fail;
38537 }
38538 Py_INCREF(Py_None); resultobj = Py_None;
38539 return resultobj;
38540 fail:
38541 return NULL;
38542 }
38543
38544
38545 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38546 PyObject *resultobj;
38547 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38548 int arg2 ;
38549 PyObject * obj0 = 0 ;
38550 PyObject * obj1 = 0 ;
38551 char *kwnames[] = {
38552 (char *) "self",(char *) "n", NULL
38553 };
38554
38555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38557 if (SWIG_arg_fail(1)) SWIG_fail;
38558 {
38559 arg2 = (int)(SWIG_As_int(obj1));
38560 if (SWIG_arg_fail(2)) SWIG_fail;
38561 }
38562 {
38563 PyThreadState* __tstate = wxPyBeginAllowThreads();
38564 (arg1)->Delete(arg2);
38565
38566 wxPyEndAllowThreads(__tstate);
38567 if (PyErr_Occurred()) SWIG_fail;
38568 }
38569 Py_INCREF(Py_None); resultobj = Py_None;
38570 return resultobj;
38571 fail:
38572 return NULL;
38573 }
38574
38575
38576 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38577 PyObject *resultobj;
38578 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38579 int arg2 ;
38580 PyObject *result;
38581 PyObject * obj0 = 0 ;
38582 PyObject * obj1 = 0 ;
38583 char *kwnames[] = {
38584 (char *) "self",(char *) "n", NULL
38585 };
38586
38587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38589 if (SWIG_arg_fail(1)) SWIG_fail;
38590 {
38591 arg2 = (int)(SWIG_As_int(obj1));
38592 if (SWIG_arg_fail(2)) SWIG_fail;
38593 }
38594 {
38595 PyThreadState* __tstate = wxPyBeginAllowThreads();
38596 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38597
38598 wxPyEndAllowThreads(__tstate);
38599 if (PyErr_Occurred()) SWIG_fail;
38600 }
38601 resultobj = result;
38602 return resultobj;
38603 fail:
38604 return NULL;
38605 }
38606
38607
38608 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38609 PyObject *resultobj;
38610 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38611 int arg2 ;
38612 PyObject *arg3 = (PyObject *) 0 ;
38613 PyObject * obj0 = 0 ;
38614 PyObject * obj1 = 0 ;
38615 PyObject * obj2 = 0 ;
38616 char *kwnames[] = {
38617 (char *) "self",(char *) "n",(char *) "clientData", NULL
38618 };
38619
38620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38622 if (SWIG_arg_fail(1)) SWIG_fail;
38623 {
38624 arg2 = (int)(SWIG_As_int(obj1));
38625 if (SWIG_arg_fail(2)) SWIG_fail;
38626 }
38627 arg3 = obj2;
38628 {
38629 PyThreadState* __tstate = wxPyBeginAllowThreads();
38630 wxItemContainer_SetClientData(arg1,arg2,arg3);
38631
38632 wxPyEndAllowThreads(__tstate);
38633 if (PyErr_Occurred()) SWIG_fail;
38634 }
38635 Py_INCREF(Py_None); resultobj = Py_None;
38636 return resultobj;
38637 fail:
38638 return NULL;
38639 }
38640
38641
38642 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38643 PyObject *resultobj;
38644 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38645 int result;
38646 PyObject * obj0 = 0 ;
38647 char *kwnames[] = {
38648 (char *) "self", NULL
38649 };
38650
38651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38653 if (SWIG_arg_fail(1)) SWIG_fail;
38654 {
38655 PyThreadState* __tstate = wxPyBeginAllowThreads();
38656 result = (int)((wxItemContainer const *)arg1)->GetCount();
38657
38658 wxPyEndAllowThreads(__tstate);
38659 if (PyErr_Occurred()) SWIG_fail;
38660 }
38661 {
38662 resultobj = SWIG_From_int((int)(result));
38663 }
38664 return resultobj;
38665 fail:
38666 return NULL;
38667 }
38668
38669
38670 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38671 PyObject *resultobj;
38672 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38673 bool result;
38674 PyObject * obj0 = 0 ;
38675 char *kwnames[] = {
38676 (char *) "self", NULL
38677 };
38678
38679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38681 if (SWIG_arg_fail(1)) SWIG_fail;
38682 {
38683 PyThreadState* __tstate = wxPyBeginAllowThreads();
38684 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38685
38686 wxPyEndAllowThreads(__tstate);
38687 if (PyErr_Occurred()) SWIG_fail;
38688 }
38689 {
38690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38691 }
38692 return resultobj;
38693 fail:
38694 return NULL;
38695 }
38696
38697
38698 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38699 PyObject *resultobj;
38700 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38701 int arg2 ;
38702 wxString result;
38703 PyObject * obj0 = 0 ;
38704 PyObject * obj1 = 0 ;
38705 char *kwnames[] = {
38706 (char *) "self",(char *) "n", NULL
38707 };
38708
38709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38711 if (SWIG_arg_fail(1)) SWIG_fail;
38712 {
38713 arg2 = (int)(SWIG_As_int(obj1));
38714 if (SWIG_arg_fail(2)) SWIG_fail;
38715 }
38716 {
38717 PyThreadState* __tstate = wxPyBeginAllowThreads();
38718 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38719
38720 wxPyEndAllowThreads(__tstate);
38721 if (PyErr_Occurred()) SWIG_fail;
38722 }
38723 {
38724 #if wxUSE_UNICODE
38725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38726 #else
38727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38728 #endif
38729 }
38730 return resultobj;
38731 fail:
38732 return NULL;
38733 }
38734
38735
38736 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38737 PyObject *resultobj;
38738 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38739 wxArrayString result;
38740 PyObject * obj0 = 0 ;
38741 char *kwnames[] = {
38742 (char *) "self", NULL
38743 };
38744
38745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38747 if (SWIG_arg_fail(1)) SWIG_fail;
38748 {
38749 PyThreadState* __tstate = wxPyBeginAllowThreads();
38750 result = ((wxItemContainer const *)arg1)->GetStrings();
38751
38752 wxPyEndAllowThreads(__tstate);
38753 if (PyErr_Occurred()) SWIG_fail;
38754 }
38755 {
38756 resultobj = wxArrayString2PyList_helper(result);
38757 }
38758 return resultobj;
38759 fail:
38760 return NULL;
38761 }
38762
38763
38764 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38765 PyObject *resultobj;
38766 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38767 int arg2 ;
38768 wxString *arg3 = 0 ;
38769 bool temp3 = false ;
38770 PyObject * obj0 = 0 ;
38771 PyObject * obj1 = 0 ;
38772 PyObject * obj2 = 0 ;
38773 char *kwnames[] = {
38774 (char *) "self",(char *) "n",(char *) "s", NULL
38775 };
38776
38777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38779 if (SWIG_arg_fail(1)) SWIG_fail;
38780 {
38781 arg2 = (int)(SWIG_As_int(obj1));
38782 if (SWIG_arg_fail(2)) SWIG_fail;
38783 }
38784 {
38785 arg3 = wxString_in_helper(obj2);
38786 if (arg3 == NULL) SWIG_fail;
38787 temp3 = true;
38788 }
38789 {
38790 PyThreadState* __tstate = wxPyBeginAllowThreads();
38791 (arg1)->SetString(arg2,(wxString const &)*arg3);
38792
38793 wxPyEndAllowThreads(__tstate);
38794 if (PyErr_Occurred()) SWIG_fail;
38795 }
38796 Py_INCREF(Py_None); resultobj = Py_None;
38797 {
38798 if (temp3)
38799 delete arg3;
38800 }
38801 return resultobj;
38802 fail:
38803 {
38804 if (temp3)
38805 delete arg3;
38806 }
38807 return NULL;
38808 }
38809
38810
38811 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38812 PyObject *resultobj;
38813 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38814 wxString *arg2 = 0 ;
38815 int result;
38816 bool temp2 = false ;
38817 PyObject * obj0 = 0 ;
38818 PyObject * obj1 = 0 ;
38819 char *kwnames[] = {
38820 (char *) "self",(char *) "s", NULL
38821 };
38822
38823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38825 if (SWIG_arg_fail(1)) SWIG_fail;
38826 {
38827 arg2 = wxString_in_helper(obj1);
38828 if (arg2 == NULL) SWIG_fail;
38829 temp2 = true;
38830 }
38831 {
38832 PyThreadState* __tstate = wxPyBeginAllowThreads();
38833 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38834
38835 wxPyEndAllowThreads(__tstate);
38836 if (PyErr_Occurred()) SWIG_fail;
38837 }
38838 {
38839 resultobj = SWIG_From_int((int)(result));
38840 }
38841 {
38842 if (temp2)
38843 delete arg2;
38844 }
38845 return resultobj;
38846 fail:
38847 {
38848 if (temp2)
38849 delete arg2;
38850 }
38851 return NULL;
38852 }
38853
38854
38855 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38856 PyObject *resultobj;
38857 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38858 int arg2 ;
38859 PyObject * obj0 = 0 ;
38860 PyObject * obj1 = 0 ;
38861 char *kwnames[] = {
38862 (char *) "self",(char *) "n", NULL
38863 };
38864
38865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38867 if (SWIG_arg_fail(1)) SWIG_fail;
38868 {
38869 arg2 = (int)(SWIG_As_int(obj1));
38870 if (SWIG_arg_fail(2)) SWIG_fail;
38871 }
38872 {
38873 PyThreadState* __tstate = wxPyBeginAllowThreads();
38874 (arg1)->SetSelection(arg2);
38875
38876 wxPyEndAllowThreads(__tstate);
38877 if (PyErr_Occurred()) SWIG_fail;
38878 }
38879 Py_INCREF(Py_None); resultobj = Py_None;
38880 return resultobj;
38881 fail:
38882 return NULL;
38883 }
38884
38885
38886 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38887 PyObject *resultobj;
38888 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38889 int result;
38890 PyObject * obj0 = 0 ;
38891 char *kwnames[] = {
38892 (char *) "self", NULL
38893 };
38894
38895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38897 if (SWIG_arg_fail(1)) SWIG_fail;
38898 {
38899 PyThreadState* __tstate = wxPyBeginAllowThreads();
38900 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38901
38902 wxPyEndAllowThreads(__tstate);
38903 if (PyErr_Occurred()) SWIG_fail;
38904 }
38905 {
38906 resultobj = SWIG_From_int((int)(result));
38907 }
38908 return resultobj;
38909 fail:
38910 return NULL;
38911 }
38912
38913
38914 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38915 PyObject *resultobj;
38916 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38917 wxString *arg2 = 0 ;
38918 bool result;
38919 bool temp2 = false ;
38920 PyObject * obj0 = 0 ;
38921 PyObject * obj1 = 0 ;
38922 char *kwnames[] = {
38923 (char *) "self",(char *) "s", NULL
38924 };
38925
38926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38928 if (SWIG_arg_fail(1)) SWIG_fail;
38929 {
38930 arg2 = wxString_in_helper(obj1);
38931 if (arg2 == NULL) SWIG_fail;
38932 temp2 = true;
38933 }
38934 {
38935 PyThreadState* __tstate = wxPyBeginAllowThreads();
38936 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38937
38938 wxPyEndAllowThreads(__tstate);
38939 if (PyErr_Occurred()) SWIG_fail;
38940 }
38941 {
38942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38943 }
38944 {
38945 if (temp2)
38946 delete arg2;
38947 }
38948 return resultobj;
38949 fail:
38950 {
38951 if (temp2)
38952 delete arg2;
38953 }
38954 return NULL;
38955 }
38956
38957
38958 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38959 PyObject *resultobj;
38960 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38961 wxString result;
38962 PyObject * obj0 = 0 ;
38963 char *kwnames[] = {
38964 (char *) "self", NULL
38965 };
38966
38967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38969 if (SWIG_arg_fail(1)) SWIG_fail;
38970 {
38971 PyThreadState* __tstate = wxPyBeginAllowThreads();
38972 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38973
38974 wxPyEndAllowThreads(__tstate);
38975 if (PyErr_Occurred()) SWIG_fail;
38976 }
38977 {
38978 #if wxUSE_UNICODE
38979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38980 #else
38981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38982 #endif
38983 }
38984 return resultobj;
38985 fail:
38986 return NULL;
38987 }
38988
38989
38990 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38991 PyObject *resultobj;
38992 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38993 int arg2 ;
38994 PyObject * obj0 = 0 ;
38995 PyObject * obj1 = 0 ;
38996 char *kwnames[] = {
38997 (char *) "self",(char *) "n", NULL
38998 };
38999
39000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39002 if (SWIG_arg_fail(1)) SWIG_fail;
39003 {
39004 arg2 = (int)(SWIG_As_int(obj1));
39005 if (SWIG_arg_fail(2)) SWIG_fail;
39006 }
39007 {
39008 PyThreadState* __tstate = wxPyBeginAllowThreads();
39009 (arg1)->Select(arg2);
39010
39011 wxPyEndAllowThreads(__tstate);
39012 if (PyErr_Occurred()) SWIG_fail;
39013 }
39014 Py_INCREF(Py_None); resultobj = Py_None;
39015 return resultobj;
39016 fail:
39017 return NULL;
39018 }
39019
39020
39021 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39022 PyObject *obj;
39023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39024 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39025 Py_INCREF(obj);
39026 return Py_BuildValue((char *)"");
39027 }
39028 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39029 PyObject *obj;
39030 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39031 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39032 Py_INCREF(obj);
39033 return Py_BuildValue((char *)"");
39034 }
39035 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39036 PyObject *resultobj;
39037 wxSizerItem *result;
39038 char *kwnames[] = {
39039 NULL
39040 };
39041
39042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39043 {
39044 PyThreadState* __tstate = wxPyBeginAllowThreads();
39045 result = (wxSizerItem *)new wxSizerItem();
39046
39047 wxPyEndAllowThreads(__tstate);
39048 if (PyErr_Occurred()) SWIG_fail;
39049 }
39050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39051 return resultobj;
39052 fail:
39053 return NULL;
39054 }
39055
39056
39057 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39058 PyObject *resultobj;
39059 wxWindow *arg1 = (wxWindow *) 0 ;
39060 int arg2 ;
39061 int arg3 ;
39062 int arg4 ;
39063 PyObject *arg5 = (PyObject *) NULL ;
39064 wxSizerItem *result;
39065 PyObject * obj0 = 0 ;
39066 PyObject * obj1 = 0 ;
39067 PyObject * obj2 = 0 ;
39068 PyObject * obj3 = 0 ;
39069 PyObject * obj4 = 0 ;
39070 char *kwnames[] = {
39071 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39072 };
39073
39074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39076 if (SWIG_arg_fail(1)) SWIG_fail;
39077 {
39078 arg2 = (int)(SWIG_As_int(obj1));
39079 if (SWIG_arg_fail(2)) SWIG_fail;
39080 }
39081 {
39082 arg3 = (int)(SWIG_As_int(obj2));
39083 if (SWIG_arg_fail(3)) SWIG_fail;
39084 }
39085 {
39086 arg4 = (int)(SWIG_As_int(obj3));
39087 if (SWIG_arg_fail(4)) SWIG_fail;
39088 }
39089 if (obj4) {
39090 arg5 = obj4;
39091 }
39092 {
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39095
39096 wxPyEndAllowThreads(__tstate);
39097 if (PyErr_Occurred()) SWIG_fail;
39098 }
39099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39100 return resultobj;
39101 fail:
39102 return NULL;
39103 }
39104
39105
39106 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39107 PyObject *resultobj;
39108 int arg1 ;
39109 int arg2 ;
39110 int arg3 ;
39111 int arg4 ;
39112 int arg5 ;
39113 PyObject *arg6 = (PyObject *) NULL ;
39114 wxSizerItem *result;
39115 PyObject * obj0 = 0 ;
39116 PyObject * obj1 = 0 ;
39117 PyObject * obj2 = 0 ;
39118 PyObject * obj3 = 0 ;
39119 PyObject * obj4 = 0 ;
39120 PyObject * obj5 = 0 ;
39121 char *kwnames[] = {
39122 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39123 };
39124
39125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39126 {
39127 arg1 = (int)(SWIG_As_int(obj0));
39128 if (SWIG_arg_fail(1)) SWIG_fail;
39129 }
39130 {
39131 arg2 = (int)(SWIG_As_int(obj1));
39132 if (SWIG_arg_fail(2)) SWIG_fail;
39133 }
39134 {
39135 arg3 = (int)(SWIG_As_int(obj2));
39136 if (SWIG_arg_fail(3)) SWIG_fail;
39137 }
39138 {
39139 arg4 = (int)(SWIG_As_int(obj3));
39140 if (SWIG_arg_fail(4)) SWIG_fail;
39141 }
39142 {
39143 arg5 = (int)(SWIG_As_int(obj4));
39144 if (SWIG_arg_fail(5)) SWIG_fail;
39145 }
39146 if (obj5) {
39147 arg6 = obj5;
39148 }
39149 {
39150 PyThreadState* __tstate = wxPyBeginAllowThreads();
39151 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39152
39153 wxPyEndAllowThreads(__tstate);
39154 if (PyErr_Occurred()) SWIG_fail;
39155 }
39156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39157 return resultobj;
39158 fail:
39159 return NULL;
39160 }
39161
39162
39163 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39164 PyObject *resultobj;
39165 wxSizer *arg1 = (wxSizer *) 0 ;
39166 int arg2 ;
39167 int arg3 ;
39168 int arg4 ;
39169 PyObject *arg5 = (PyObject *) NULL ;
39170 wxSizerItem *result;
39171 PyObject * obj0 = 0 ;
39172 PyObject * obj1 = 0 ;
39173 PyObject * obj2 = 0 ;
39174 PyObject * obj3 = 0 ;
39175 PyObject * obj4 = 0 ;
39176 char *kwnames[] = {
39177 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39178 };
39179
39180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39182 if (SWIG_arg_fail(1)) SWIG_fail;
39183 {
39184 arg2 = (int)(SWIG_As_int(obj1));
39185 if (SWIG_arg_fail(2)) SWIG_fail;
39186 }
39187 {
39188 arg3 = (int)(SWIG_As_int(obj2));
39189 if (SWIG_arg_fail(3)) SWIG_fail;
39190 }
39191 {
39192 arg4 = (int)(SWIG_As_int(obj3));
39193 if (SWIG_arg_fail(4)) SWIG_fail;
39194 }
39195 if (obj4) {
39196 arg5 = obj4;
39197 }
39198 {
39199 PyThreadState* __tstate = wxPyBeginAllowThreads();
39200 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39201
39202 wxPyEndAllowThreads(__tstate);
39203 if (PyErr_Occurred()) SWIG_fail;
39204 }
39205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39206 return resultobj;
39207 fail:
39208 return NULL;
39209 }
39210
39211
39212 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39213 PyObject *resultobj;
39214 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39215 PyObject * obj0 = 0 ;
39216 char *kwnames[] = {
39217 (char *) "self", NULL
39218 };
39219
39220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39222 if (SWIG_arg_fail(1)) SWIG_fail;
39223 {
39224 PyThreadState* __tstate = wxPyBeginAllowThreads();
39225 (arg1)->DeleteWindows();
39226
39227 wxPyEndAllowThreads(__tstate);
39228 if (PyErr_Occurred()) SWIG_fail;
39229 }
39230 Py_INCREF(Py_None); resultobj = Py_None;
39231 return resultobj;
39232 fail:
39233 return NULL;
39234 }
39235
39236
39237 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39238 PyObject *resultobj;
39239 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39240 PyObject * obj0 = 0 ;
39241 char *kwnames[] = {
39242 (char *) "self", NULL
39243 };
39244
39245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39247 if (SWIG_arg_fail(1)) SWIG_fail;
39248 {
39249 PyThreadState* __tstate = wxPyBeginAllowThreads();
39250 (arg1)->DetachSizer();
39251
39252 wxPyEndAllowThreads(__tstate);
39253 if (PyErr_Occurred()) SWIG_fail;
39254 }
39255 Py_INCREF(Py_None); resultobj = Py_None;
39256 return resultobj;
39257 fail:
39258 return NULL;
39259 }
39260
39261
39262 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39263 PyObject *resultobj;
39264 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39265 wxSize result;
39266 PyObject * obj0 = 0 ;
39267 char *kwnames[] = {
39268 (char *) "self", NULL
39269 };
39270
39271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39273 if (SWIG_arg_fail(1)) SWIG_fail;
39274 {
39275 PyThreadState* __tstate = wxPyBeginAllowThreads();
39276 result = (arg1)->GetSize();
39277
39278 wxPyEndAllowThreads(__tstate);
39279 if (PyErr_Occurred()) SWIG_fail;
39280 }
39281 {
39282 wxSize * resultptr;
39283 resultptr = new wxSize((wxSize &)(result));
39284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39285 }
39286 return resultobj;
39287 fail:
39288 return NULL;
39289 }
39290
39291
39292 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39293 PyObject *resultobj;
39294 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39295 wxSize result;
39296 PyObject * obj0 = 0 ;
39297 char *kwnames[] = {
39298 (char *) "self", NULL
39299 };
39300
39301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39303 if (SWIG_arg_fail(1)) SWIG_fail;
39304 {
39305 PyThreadState* __tstate = wxPyBeginAllowThreads();
39306 result = (arg1)->CalcMin();
39307
39308 wxPyEndAllowThreads(__tstate);
39309 if (PyErr_Occurred()) SWIG_fail;
39310 }
39311 {
39312 wxSize * resultptr;
39313 resultptr = new wxSize((wxSize &)(result));
39314 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39315 }
39316 return resultobj;
39317 fail:
39318 return NULL;
39319 }
39320
39321
39322 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39323 PyObject *resultobj;
39324 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39325 wxPoint arg2 ;
39326 wxSize arg3 ;
39327 PyObject * obj0 = 0 ;
39328 PyObject * obj1 = 0 ;
39329 PyObject * obj2 = 0 ;
39330 char *kwnames[] = {
39331 (char *) "self",(char *) "pos",(char *) "size", NULL
39332 };
39333
39334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39336 if (SWIG_arg_fail(1)) SWIG_fail;
39337 {
39338 wxPoint * argp;
39339 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
39340 if (SWIG_arg_fail(2)) SWIG_fail;
39341 if (argp == NULL) {
39342 SWIG_null_ref("wxPoint");
39343 }
39344 if (SWIG_arg_fail(2)) SWIG_fail;
39345 arg2 = *argp;
39346 }
39347 {
39348 wxSize * argp;
39349 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
39350 if (SWIG_arg_fail(3)) SWIG_fail;
39351 if (argp == NULL) {
39352 SWIG_null_ref("wxSize");
39353 }
39354 if (SWIG_arg_fail(3)) SWIG_fail;
39355 arg3 = *argp;
39356 }
39357 {
39358 PyThreadState* __tstate = wxPyBeginAllowThreads();
39359 (arg1)->SetDimension(arg2,arg3);
39360
39361 wxPyEndAllowThreads(__tstate);
39362 if (PyErr_Occurred()) SWIG_fail;
39363 }
39364 Py_INCREF(Py_None); resultobj = Py_None;
39365 return resultobj;
39366 fail:
39367 return NULL;
39368 }
39369
39370
39371 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39372 PyObject *resultobj;
39373 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39374 wxSize result;
39375 PyObject * obj0 = 0 ;
39376 char *kwnames[] = {
39377 (char *) "self", NULL
39378 };
39379
39380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39382 if (SWIG_arg_fail(1)) SWIG_fail;
39383 {
39384 PyThreadState* __tstate = wxPyBeginAllowThreads();
39385 result = (arg1)->GetMinSize();
39386
39387 wxPyEndAllowThreads(__tstate);
39388 if (PyErr_Occurred()) SWIG_fail;
39389 }
39390 {
39391 wxSize * resultptr;
39392 resultptr = new wxSize((wxSize &)(result));
39393 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39394 }
39395 return resultobj;
39396 fail:
39397 return NULL;
39398 }
39399
39400
39401 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39402 PyObject *resultobj;
39403 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39404 wxSize result;
39405 PyObject * obj0 = 0 ;
39406 char *kwnames[] = {
39407 (char *) "self", NULL
39408 };
39409
39410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39412 if (SWIG_arg_fail(1)) SWIG_fail;
39413 {
39414 PyThreadState* __tstate = wxPyBeginAllowThreads();
39415 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39416
39417 wxPyEndAllowThreads(__tstate);
39418 if (PyErr_Occurred()) SWIG_fail;
39419 }
39420 {
39421 wxSize * resultptr;
39422 resultptr = new wxSize((wxSize &)(result));
39423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39424 }
39425 return resultobj;
39426 fail:
39427 return NULL;
39428 }
39429
39430
39431 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39432 PyObject *resultobj;
39433 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39434 int arg2 ;
39435 int arg3 ;
39436 PyObject * obj0 = 0 ;
39437 PyObject * obj1 = 0 ;
39438 PyObject * obj2 = 0 ;
39439 char *kwnames[] = {
39440 (char *) "self",(char *) "x",(char *) "y", NULL
39441 };
39442
39443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39445 if (SWIG_arg_fail(1)) SWIG_fail;
39446 {
39447 arg2 = (int)(SWIG_As_int(obj1));
39448 if (SWIG_arg_fail(2)) SWIG_fail;
39449 }
39450 {
39451 arg3 = (int)(SWIG_As_int(obj2));
39452 if (SWIG_arg_fail(3)) SWIG_fail;
39453 }
39454 {
39455 PyThreadState* __tstate = wxPyBeginAllowThreads();
39456 (arg1)->SetInitSize(arg2,arg3);
39457
39458 wxPyEndAllowThreads(__tstate);
39459 if (PyErr_Occurred()) SWIG_fail;
39460 }
39461 Py_INCREF(Py_None); resultobj = Py_None;
39462 return resultobj;
39463 fail:
39464 return NULL;
39465 }
39466
39467
39468 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39469 PyObject *resultobj;
39470 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39471 int arg2 ;
39472 int arg3 ;
39473 PyObject * obj0 = 0 ;
39474 PyObject * obj1 = 0 ;
39475 PyObject * obj2 = 0 ;
39476 char *kwnames[] = {
39477 (char *) "self",(char *) "width",(char *) "height", NULL
39478 };
39479
39480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39482 if (SWIG_arg_fail(1)) SWIG_fail;
39483 {
39484 arg2 = (int)(SWIG_As_int(obj1));
39485 if (SWIG_arg_fail(2)) SWIG_fail;
39486 }
39487 {
39488 arg3 = (int)(SWIG_As_int(obj2));
39489 if (SWIG_arg_fail(3)) SWIG_fail;
39490 }
39491 {
39492 PyThreadState* __tstate = wxPyBeginAllowThreads();
39493 (arg1)->SetRatio(arg2,arg3);
39494
39495 wxPyEndAllowThreads(__tstate);
39496 if (PyErr_Occurred()) SWIG_fail;
39497 }
39498 Py_INCREF(Py_None); resultobj = Py_None;
39499 return resultobj;
39500 fail:
39501 return NULL;
39502 }
39503
39504
39505 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39506 PyObject *resultobj;
39507 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39508 wxSize *arg2 = 0 ;
39509 wxSize temp2 ;
39510 PyObject * obj0 = 0 ;
39511 PyObject * obj1 = 0 ;
39512 char *kwnames[] = {
39513 (char *) "self",(char *) "size", NULL
39514 };
39515
39516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39518 if (SWIG_arg_fail(1)) SWIG_fail;
39519 {
39520 arg2 = &temp2;
39521 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39522 }
39523 {
39524 PyThreadState* __tstate = wxPyBeginAllowThreads();
39525 (arg1)->SetRatio((wxSize const &)*arg2);
39526
39527 wxPyEndAllowThreads(__tstate);
39528 if (PyErr_Occurred()) SWIG_fail;
39529 }
39530 Py_INCREF(Py_None); resultobj = Py_None;
39531 return resultobj;
39532 fail:
39533 return NULL;
39534 }
39535
39536
39537 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39538 PyObject *resultobj;
39539 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39540 float arg2 ;
39541 PyObject * obj0 = 0 ;
39542 PyObject * obj1 = 0 ;
39543 char *kwnames[] = {
39544 (char *) "self",(char *) "ratio", NULL
39545 };
39546
39547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39549 if (SWIG_arg_fail(1)) SWIG_fail;
39550 {
39551 arg2 = (float)(SWIG_As_float(obj1));
39552 if (SWIG_arg_fail(2)) SWIG_fail;
39553 }
39554 {
39555 PyThreadState* __tstate = wxPyBeginAllowThreads();
39556 (arg1)->SetRatio(arg2);
39557
39558 wxPyEndAllowThreads(__tstate);
39559 if (PyErr_Occurred()) SWIG_fail;
39560 }
39561 Py_INCREF(Py_None); resultobj = Py_None;
39562 return resultobj;
39563 fail:
39564 return NULL;
39565 }
39566
39567
39568 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39569 PyObject *resultobj;
39570 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39571 float result;
39572 PyObject * obj0 = 0 ;
39573 char *kwnames[] = {
39574 (char *) "self", NULL
39575 };
39576
39577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39579 if (SWIG_arg_fail(1)) SWIG_fail;
39580 {
39581 PyThreadState* __tstate = wxPyBeginAllowThreads();
39582 result = (float)(arg1)->GetRatio();
39583
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 {
39588 resultobj = SWIG_From_float((float)(result));
39589 }
39590 return resultobj;
39591 fail:
39592 return NULL;
39593 }
39594
39595
39596 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39597 PyObject *resultobj;
39598 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39599 wxRect result;
39600 PyObject * obj0 = 0 ;
39601 char *kwnames[] = {
39602 (char *) "self", NULL
39603 };
39604
39605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39607 if (SWIG_arg_fail(1)) SWIG_fail;
39608 {
39609 PyThreadState* __tstate = wxPyBeginAllowThreads();
39610 result = (arg1)->GetRect();
39611
39612 wxPyEndAllowThreads(__tstate);
39613 if (PyErr_Occurred()) SWIG_fail;
39614 }
39615 {
39616 wxRect * resultptr;
39617 resultptr = new wxRect((wxRect &)(result));
39618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39619 }
39620 return resultobj;
39621 fail:
39622 return NULL;
39623 }
39624
39625
39626 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39627 PyObject *resultobj;
39628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39629 bool result;
39630 PyObject * obj0 = 0 ;
39631 char *kwnames[] = {
39632 (char *) "self", NULL
39633 };
39634
39635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39637 if (SWIG_arg_fail(1)) SWIG_fail;
39638 {
39639 PyThreadState* __tstate = wxPyBeginAllowThreads();
39640 result = (bool)(arg1)->IsWindow();
39641
39642 wxPyEndAllowThreads(__tstate);
39643 if (PyErr_Occurred()) SWIG_fail;
39644 }
39645 {
39646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39647 }
39648 return resultobj;
39649 fail:
39650 return NULL;
39651 }
39652
39653
39654 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39655 PyObject *resultobj;
39656 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39657 bool result;
39658 PyObject * obj0 = 0 ;
39659 char *kwnames[] = {
39660 (char *) "self", NULL
39661 };
39662
39663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39665 if (SWIG_arg_fail(1)) SWIG_fail;
39666 {
39667 PyThreadState* __tstate = wxPyBeginAllowThreads();
39668 result = (bool)(arg1)->IsSizer();
39669
39670 wxPyEndAllowThreads(__tstate);
39671 if (PyErr_Occurred()) SWIG_fail;
39672 }
39673 {
39674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39675 }
39676 return resultobj;
39677 fail:
39678 return NULL;
39679 }
39680
39681
39682 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39683 PyObject *resultobj;
39684 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39685 bool result;
39686 PyObject * obj0 = 0 ;
39687 char *kwnames[] = {
39688 (char *) "self", NULL
39689 };
39690
39691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39693 if (SWIG_arg_fail(1)) SWIG_fail;
39694 {
39695 PyThreadState* __tstate = wxPyBeginAllowThreads();
39696 result = (bool)(arg1)->IsSpacer();
39697
39698 wxPyEndAllowThreads(__tstate);
39699 if (PyErr_Occurred()) SWIG_fail;
39700 }
39701 {
39702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39703 }
39704 return resultobj;
39705 fail:
39706 return NULL;
39707 }
39708
39709
39710 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39711 PyObject *resultobj;
39712 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39713 int arg2 ;
39714 PyObject * obj0 = 0 ;
39715 PyObject * obj1 = 0 ;
39716 char *kwnames[] = {
39717 (char *) "self",(char *) "proportion", NULL
39718 };
39719
39720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39722 if (SWIG_arg_fail(1)) SWIG_fail;
39723 {
39724 arg2 = (int)(SWIG_As_int(obj1));
39725 if (SWIG_arg_fail(2)) SWIG_fail;
39726 }
39727 {
39728 PyThreadState* __tstate = wxPyBeginAllowThreads();
39729 (arg1)->SetProportion(arg2);
39730
39731 wxPyEndAllowThreads(__tstate);
39732 if (PyErr_Occurred()) SWIG_fail;
39733 }
39734 Py_INCREF(Py_None); resultobj = Py_None;
39735 return resultobj;
39736 fail:
39737 return NULL;
39738 }
39739
39740
39741 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39742 PyObject *resultobj;
39743 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39744 int result;
39745 PyObject * obj0 = 0 ;
39746 char *kwnames[] = {
39747 (char *) "self", NULL
39748 };
39749
39750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39752 if (SWIG_arg_fail(1)) SWIG_fail;
39753 {
39754 PyThreadState* __tstate = wxPyBeginAllowThreads();
39755 result = (int)(arg1)->GetProportion();
39756
39757 wxPyEndAllowThreads(__tstate);
39758 if (PyErr_Occurred()) SWIG_fail;
39759 }
39760 {
39761 resultobj = SWIG_From_int((int)(result));
39762 }
39763 return resultobj;
39764 fail:
39765 return NULL;
39766 }
39767
39768
39769 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39770 PyObject *resultobj;
39771 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39772 int arg2 ;
39773 PyObject * obj0 = 0 ;
39774 PyObject * obj1 = 0 ;
39775 char *kwnames[] = {
39776 (char *) "self",(char *) "flag", NULL
39777 };
39778
39779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39781 if (SWIG_arg_fail(1)) SWIG_fail;
39782 {
39783 arg2 = (int)(SWIG_As_int(obj1));
39784 if (SWIG_arg_fail(2)) SWIG_fail;
39785 }
39786 {
39787 PyThreadState* __tstate = wxPyBeginAllowThreads();
39788 (arg1)->SetFlag(arg2);
39789
39790 wxPyEndAllowThreads(__tstate);
39791 if (PyErr_Occurred()) SWIG_fail;
39792 }
39793 Py_INCREF(Py_None); resultobj = Py_None;
39794 return resultobj;
39795 fail:
39796 return NULL;
39797 }
39798
39799
39800 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39801 PyObject *resultobj;
39802 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39803 int result;
39804 PyObject * obj0 = 0 ;
39805 char *kwnames[] = {
39806 (char *) "self", NULL
39807 };
39808
39809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39811 if (SWIG_arg_fail(1)) SWIG_fail;
39812 {
39813 PyThreadState* __tstate = wxPyBeginAllowThreads();
39814 result = (int)(arg1)->GetFlag();
39815
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 {
39820 resultobj = SWIG_From_int((int)(result));
39821 }
39822 return resultobj;
39823 fail:
39824 return NULL;
39825 }
39826
39827
39828 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39829 PyObject *resultobj;
39830 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39831 int arg2 ;
39832 PyObject * obj0 = 0 ;
39833 PyObject * obj1 = 0 ;
39834 char *kwnames[] = {
39835 (char *) "self",(char *) "border", NULL
39836 };
39837
39838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39840 if (SWIG_arg_fail(1)) SWIG_fail;
39841 {
39842 arg2 = (int)(SWIG_As_int(obj1));
39843 if (SWIG_arg_fail(2)) SWIG_fail;
39844 }
39845 {
39846 PyThreadState* __tstate = wxPyBeginAllowThreads();
39847 (arg1)->SetBorder(arg2);
39848
39849 wxPyEndAllowThreads(__tstate);
39850 if (PyErr_Occurred()) SWIG_fail;
39851 }
39852 Py_INCREF(Py_None); resultobj = Py_None;
39853 return resultobj;
39854 fail:
39855 return NULL;
39856 }
39857
39858
39859 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39860 PyObject *resultobj;
39861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39862 int result;
39863 PyObject * obj0 = 0 ;
39864 char *kwnames[] = {
39865 (char *) "self", NULL
39866 };
39867
39868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39870 if (SWIG_arg_fail(1)) SWIG_fail;
39871 {
39872 PyThreadState* __tstate = wxPyBeginAllowThreads();
39873 result = (int)(arg1)->GetBorder();
39874
39875 wxPyEndAllowThreads(__tstate);
39876 if (PyErr_Occurred()) SWIG_fail;
39877 }
39878 {
39879 resultobj = SWIG_From_int((int)(result));
39880 }
39881 return resultobj;
39882 fail:
39883 return NULL;
39884 }
39885
39886
39887 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39888 PyObject *resultobj;
39889 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39890 wxWindow *result;
39891 PyObject * obj0 = 0 ;
39892 char *kwnames[] = {
39893 (char *) "self", NULL
39894 };
39895
39896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39898 if (SWIG_arg_fail(1)) SWIG_fail;
39899 {
39900 PyThreadState* __tstate = wxPyBeginAllowThreads();
39901 result = (wxWindow *)(arg1)->GetWindow();
39902
39903 wxPyEndAllowThreads(__tstate);
39904 if (PyErr_Occurred()) SWIG_fail;
39905 }
39906 {
39907 resultobj = wxPyMake_wxObject(result, 0);
39908 }
39909 return resultobj;
39910 fail:
39911 return NULL;
39912 }
39913
39914
39915 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39916 PyObject *resultobj;
39917 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39918 wxWindow *arg2 = (wxWindow *) 0 ;
39919 PyObject * obj0 = 0 ;
39920 PyObject * obj1 = 0 ;
39921 char *kwnames[] = {
39922 (char *) "self",(char *) "window", NULL
39923 };
39924
39925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39927 if (SWIG_arg_fail(1)) SWIG_fail;
39928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39929 if (SWIG_arg_fail(2)) SWIG_fail;
39930 {
39931 PyThreadState* __tstate = wxPyBeginAllowThreads();
39932 (arg1)->SetWindow(arg2);
39933
39934 wxPyEndAllowThreads(__tstate);
39935 if (PyErr_Occurred()) SWIG_fail;
39936 }
39937 Py_INCREF(Py_None); resultobj = Py_None;
39938 return resultobj;
39939 fail:
39940 return NULL;
39941 }
39942
39943
39944 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39945 PyObject *resultobj;
39946 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39947 wxSizer *result;
39948 PyObject * obj0 = 0 ;
39949 char *kwnames[] = {
39950 (char *) "self", NULL
39951 };
39952
39953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39955 if (SWIG_arg_fail(1)) SWIG_fail;
39956 {
39957 PyThreadState* __tstate = wxPyBeginAllowThreads();
39958 result = (wxSizer *)(arg1)->GetSizer();
39959
39960 wxPyEndAllowThreads(__tstate);
39961 if (PyErr_Occurred()) SWIG_fail;
39962 }
39963 {
39964 resultobj = wxPyMake_wxObject(result, 0);
39965 }
39966 return resultobj;
39967 fail:
39968 return NULL;
39969 }
39970
39971
39972 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39973 PyObject *resultobj;
39974 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39975 wxSizer *arg2 = (wxSizer *) 0 ;
39976 PyObject * obj0 = 0 ;
39977 PyObject * obj1 = 0 ;
39978 char *kwnames[] = {
39979 (char *) "self",(char *) "sizer", NULL
39980 };
39981
39982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39984 if (SWIG_arg_fail(1)) SWIG_fail;
39985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39986 if (SWIG_arg_fail(2)) SWIG_fail;
39987 {
39988 PyThreadState* __tstate = wxPyBeginAllowThreads();
39989 (arg1)->SetSizer(arg2);
39990
39991 wxPyEndAllowThreads(__tstate);
39992 if (PyErr_Occurred()) SWIG_fail;
39993 }
39994 Py_INCREF(Py_None); resultobj = Py_None;
39995 return resultobj;
39996 fail:
39997 return NULL;
39998 }
39999
40000
40001 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40002 PyObject *resultobj;
40003 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40004 wxSize *result;
40005 PyObject * obj0 = 0 ;
40006 char *kwnames[] = {
40007 (char *) "self", NULL
40008 };
40009
40010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40012 if (SWIG_arg_fail(1)) SWIG_fail;
40013 {
40014 PyThreadState* __tstate = wxPyBeginAllowThreads();
40015 {
40016 wxSize const &_result_ref = (arg1)->GetSpacer();
40017 result = (wxSize *) &_result_ref;
40018 }
40019
40020 wxPyEndAllowThreads(__tstate);
40021 if (PyErr_Occurred()) SWIG_fail;
40022 }
40023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40024 return resultobj;
40025 fail:
40026 return NULL;
40027 }
40028
40029
40030 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40031 PyObject *resultobj;
40032 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40033 wxSize *arg2 = 0 ;
40034 wxSize temp2 ;
40035 PyObject * obj0 = 0 ;
40036 PyObject * obj1 = 0 ;
40037 char *kwnames[] = {
40038 (char *) "self",(char *) "size", NULL
40039 };
40040
40041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40043 if (SWIG_arg_fail(1)) SWIG_fail;
40044 {
40045 arg2 = &temp2;
40046 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40047 }
40048 {
40049 PyThreadState* __tstate = wxPyBeginAllowThreads();
40050 (arg1)->SetSpacer((wxSize const &)*arg2);
40051
40052 wxPyEndAllowThreads(__tstate);
40053 if (PyErr_Occurred()) SWIG_fail;
40054 }
40055 Py_INCREF(Py_None); resultobj = Py_None;
40056 return resultobj;
40057 fail:
40058 return NULL;
40059 }
40060
40061
40062 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40063 PyObject *resultobj;
40064 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40065 bool arg2 ;
40066 PyObject * obj0 = 0 ;
40067 PyObject * obj1 = 0 ;
40068 char *kwnames[] = {
40069 (char *) "self",(char *) "show", NULL
40070 };
40071
40072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40074 if (SWIG_arg_fail(1)) SWIG_fail;
40075 {
40076 arg2 = (bool)(SWIG_As_bool(obj1));
40077 if (SWIG_arg_fail(2)) SWIG_fail;
40078 }
40079 {
40080 PyThreadState* __tstate = wxPyBeginAllowThreads();
40081 (arg1)->Show(arg2);
40082
40083 wxPyEndAllowThreads(__tstate);
40084 if (PyErr_Occurred()) SWIG_fail;
40085 }
40086 Py_INCREF(Py_None); resultobj = Py_None;
40087 return resultobj;
40088 fail:
40089 return NULL;
40090 }
40091
40092
40093 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40094 PyObject *resultobj;
40095 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40096 bool result;
40097 PyObject * obj0 = 0 ;
40098 char *kwnames[] = {
40099 (char *) "self", NULL
40100 };
40101
40102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40104 if (SWIG_arg_fail(1)) SWIG_fail;
40105 {
40106 PyThreadState* __tstate = wxPyBeginAllowThreads();
40107 result = (bool)(arg1)->IsShown();
40108
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 {
40113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40114 }
40115 return resultobj;
40116 fail:
40117 return NULL;
40118 }
40119
40120
40121 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40122 PyObject *resultobj;
40123 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40124 wxPoint result;
40125 PyObject * obj0 = 0 ;
40126 char *kwnames[] = {
40127 (char *) "self", NULL
40128 };
40129
40130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40132 if (SWIG_arg_fail(1)) SWIG_fail;
40133 {
40134 PyThreadState* __tstate = wxPyBeginAllowThreads();
40135 result = (arg1)->GetPosition();
40136
40137 wxPyEndAllowThreads(__tstate);
40138 if (PyErr_Occurred()) SWIG_fail;
40139 }
40140 {
40141 wxPoint * resultptr;
40142 resultptr = new wxPoint((wxPoint &)(result));
40143 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40144 }
40145 return resultobj;
40146 fail:
40147 return NULL;
40148 }
40149
40150
40151 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40152 PyObject *resultobj;
40153 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40154 PyObject *result;
40155 PyObject * obj0 = 0 ;
40156 char *kwnames[] = {
40157 (char *) "self", NULL
40158 };
40159
40160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40162 if (SWIG_arg_fail(1)) SWIG_fail;
40163 {
40164 PyThreadState* __tstate = wxPyBeginAllowThreads();
40165 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40166
40167 wxPyEndAllowThreads(__tstate);
40168 if (PyErr_Occurred()) SWIG_fail;
40169 }
40170 resultobj = result;
40171 return resultobj;
40172 fail:
40173 return NULL;
40174 }
40175
40176
40177 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40178 PyObject *obj;
40179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40180 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40181 Py_INCREF(obj);
40182 return Py_BuildValue((char *)"");
40183 }
40184 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40185 PyObject *resultobj;
40186 wxSizer *arg1 = (wxSizer *) 0 ;
40187 PyObject *arg2 = (PyObject *) 0 ;
40188 PyObject * obj0 = 0 ;
40189 PyObject * obj1 = 0 ;
40190 char *kwnames[] = {
40191 (char *) "self",(char *) "_self", NULL
40192 };
40193
40194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40196 if (SWIG_arg_fail(1)) SWIG_fail;
40197 arg2 = obj1;
40198 {
40199 PyThreadState* __tstate = wxPyBeginAllowThreads();
40200 wxSizer__setOORInfo(arg1,arg2);
40201
40202 wxPyEndAllowThreads(__tstate);
40203 if (PyErr_Occurred()) SWIG_fail;
40204 }
40205 Py_INCREF(Py_None); resultobj = Py_None;
40206 return resultobj;
40207 fail:
40208 return NULL;
40209 }
40210
40211
40212 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40213 PyObject *resultobj;
40214 wxSizer *arg1 = (wxSizer *) 0 ;
40215 PyObject *arg2 = (PyObject *) 0 ;
40216 int arg3 = (int) 0 ;
40217 int arg4 = (int) 0 ;
40218 int arg5 = (int) 0 ;
40219 PyObject *arg6 = (PyObject *) NULL ;
40220 wxSizerItem *result;
40221 PyObject * obj0 = 0 ;
40222 PyObject * obj1 = 0 ;
40223 PyObject * obj2 = 0 ;
40224 PyObject * obj3 = 0 ;
40225 PyObject * obj4 = 0 ;
40226 PyObject * obj5 = 0 ;
40227 char *kwnames[] = {
40228 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40229 };
40230
40231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40233 if (SWIG_arg_fail(1)) SWIG_fail;
40234 arg2 = obj1;
40235 if (obj2) {
40236 {
40237 arg3 = (int)(SWIG_As_int(obj2));
40238 if (SWIG_arg_fail(3)) SWIG_fail;
40239 }
40240 }
40241 if (obj3) {
40242 {
40243 arg4 = (int)(SWIG_As_int(obj3));
40244 if (SWIG_arg_fail(4)) SWIG_fail;
40245 }
40246 }
40247 if (obj4) {
40248 {
40249 arg5 = (int)(SWIG_As_int(obj4));
40250 if (SWIG_arg_fail(5)) SWIG_fail;
40251 }
40252 }
40253 if (obj5) {
40254 arg6 = obj5;
40255 }
40256 {
40257 PyThreadState* __tstate = wxPyBeginAllowThreads();
40258 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40259
40260 wxPyEndAllowThreads(__tstate);
40261 if (PyErr_Occurred()) SWIG_fail;
40262 }
40263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40264 return resultobj;
40265 fail:
40266 return NULL;
40267 }
40268
40269
40270 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40271 PyObject *resultobj;
40272 wxSizer *arg1 = (wxSizer *) 0 ;
40273 int arg2 ;
40274 PyObject *arg3 = (PyObject *) 0 ;
40275 int arg4 = (int) 0 ;
40276 int arg5 = (int) 0 ;
40277 int arg6 = (int) 0 ;
40278 PyObject *arg7 = (PyObject *) NULL ;
40279 wxSizerItem *result;
40280 PyObject * obj0 = 0 ;
40281 PyObject * obj1 = 0 ;
40282 PyObject * obj2 = 0 ;
40283 PyObject * obj3 = 0 ;
40284 PyObject * obj4 = 0 ;
40285 PyObject * obj5 = 0 ;
40286 PyObject * obj6 = 0 ;
40287 char *kwnames[] = {
40288 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40289 };
40290
40291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40293 if (SWIG_arg_fail(1)) SWIG_fail;
40294 {
40295 arg2 = (int)(SWIG_As_int(obj1));
40296 if (SWIG_arg_fail(2)) SWIG_fail;
40297 }
40298 arg3 = obj2;
40299 if (obj3) {
40300 {
40301 arg4 = (int)(SWIG_As_int(obj3));
40302 if (SWIG_arg_fail(4)) SWIG_fail;
40303 }
40304 }
40305 if (obj4) {
40306 {
40307 arg5 = (int)(SWIG_As_int(obj4));
40308 if (SWIG_arg_fail(5)) SWIG_fail;
40309 }
40310 }
40311 if (obj5) {
40312 {
40313 arg6 = (int)(SWIG_As_int(obj5));
40314 if (SWIG_arg_fail(6)) SWIG_fail;
40315 }
40316 }
40317 if (obj6) {
40318 arg7 = obj6;
40319 }
40320 {
40321 PyThreadState* __tstate = wxPyBeginAllowThreads();
40322 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40323
40324 wxPyEndAllowThreads(__tstate);
40325 if (PyErr_Occurred()) SWIG_fail;
40326 }
40327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40328 return resultobj;
40329 fail:
40330 return NULL;
40331 }
40332
40333
40334 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40335 PyObject *resultobj;
40336 wxSizer *arg1 = (wxSizer *) 0 ;
40337 PyObject *arg2 = (PyObject *) 0 ;
40338 int arg3 = (int) 0 ;
40339 int arg4 = (int) 0 ;
40340 int arg5 = (int) 0 ;
40341 PyObject *arg6 = (PyObject *) NULL ;
40342 wxSizerItem *result;
40343 PyObject * obj0 = 0 ;
40344 PyObject * obj1 = 0 ;
40345 PyObject * obj2 = 0 ;
40346 PyObject * obj3 = 0 ;
40347 PyObject * obj4 = 0 ;
40348 PyObject * obj5 = 0 ;
40349 char *kwnames[] = {
40350 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40351 };
40352
40353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40355 if (SWIG_arg_fail(1)) SWIG_fail;
40356 arg2 = obj1;
40357 if (obj2) {
40358 {
40359 arg3 = (int)(SWIG_As_int(obj2));
40360 if (SWIG_arg_fail(3)) SWIG_fail;
40361 }
40362 }
40363 if (obj3) {
40364 {
40365 arg4 = (int)(SWIG_As_int(obj3));
40366 if (SWIG_arg_fail(4)) SWIG_fail;
40367 }
40368 }
40369 if (obj4) {
40370 {
40371 arg5 = (int)(SWIG_As_int(obj4));
40372 if (SWIG_arg_fail(5)) SWIG_fail;
40373 }
40374 }
40375 if (obj5) {
40376 arg6 = obj5;
40377 }
40378 {
40379 PyThreadState* __tstate = wxPyBeginAllowThreads();
40380 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40381
40382 wxPyEndAllowThreads(__tstate);
40383 if (PyErr_Occurred()) SWIG_fail;
40384 }
40385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40386 return resultobj;
40387 fail:
40388 return NULL;
40389 }
40390
40391
40392 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40393 PyObject *resultobj;
40394 wxSizer *arg1 = (wxSizer *) 0 ;
40395 PyObject *arg2 = (PyObject *) 0 ;
40396 bool result;
40397 PyObject * obj0 = 0 ;
40398 PyObject * obj1 = 0 ;
40399 char *kwnames[] = {
40400 (char *) "self",(char *) "item", NULL
40401 };
40402
40403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40405 if (SWIG_arg_fail(1)) SWIG_fail;
40406 arg2 = obj1;
40407 {
40408 PyThreadState* __tstate = wxPyBeginAllowThreads();
40409 result = (bool)wxSizer_Remove(arg1,arg2);
40410
40411 wxPyEndAllowThreads(__tstate);
40412 if (PyErr_Occurred()) SWIG_fail;
40413 }
40414 {
40415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40416 }
40417 return resultobj;
40418 fail:
40419 return NULL;
40420 }
40421
40422
40423 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40424 PyObject *resultobj;
40425 wxSizer *arg1 = (wxSizer *) 0 ;
40426 PyObject *arg2 = (PyObject *) 0 ;
40427 bool result;
40428 PyObject * obj0 = 0 ;
40429 PyObject * obj1 = 0 ;
40430 char *kwnames[] = {
40431 (char *) "self",(char *) "item", NULL
40432 };
40433
40434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40436 if (SWIG_arg_fail(1)) SWIG_fail;
40437 arg2 = obj1;
40438 {
40439 PyThreadState* __tstate = wxPyBeginAllowThreads();
40440 result = (bool)wxSizer_Detach(arg1,arg2);
40441
40442 wxPyEndAllowThreads(__tstate);
40443 if (PyErr_Occurred()) SWIG_fail;
40444 }
40445 {
40446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40447 }
40448 return resultobj;
40449 fail:
40450 return NULL;
40451 }
40452
40453
40454 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40455 PyObject *resultobj;
40456 wxSizer *arg1 = (wxSizer *) 0 ;
40457 PyObject *arg2 = (PyObject *) 0 ;
40458 wxSizerItem *result;
40459 PyObject * obj0 = 0 ;
40460 PyObject * obj1 = 0 ;
40461 char *kwnames[] = {
40462 (char *) "self",(char *) "item", NULL
40463 };
40464
40465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40467 if (SWIG_arg_fail(1)) SWIG_fail;
40468 arg2 = obj1;
40469 {
40470 PyThreadState* __tstate = wxPyBeginAllowThreads();
40471 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40472
40473 wxPyEndAllowThreads(__tstate);
40474 if (PyErr_Occurred()) SWIG_fail;
40475 }
40476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40477 return resultobj;
40478 fail:
40479 return NULL;
40480 }
40481
40482
40483 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40484 PyObject *resultobj;
40485 wxSizer *arg1 = (wxSizer *) 0 ;
40486 PyObject *arg2 = (PyObject *) 0 ;
40487 wxSize *arg3 = 0 ;
40488 wxSize temp3 ;
40489 PyObject * obj0 = 0 ;
40490 PyObject * obj1 = 0 ;
40491 PyObject * obj2 = 0 ;
40492 char *kwnames[] = {
40493 (char *) "self",(char *) "item",(char *) "size", NULL
40494 };
40495
40496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40498 if (SWIG_arg_fail(1)) SWIG_fail;
40499 arg2 = obj1;
40500 {
40501 arg3 = &temp3;
40502 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40503 }
40504 {
40505 PyThreadState* __tstate = wxPyBeginAllowThreads();
40506 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40507
40508 wxPyEndAllowThreads(__tstate);
40509 if (PyErr_Occurred()) SWIG_fail;
40510 }
40511 Py_INCREF(Py_None); resultobj = Py_None;
40512 return resultobj;
40513 fail:
40514 return NULL;
40515 }
40516
40517
40518 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40519 PyObject *resultobj;
40520 wxSizer *arg1 = (wxSizer *) 0 ;
40521 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40522 wxSizerItem *result;
40523 PyObject * obj0 = 0 ;
40524 PyObject * obj1 = 0 ;
40525 char *kwnames[] = {
40526 (char *) "self",(char *) "item", NULL
40527 };
40528
40529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40531 if (SWIG_arg_fail(1)) SWIG_fail;
40532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40533 if (SWIG_arg_fail(2)) SWIG_fail;
40534 {
40535 PyThreadState* __tstate = wxPyBeginAllowThreads();
40536 result = (wxSizerItem *)(arg1)->Add(arg2);
40537
40538 wxPyEndAllowThreads(__tstate);
40539 if (PyErr_Occurred()) SWIG_fail;
40540 }
40541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40542 return resultobj;
40543 fail:
40544 return NULL;
40545 }
40546
40547
40548 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40549 PyObject *resultobj;
40550 wxSizer *arg1 = (wxSizer *) 0 ;
40551 size_t arg2 ;
40552 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40553 wxSizerItem *result;
40554 PyObject * obj0 = 0 ;
40555 PyObject * obj1 = 0 ;
40556 PyObject * obj2 = 0 ;
40557 char *kwnames[] = {
40558 (char *) "self",(char *) "index",(char *) "item", NULL
40559 };
40560
40561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40563 if (SWIG_arg_fail(1)) SWIG_fail;
40564 {
40565 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40566 if (SWIG_arg_fail(2)) SWIG_fail;
40567 }
40568 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40569 if (SWIG_arg_fail(3)) SWIG_fail;
40570 {
40571 PyThreadState* __tstate = wxPyBeginAllowThreads();
40572 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40573
40574 wxPyEndAllowThreads(__tstate);
40575 if (PyErr_Occurred()) SWIG_fail;
40576 }
40577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40578 return resultobj;
40579 fail:
40580 return NULL;
40581 }
40582
40583
40584 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40585 PyObject *resultobj;
40586 wxSizer *arg1 = (wxSizer *) 0 ;
40587 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40588 wxSizerItem *result;
40589 PyObject * obj0 = 0 ;
40590 PyObject * obj1 = 0 ;
40591 char *kwnames[] = {
40592 (char *) "self",(char *) "item", NULL
40593 };
40594
40595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40597 if (SWIG_arg_fail(1)) SWIG_fail;
40598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40599 if (SWIG_arg_fail(2)) SWIG_fail;
40600 {
40601 PyThreadState* __tstate = wxPyBeginAllowThreads();
40602 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40603
40604 wxPyEndAllowThreads(__tstate);
40605 if (PyErr_Occurred()) SWIG_fail;
40606 }
40607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40608 return resultobj;
40609 fail:
40610 return NULL;
40611 }
40612
40613
40614 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40615 PyObject *resultobj;
40616 wxSizer *arg1 = (wxSizer *) 0 ;
40617 int arg2 ;
40618 int arg3 ;
40619 int arg4 ;
40620 int arg5 ;
40621 PyObject * obj0 = 0 ;
40622 PyObject * obj1 = 0 ;
40623 PyObject * obj2 = 0 ;
40624 PyObject * obj3 = 0 ;
40625 PyObject * obj4 = 0 ;
40626 char *kwnames[] = {
40627 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40628 };
40629
40630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40632 if (SWIG_arg_fail(1)) SWIG_fail;
40633 {
40634 arg2 = (int)(SWIG_As_int(obj1));
40635 if (SWIG_arg_fail(2)) SWIG_fail;
40636 }
40637 {
40638 arg3 = (int)(SWIG_As_int(obj2));
40639 if (SWIG_arg_fail(3)) SWIG_fail;
40640 }
40641 {
40642 arg4 = (int)(SWIG_As_int(obj3));
40643 if (SWIG_arg_fail(4)) SWIG_fail;
40644 }
40645 {
40646 arg5 = (int)(SWIG_As_int(obj4));
40647 if (SWIG_arg_fail(5)) SWIG_fail;
40648 }
40649 {
40650 PyThreadState* __tstate = wxPyBeginAllowThreads();
40651 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40652
40653 wxPyEndAllowThreads(__tstate);
40654 if (PyErr_Occurred()) SWIG_fail;
40655 }
40656 Py_INCREF(Py_None); resultobj = Py_None;
40657 return resultobj;
40658 fail:
40659 return NULL;
40660 }
40661
40662
40663 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40664 PyObject *resultobj;
40665 wxSizer *arg1 = (wxSizer *) 0 ;
40666 wxSize *arg2 = 0 ;
40667 wxSize temp2 ;
40668 PyObject * obj0 = 0 ;
40669 PyObject * obj1 = 0 ;
40670 char *kwnames[] = {
40671 (char *) "self",(char *) "size", NULL
40672 };
40673
40674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40676 if (SWIG_arg_fail(1)) SWIG_fail;
40677 {
40678 arg2 = &temp2;
40679 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40680 }
40681 {
40682 PyThreadState* __tstate = wxPyBeginAllowThreads();
40683 (arg1)->SetMinSize((wxSize const &)*arg2);
40684
40685 wxPyEndAllowThreads(__tstate);
40686 if (PyErr_Occurred()) SWIG_fail;
40687 }
40688 Py_INCREF(Py_None); resultobj = Py_None;
40689 return resultobj;
40690 fail:
40691 return NULL;
40692 }
40693
40694
40695 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40696 PyObject *resultobj;
40697 wxSizer *arg1 = (wxSizer *) 0 ;
40698 wxSize result;
40699 PyObject * obj0 = 0 ;
40700 char *kwnames[] = {
40701 (char *) "self", NULL
40702 };
40703
40704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40706 if (SWIG_arg_fail(1)) SWIG_fail;
40707 {
40708 PyThreadState* __tstate = wxPyBeginAllowThreads();
40709 result = (arg1)->GetSize();
40710
40711 wxPyEndAllowThreads(__tstate);
40712 if (PyErr_Occurred()) SWIG_fail;
40713 }
40714 {
40715 wxSize * resultptr;
40716 resultptr = new wxSize((wxSize &)(result));
40717 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40718 }
40719 return resultobj;
40720 fail:
40721 return NULL;
40722 }
40723
40724
40725 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40726 PyObject *resultobj;
40727 wxSizer *arg1 = (wxSizer *) 0 ;
40728 wxPoint result;
40729 PyObject * obj0 = 0 ;
40730 char *kwnames[] = {
40731 (char *) "self", NULL
40732 };
40733
40734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40736 if (SWIG_arg_fail(1)) SWIG_fail;
40737 {
40738 PyThreadState* __tstate = wxPyBeginAllowThreads();
40739 result = (arg1)->GetPosition();
40740
40741 wxPyEndAllowThreads(__tstate);
40742 if (PyErr_Occurred()) SWIG_fail;
40743 }
40744 {
40745 wxPoint * resultptr;
40746 resultptr = new wxPoint((wxPoint &)(result));
40747 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40748 }
40749 return resultobj;
40750 fail:
40751 return NULL;
40752 }
40753
40754
40755 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40756 PyObject *resultobj;
40757 wxSizer *arg1 = (wxSizer *) 0 ;
40758 wxSize result;
40759 PyObject * obj0 = 0 ;
40760 char *kwnames[] = {
40761 (char *) "self", NULL
40762 };
40763
40764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40766 if (SWIG_arg_fail(1)) SWIG_fail;
40767 {
40768 PyThreadState* __tstate = wxPyBeginAllowThreads();
40769 result = (arg1)->GetMinSize();
40770
40771 wxPyEndAllowThreads(__tstate);
40772 if (PyErr_Occurred()) SWIG_fail;
40773 }
40774 {
40775 wxSize * resultptr;
40776 resultptr = new wxSize((wxSize &)(result));
40777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40778 }
40779 return resultobj;
40780 fail:
40781 return NULL;
40782 }
40783
40784
40785 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40786 PyObject *resultobj;
40787 wxSizer *arg1 = (wxSizer *) 0 ;
40788 PyObject * obj0 = 0 ;
40789 char *kwnames[] = {
40790 (char *) "self", NULL
40791 };
40792
40793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40795 if (SWIG_arg_fail(1)) SWIG_fail;
40796 {
40797 PyThreadState* __tstate = wxPyBeginAllowThreads();
40798 (arg1)->RecalcSizes();
40799
40800 wxPyEndAllowThreads(__tstate);
40801 if (PyErr_Occurred()) SWIG_fail;
40802 }
40803 Py_INCREF(Py_None); resultobj = Py_None;
40804 return resultobj;
40805 fail:
40806 return NULL;
40807 }
40808
40809
40810 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40811 PyObject *resultobj;
40812 wxSizer *arg1 = (wxSizer *) 0 ;
40813 wxSize result;
40814 PyObject * obj0 = 0 ;
40815 char *kwnames[] = {
40816 (char *) "self", NULL
40817 };
40818
40819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40821 if (SWIG_arg_fail(1)) SWIG_fail;
40822 {
40823 PyThreadState* __tstate = wxPyBeginAllowThreads();
40824 result = (arg1)->CalcMin();
40825
40826 wxPyEndAllowThreads(__tstate);
40827 if (PyErr_Occurred()) SWIG_fail;
40828 }
40829 {
40830 wxSize * resultptr;
40831 resultptr = new wxSize((wxSize &)(result));
40832 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40833 }
40834 return resultobj;
40835 fail:
40836 return NULL;
40837 }
40838
40839
40840 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40841 PyObject *resultobj;
40842 wxSizer *arg1 = (wxSizer *) 0 ;
40843 PyObject * obj0 = 0 ;
40844 char *kwnames[] = {
40845 (char *) "self", NULL
40846 };
40847
40848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40850 if (SWIG_arg_fail(1)) SWIG_fail;
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 (arg1)->Layout();
40854
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 Py_INCREF(Py_None); resultobj = Py_None;
40859 return resultobj;
40860 fail:
40861 return NULL;
40862 }
40863
40864
40865 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40866 PyObject *resultobj;
40867 wxSizer *arg1 = (wxSizer *) 0 ;
40868 wxWindow *arg2 = (wxWindow *) 0 ;
40869 wxSize result;
40870 PyObject * obj0 = 0 ;
40871 PyObject * obj1 = 0 ;
40872 char *kwnames[] = {
40873 (char *) "self",(char *) "window", NULL
40874 };
40875
40876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40878 if (SWIG_arg_fail(1)) SWIG_fail;
40879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40880 if (SWIG_arg_fail(2)) SWIG_fail;
40881 {
40882 PyThreadState* __tstate = wxPyBeginAllowThreads();
40883 result = (arg1)->Fit(arg2);
40884
40885 wxPyEndAllowThreads(__tstate);
40886 if (PyErr_Occurred()) SWIG_fail;
40887 }
40888 {
40889 wxSize * resultptr;
40890 resultptr = new wxSize((wxSize &)(result));
40891 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40892 }
40893 return resultobj;
40894 fail:
40895 return NULL;
40896 }
40897
40898
40899 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40900 PyObject *resultobj;
40901 wxSizer *arg1 = (wxSizer *) 0 ;
40902 wxWindow *arg2 = (wxWindow *) 0 ;
40903 PyObject * obj0 = 0 ;
40904 PyObject * obj1 = 0 ;
40905 char *kwnames[] = {
40906 (char *) "self",(char *) "window", NULL
40907 };
40908
40909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40911 if (SWIG_arg_fail(1)) SWIG_fail;
40912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40913 if (SWIG_arg_fail(2)) SWIG_fail;
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 (arg1)->FitInside(arg2);
40917
40918 wxPyEndAllowThreads(__tstate);
40919 if (PyErr_Occurred()) SWIG_fail;
40920 }
40921 Py_INCREF(Py_None); resultobj = Py_None;
40922 return resultobj;
40923 fail:
40924 return NULL;
40925 }
40926
40927
40928 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40929 PyObject *resultobj;
40930 wxSizer *arg1 = (wxSizer *) 0 ;
40931 wxWindow *arg2 = (wxWindow *) 0 ;
40932 PyObject * obj0 = 0 ;
40933 PyObject * obj1 = 0 ;
40934 char *kwnames[] = {
40935 (char *) "self",(char *) "window", NULL
40936 };
40937
40938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40940 if (SWIG_arg_fail(1)) SWIG_fail;
40941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40942 if (SWIG_arg_fail(2)) SWIG_fail;
40943 {
40944 PyThreadState* __tstate = wxPyBeginAllowThreads();
40945 (arg1)->SetSizeHints(arg2);
40946
40947 wxPyEndAllowThreads(__tstate);
40948 if (PyErr_Occurred()) SWIG_fail;
40949 }
40950 Py_INCREF(Py_None); resultobj = Py_None;
40951 return resultobj;
40952 fail:
40953 return NULL;
40954 }
40955
40956
40957 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40958 PyObject *resultobj;
40959 wxSizer *arg1 = (wxSizer *) 0 ;
40960 wxWindow *arg2 = (wxWindow *) 0 ;
40961 PyObject * obj0 = 0 ;
40962 PyObject * obj1 = 0 ;
40963 char *kwnames[] = {
40964 (char *) "self",(char *) "window", NULL
40965 };
40966
40967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40969 if (SWIG_arg_fail(1)) SWIG_fail;
40970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40971 if (SWIG_arg_fail(2)) SWIG_fail;
40972 {
40973 PyThreadState* __tstate = wxPyBeginAllowThreads();
40974 (arg1)->SetVirtualSizeHints(arg2);
40975
40976 wxPyEndAllowThreads(__tstate);
40977 if (PyErr_Occurred()) SWIG_fail;
40978 }
40979 Py_INCREF(Py_None); resultobj = Py_None;
40980 return resultobj;
40981 fail:
40982 return NULL;
40983 }
40984
40985
40986 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40987 PyObject *resultobj;
40988 wxSizer *arg1 = (wxSizer *) 0 ;
40989 bool arg2 = (bool) false ;
40990 PyObject * obj0 = 0 ;
40991 PyObject * obj1 = 0 ;
40992 char *kwnames[] = {
40993 (char *) "self",(char *) "deleteWindows", NULL
40994 };
40995
40996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40998 if (SWIG_arg_fail(1)) SWIG_fail;
40999 if (obj1) {
41000 {
41001 arg2 = (bool)(SWIG_As_bool(obj1));
41002 if (SWIG_arg_fail(2)) SWIG_fail;
41003 }
41004 }
41005 {
41006 PyThreadState* __tstate = wxPyBeginAllowThreads();
41007 (arg1)->Clear(arg2);
41008
41009 wxPyEndAllowThreads(__tstate);
41010 if (PyErr_Occurred()) SWIG_fail;
41011 }
41012 Py_INCREF(Py_None); resultobj = Py_None;
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj;
41021 wxSizer *arg1 = (wxSizer *) 0 ;
41022 PyObject * obj0 = 0 ;
41023 char *kwnames[] = {
41024 (char *) "self", NULL
41025 };
41026
41027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41029 if (SWIG_arg_fail(1)) SWIG_fail;
41030 {
41031 PyThreadState* __tstate = wxPyBeginAllowThreads();
41032 (arg1)->DeleteWindows();
41033
41034 wxPyEndAllowThreads(__tstate);
41035 if (PyErr_Occurred()) SWIG_fail;
41036 }
41037 Py_INCREF(Py_None); resultobj = Py_None;
41038 return resultobj;
41039 fail:
41040 return NULL;
41041 }
41042
41043
41044 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41045 PyObject *resultobj;
41046 wxSizer *arg1 = (wxSizer *) 0 ;
41047 PyObject *result;
41048 PyObject * obj0 = 0 ;
41049 char *kwnames[] = {
41050 (char *) "self", NULL
41051 };
41052
41053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41055 if (SWIG_arg_fail(1)) SWIG_fail;
41056 {
41057 PyThreadState* __tstate = wxPyBeginAllowThreads();
41058 result = (PyObject *)wxSizer_GetChildren(arg1);
41059
41060 wxPyEndAllowThreads(__tstate);
41061 if (PyErr_Occurred()) SWIG_fail;
41062 }
41063 resultobj = result;
41064 return resultobj;
41065 fail:
41066 return NULL;
41067 }
41068
41069
41070 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41071 PyObject *resultobj;
41072 wxSizer *arg1 = (wxSizer *) 0 ;
41073 PyObject *arg2 = (PyObject *) 0 ;
41074 bool arg3 = (bool) true ;
41075 bool arg4 = (bool) false ;
41076 bool result;
41077 PyObject * obj0 = 0 ;
41078 PyObject * obj1 = 0 ;
41079 PyObject * obj2 = 0 ;
41080 PyObject * obj3 = 0 ;
41081 char *kwnames[] = {
41082 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41083 };
41084
41085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41087 if (SWIG_arg_fail(1)) SWIG_fail;
41088 arg2 = obj1;
41089 if (obj2) {
41090 {
41091 arg3 = (bool)(SWIG_As_bool(obj2));
41092 if (SWIG_arg_fail(3)) SWIG_fail;
41093 }
41094 }
41095 if (obj3) {
41096 {
41097 arg4 = (bool)(SWIG_As_bool(obj3));
41098 if (SWIG_arg_fail(4)) SWIG_fail;
41099 }
41100 }
41101 {
41102 PyThreadState* __tstate = wxPyBeginAllowThreads();
41103 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41104
41105 wxPyEndAllowThreads(__tstate);
41106 if (PyErr_Occurred()) SWIG_fail;
41107 }
41108 {
41109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41110 }
41111 return resultobj;
41112 fail:
41113 return NULL;
41114 }
41115
41116
41117 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41118 PyObject *resultobj;
41119 wxSizer *arg1 = (wxSizer *) 0 ;
41120 PyObject *arg2 = (PyObject *) 0 ;
41121 bool result;
41122 PyObject * obj0 = 0 ;
41123 PyObject * obj1 = 0 ;
41124 char *kwnames[] = {
41125 (char *) "self",(char *) "item", NULL
41126 };
41127
41128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41130 if (SWIG_arg_fail(1)) SWIG_fail;
41131 arg2 = obj1;
41132 {
41133 PyThreadState* __tstate = wxPyBeginAllowThreads();
41134 result = (bool)wxSizer_IsShown(arg1,arg2);
41135
41136 wxPyEndAllowThreads(__tstate);
41137 if (PyErr_Occurred()) SWIG_fail;
41138 }
41139 {
41140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41141 }
41142 return resultobj;
41143 fail:
41144 return NULL;
41145 }
41146
41147
41148 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41149 PyObject *resultobj;
41150 wxSizer *arg1 = (wxSizer *) 0 ;
41151 bool arg2 ;
41152 PyObject * obj0 = 0 ;
41153 PyObject * obj1 = 0 ;
41154 char *kwnames[] = {
41155 (char *) "self",(char *) "show", NULL
41156 };
41157
41158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41160 if (SWIG_arg_fail(1)) SWIG_fail;
41161 {
41162 arg2 = (bool)(SWIG_As_bool(obj1));
41163 if (SWIG_arg_fail(2)) SWIG_fail;
41164 }
41165 {
41166 PyThreadState* __tstate = wxPyBeginAllowThreads();
41167 (arg1)->ShowItems(arg2);
41168
41169 wxPyEndAllowThreads(__tstate);
41170 if (PyErr_Occurred()) SWIG_fail;
41171 }
41172 Py_INCREF(Py_None); resultobj = Py_None;
41173 return resultobj;
41174 fail:
41175 return NULL;
41176 }
41177
41178
41179 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41180 PyObject *obj;
41181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41182 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41183 Py_INCREF(obj);
41184 return Py_BuildValue((char *)"");
41185 }
41186 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41187 PyObject *resultobj;
41188 wxPySizer *result;
41189 char *kwnames[] = {
41190 NULL
41191 };
41192
41193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41194 {
41195 PyThreadState* __tstate = wxPyBeginAllowThreads();
41196 result = (wxPySizer *)new wxPySizer();
41197
41198 wxPyEndAllowThreads(__tstate);
41199 if (PyErr_Occurred()) SWIG_fail;
41200 }
41201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41202 return resultobj;
41203 fail:
41204 return NULL;
41205 }
41206
41207
41208 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41209 PyObject *resultobj;
41210 wxPySizer *arg1 = (wxPySizer *) 0 ;
41211 PyObject *arg2 = (PyObject *) 0 ;
41212 PyObject *arg3 = (PyObject *) 0 ;
41213 PyObject * obj0 = 0 ;
41214 PyObject * obj1 = 0 ;
41215 PyObject * obj2 = 0 ;
41216 char *kwnames[] = {
41217 (char *) "self",(char *) "self",(char *) "_class", NULL
41218 };
41219
41220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41222 if (SWIG_arg_fail(1)) SWIG_fail;
41223 arg2 = obj1;
41224 arg3 = obj2;
41225 {
41226 PyThreadState* __tstate = wxPyBeginAllowThreads();
41227 (arg1)->_setCallbackInfo(arg2,arg3);
41228
41229 wxPyEndAllowThreads(__tstate);
41230 if (PyErr_Occurred()) SWIG_fail;
41231 }
41232 Py_INCREF(Py_None); resultobj = Py_None;
41233 return resultobj;
41234 fail:
41235 return NULL;
41236 }
41237
41238
41239 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41240 PyObject *obj;
41241 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41242 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41243 Py_INCREF(obj);
41244 return Py_BuildValue((char *)"");
41245 }
41246 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41247 PyObject *resultobj;
41248 int arg1 = (int) wxHORIZONTAL ;
41249 wxBoxSizer *result;
41250 PyObject * obj0 = 0 ;
41251 char *kwnames[] = {
41252 (char *) "orient", NULL
41253 };
41254
41255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41256 if (obj0) {
41257 {
41258 arg1 = (int)(SWIG_As_int(obj0));
41259 if (SWIG_arg_fail(1)) SWIG_fail;
41260 }
41261 }
41262 {
41263 PyThreadState* __tstate = wxPyBeginAllowThreads();
41264 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41265
41266 wxPyEndAllowThreads(__tstate);
41267 if (PyErr_Occurred()) SWIG_fail;
41268 }
41269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41270 return resultobj;
41271 fail:
41272 return NULL;
41273 }
41274
41275
41276 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41277 PyObject *resultobj;
41278 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41279 int result;
41280 PyObject * obj0 = 0 ;
41281 char *kwnames[] = {
41282 (char *) "self", NULL
41283 };
41284
41285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41287 if (SWIG_arg_fail(1)) SWIG_fail;
41288 {
41289 PyThreadState* __tstate = wxPyBeginAllowThreads();
41290 result = (int)(arg1)->GetOrientation();
41291
41292 wxPyEndAllowThreads(__tstate);
41293 if (PyErr_Occurred()) SWIG_fail;
41294 }
41295 {
41296 resultobj = SWIG_From_int((int)(result));
41297 }
41298 return resultobj;
41299 fail:
41300 return NULL;
41301 }
41302
41303
41304 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41305 PyObject *resultobj;
41306 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41307 int arg2 ;
41308 PyObject * obj0 = 0 ;
41309 PyObject * obj1 = 0 ;
41310 char *kwnames[] = {
41311 (char *) "self",(char *) "orient", NULL
41312 };
41313
41314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41316 if (SWIG_arg_fail(1)) SWIG_fail;
41317 {
41318 arg2 = (int)(SWIG_As_int(obj1));
41319 if (SWIG_arg_fail(2)) SWIG_fail;
41320 }
41321 {
41322 PyThreadState* __tstate = wxPyBeginAllowThreads();
41323 (arg1)->SetOrientation(arg2);
41324
41325 wxPyEndAllowThreads(__tstate);
41326 if (PyErr_Occurred()) SWIG_fail;
41327 }
41328 Py_INCREF(Py_None); resultobj = Py_None;
41329 return resultobj;
41330 fail:
41331 return NULL;
41332 }
41333
41334
41335 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41336 PyObject *obj;
41337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41338 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41339 Py_INCREF(obj);
41340 return Py_BuildValue((char *)"");
41341 }
41342 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41343 PyObject *resultobj;
41344 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41345 int arg2 = (int) wxHORIZONTAL ;
41346 wxStaticBoxSizer *result;
41347 PyObject * obj0 = 0 ;
41348 PyObject * obj1 = 0 ;
41349 char *kwnames[] = {
41350 (char *) "box",(char *) "orient", NULL
41351 };
41352
41353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41355 if (SWIG_arg_fail(1)) SWIG_fail;
41356 if (obj1) {
41357 {
41358 arg2 = (int)(SWIG_As_int(obj1));
41359 if (SWIG_arg_fail(2)) SWIG_fail;
41360 }
41361 }
41362 {
41363 PyThreadState* __tstate = wxPyBeginAllowThreads();
41364 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41365
41366 wxPyEndAllowThreads(__tstate);
41367 if (PyErr_Occurred()) SWIG_fail;
41368 }
41369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41370 return resultobj;
41371 fail:
41372 return NULL;
41373 }
41374
41375
41376 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41377 PyObject *resultobj;
41378 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41379 wxStaticBox *result;
41380 PyObject * obj0 = 0 ;
41381 char *kwnames[] = {
41382 (char *) "self", NULL
41383 };
41384
41385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41387 if (SWIG_arg_fail(1)) SWIG_fail;
41388 {
41389 PyThreadState* __tstate = wxPyBeginAllowThreads();
41390 result = (wxStaticBox *)(arg1)->GetStaticBox();
41391
41392 wxPyEndAllowThreads(__tstate);
41393 if (PyErr_Occurred()) SWIG_fail;
41394 }
41395 {
41396 resultobj = wxPyMake_wxObject(result, 0);
41397 }
41398 return resultobj;
41399 fail:
41400 return NULL;
41401 }
41402
41403
41404 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41405 PyObject *obj;
41406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41407 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41408 Py_INCREF(obj);
41409 return Py_BuildValue((char *)"");
41410 }
41411 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41412 PyObject *resultobj;
41413 int arg1 = (int) 1 ;
41414 int arg2 = (int) 0 ;
41415 int arg3 = (int) 0 ;
41416 int arg4 = (int) 0 ;
41417 wxGridSizer *result;
41418 PyObject * obj0 = 0 ;
41419 PyObject * obj1 = 0 ;
41420 PyObject * obj2 = 0 ;
41421 PyObject * obj3 = 0 ;
41422 char *kwnames[] = {
41423 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41424 };
41425
41426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41427 if (obj0) {
41428 {
41429 arg1 = (int)(SWIG_As_int(obj0));
41430 if (SWIG_arg_fail(1)) SWIG_fail;
41431 }
41432 }
41433 if (obj1) {
41434 {
41435 arg2 = (int)(SWIG_As_int(obj1));
41436 if (SWIG_arg_fail(2)) SWIG_fail;
41437 }
41438 }
41439 if (obj2) {
41440 {
41441 arg3 = (int)(SWIG_As_int(obj2));
41442 if (SWIG_arg_fail(3)) SWIG_fail;
41443 }
41444 }
41445 if (obj3) {
41446 {
41447 arg4 = (int)(SWIG_As_int(obj3));
41448 if (SWIG_arg_fail(4)) SWIG_fail;
41449 }
41450 }
41451 {
41452 PyThreadState* __tstate = wxPyBeginAllowThreads();
41453 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41454
41455 wxPyEndAllowThreads(__tstate);
41456 if (PyErr_Occurred()) SWIG_fail;
41457 }
41458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41459 return resultobj;
41460 fail:
41461 return NULL;
41462 }
41463
41464
41465 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41466 PyObject *resultobj;
41467 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41468 int arg2 ;
41469 PyObject * obj0 = 0 ;
41470 PyObject * obj1 = 0 ;
41471 char *kwnames[] = {
41472 (char *) "self",(char *) "cols", NULL
41473 };
41474
41475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41477 if (SWIG_arg_fail(1)) SWIG_fail;
41478 {
41479 arg2 = (int)(SWIG_As_int(obj1));
41480 if (SWIG_arg_fail(2)) SWIG_fail;
41481 }
41482 {
41483 PyThreadState* __tstate = wxPyBeginAllowThreads();
41484 (arg1)->SetCols(arg2);
41485
41486 wxPyEndAllowThreads(__tstate);
41487 if (PyErr_Occurred()) SWIG_fail;
41488 }
41489 Py_INCREF(Py_None); resultobj = Py_None;
41490 return resultobj;
41491 fail:
41492 return NULL;
41493 }
41494
41495
41496 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41497 PyObject *resultobj;
41498 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41499 int arg2 ;
41500 PyObject * obj0 = 0 ;
41501 PyObject * obj1 = 0 ;
41502 char *kwnames[] = {
41503 (char *) "self",(char *) "rows", NULL
41504 };
41505
41506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41508 if (SWIG_arg_fail(1)) SWIG_fail;
41509 {
41510 arg2 = (int)(SWIG_As_int(obj1));
41511 if (SWIG_arg_fail(2)) SWIG_fail;
41512 }
41513 {
41514 PyThreadState* __tstate = wxPyBeginAllowThreads();
41515 (arg1)->SetRows(arg2);
41516
41517 wxPyEndAllowThreads(__tstate);
41518 if (PyErr_Occurred()) SWIG_fail;
41519 }
41520 Py_INCREF(Py_None); resultobj = Py_None;
41521 return resultobj;
41522 fail:
41523 return NULL;
41524 }
41525
41526
41527 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41528 PyObject *resultobj;
41529 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41530 int arg2 ;
41531 PyObject * obj0 = 0 ;
41532 PyObject * obj1 = 0 ;
41533 char *kwnames[] = {
41534 (char *) "self",(char *) "gap", NULL
41535 };
41536
41537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41539 if (SWIG_arg_fail(1)) SWIG_fail;
41540 {
41541 arg2 = (int)(SWIG_As_int(obj1));
41542 if (SWIG_arg_fail(2)) SWIG_fail;
41543 }
41544 {
41545 PyThreadState* __tstate = wxPyBeginAllowThreads();
41546 (arg1)->SetVGap(arg2);
41547
41548 wxPyEndAllowThreads(__tstate);
41549 if (PyErr_Occurred()) SWIG_fail;
41550 }
41551 Py_INCREF(Py_None); resultobj = Py_None;
41552 return resultobj;
41553 fail:
41554 return NULL;
41555 }
41556
41557
41558 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41559 PyObject *resultobj;
41560 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41561 int arg2 ;
41562 PyObject * obj0 = 0 ;
41563 PyObject * obj1 = 0 ;
41564 char *kwnames[] = {
41565 (char *) "self",(char *) "gap", NULL
41566 };
41567
41568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41570 if (SWIG_arg_fail(1)) SWIG_fail;
41571 {
41572 arg2 = (int)(SWIG_As_int(obj1));
41573 if (SWIG_arg_fail(2)) SWIG_fail;
41574 }
41575 {
41576 PyThreadState* __tstate = wxPyBeginAllowThreads();
41577 (arg1)->SetHGap(arg2);
41578
41579 wxPyEndAllowThreads(__tstate);
41580 if (PyErr_Occurred()) SWIG_fail;
41581 }
41582 Py_INCREF(Py_None); resultobj = Py_None;
41583 return resultobj;
41584 fail:
41585 return NULL;
41586 }
41587
41588
41589 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41590 PyObject *resultobj;
41591 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41592 int result;
41593 PyObject * obj0 = 0 ;
41594 char *kwnames[] = {
41595 (char *) "self", NULL
41596 };
41597
41598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41600 if (SWIG_arg_fail(1)) SWIG_fail;
41601 {
41602 PyThreadState* __tstate = wxPyBeginAllowThreads();
41603 result = (int)(arg1)->GetCols();
41604
41605 wxPyEndAllowThreads(__tstate);
41606 if (PyErr_Occurred()) SWIG_fail;
41607 }
41608 {
41609 resultobj = SWIG_From_int((int)(result));
41610 }
41611 return resultobj;
41612 fail:
41613 return NULL;
41614 }
41615
41616
41617 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41618 PyObject *resultobj;
41619 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41620 int result;
41621 PyObject * obj0 = 0 ;
41622 char *kwnames[] = {
41623 (char *) "self", NULL
41624 };
41625
41626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41628 if (SWIG_arg_fail(1)) SWIG_fail;
41629 {
41630 PyThreadState* __tstate = wxPyBeginAllowThreads();
41631 result = (int)(arg1)->GetRows();
41632
41633 wxPyEndAllowThreads(__tstate);
41634 if (PyErr_Occurred()) SWIG_fail;
41635 }
41636 {
41637 resultobj = SWIG_From_int((int)(result));
41638 }
41639 return resultobj;
41640 fail:
41641 return NULL;
41642 }
41643
41644
41645 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41646 PyObject *resultobj;
41647 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41648 int result;
41649 PyObject * obj0 = 0 ;
41650 char *kwnames[] = {
41651 (char *) "self", NULL
41652 };
41653
41654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41656 if (SWIG_arg_fail(1)) SWIG_fail;
41657 {
41658 PyThreadState* __tstate = wxPyBeginAllowThreads();
41659 result = (int)(arg1)->GetVGap();
41660
41661 wxPyEndAllowThreads(__tstate);
41662 if (PyErr_Occurred()) SWIG_fail;
41663 }
41664 {
41665 resultobj = SWIG_From_int((int)(result));
41666 }
41667 return resultobj;
41668 fail:
41669 return NULL;
41670 }
41671
41672
41673 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41674 PyObject *resultobj;
41675 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41676 int result;
41677 PyObject * obj0 = 0 ;
41678 char *kwnames[] = {
41679 (char *) "self", NULL
41680 };
41681
41682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41684 if (SWIG_arg_fail(1)) SWIG_fail;
41685 {
41686 PyThreadState* __tstate = wxPyBeginAllowThreads();
41687 result = (int)(arg1)->GetHGap();
41688
41689 wxPyEndAllowThreads(__tstate);
41690 if (PyErr_Occurred()) SWIG_fail;
41691 }
41692 {
41693 resultobj = SWIG_From_int((int)(result));
41694 }
41695 return resultobj;
41696 fail:
41697 return NULL;
41698 }
41699
41700
41701 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41702 PyObject *obj;
41703 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41704 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41705 Py_INCREF(obj);
41706 return Py_BuildValue((char *)"");
41707 }
41708 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41709 PyObject *resultobj;
41710 int arg1 = (int) 1 ;
41711 int arg2 = (int) 0 ;
41712 int arg3 = (int) 0 ;
41713 int arg4 = (int) 0 ;
41714 wxFlexGridSizer *result;
41715 PyObject * obj0 = 0 ;
41716 PyObject * obj1 = 0 ;
41717 PyObject * obj2 = 0 ;
41718 PyObject * obj3 = 0 ;
41719 char *kwnames[] = {
41720 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41721 };
41722
41723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41724 if (obj0) {
41725 {
41726 arg1 = (int)(SWIG_As_int(obj0));
41727 if (SWIG_arg_fail(1)) SWIG_fail;
41728 }
41729 }
41730 if (obj1) {
41731 {
41732 arg2 = (int)(SWIG_As_int(obj1));
41733 if (SWIG_arg_fail(2)) SWIG_fail;
41734 }
41735 }
41736 if (obj2) {
41737 {
41738 arg3 = (int)(SWIG_As_int(obj2));
41739 if (SWIG_arg_fail(3)) SWIG_fail;
41740 }
41741 }
41742 if (obj3) {
41743 {
41744 arg4 = (int)(SWIG_As_int(obj3));
41745 if (SWIG_arg_fail(4)) SWIG_fail;
41746 }
41747 }
41748 {
41749 PyThreadState* __tstate = wxPyBeginAllowThreads();
41750 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41751
41752 wxPyEndAllowThreads(__tstate);
41753 if (PyErr_Occurred()) SWIG_fail;
41754 }
41755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41756 return resultobj;
41757 fail:
41758 return NULL;
41759 }
41760
41761
41762 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41763 PyObject *resultobj;
41764 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41765 size_t arg2 ;
41766 int arg3 = (int) 0 ;
41767 PyObject * obj0 = 0 ;
41768 PyObject * obj1 = 0 ;
41769 PyObject * obj2 = 0 ;
41770 char *kwnames[] = {
41771 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41772 };
41773
41774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41776 if (SWIG_arg_fail(1)) SWIG_fail;
41777 {
41778 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41779 if (SWIG_arg_fail(2)) SWIG_fail;
41780 }
41781 if (obj2) {
41782 {
41783 arg3 = (int)(SWIG_As_int(obj2));
41784 if (SWIG_arg_fail(3)) SWIG_fail;
41785 }
41786 }
41787 {
41788 PyThreadState* __tstate = wxPyBeginAllowThreads();
41789 (arg1)->AddGrowableRow(arg2,arg3);
41790
41791 wxPyEndAllowThreads(__tstate);
41792 if (PyErr_Occurred()) SWIG_fail;
41793 }
41794 Py_INCREF(Py_None); resultobj = Py_None;
41795 return resultobj;
41796 fail:
41797 return NULL;
41798 }
41799
41800
41801 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41802 PyObject *resultobj;
41803 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41804 size_t arg2 ;
41805 PyObject * obj0 = 0 ;
41806 PyObject * obj1 = 0 ;
41807 char *kwnames[] = {
41808 (char *) "self",(char *) "idx", NULL
41809 };
41810
41811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41813 if (SWIG_arg_fail(1)) SWIG_fail;
41814 {
41815 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41816 if (SWIG_arg_fail(2)) SWIG_fail;
41817 }
41818 {
41819 PyThreadState* __tstate = wxPyBeginAllowThreads();
41820 (arg1)->RemoveGrowableRow(arg2);
41821
41822 wxPyEndAllowThreads(__tstate);
41823 if (PyErr_Occurred()) SWIG_fail;
41824 }
41825 Py_INCREF(Py_None); resultobj = Py_None;
41826 return resultobj;
41827 fail:
41828 return NULL;
41829 }
41830
41831
41832 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41833 PyObject *resultobj;
41834 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41835 size_t arg2 ;
41836 int arg3 = (int) 0 ;
41837 PyObject * obj0 = 0 ;
41838 PyObject * obj1 = 0 ;
41839 PyObject * obj2 = 0 ;
41840 char *kwnames[] = {
41841 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41842 };
41843
41844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41846 if (SWIG_arg_fail(1)) SWIG_fail;
41847 {
41848 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41849 if (SWIG_arg_fail(2)) SWIG_fail;
41850 }
41851 if (obj2) {
41852 {
41853 arg3 = (int)(SWIG_As_int(obj2));
41854 if (SWIG_arg_fail(3)) SWIG_fail;
41855 }
41856 }
41857 {
41858 PyThreadState* __tstate = wxPyBeginAllowThreads();
41859 (arg1)->AddGrowableCol(arg2,arg3);
41860
41861 wxPyEndAllowThreads(__tstate);
41862 if (PyErr_Occurred()) SWIG_fail;
41863 }
41864 Py_INCREF(Py_None); resultobj = Py_None;
41865 return resultobj;
41866 fail:
41867 return NULL;
41868 }
41869
41870
41871 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41872 PyObject *resultobj;
41873 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41874 size_t arg2 ;
41875 PyObject * obj0 = 0 ;
41876 PyObject * obj1 = 0 ;
41877 char *kwnames[] = {
41878 (char *) "self",(char *) "idx", NULL
41879 };
41880
41881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41883 if (SWIG_arg_fail(1)) SWIG_fail;
41884 {
41885 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41886 if (SWIG_arg_fail(2)) SWIG_fail;
41887 }
41888 {
41889 PyThreadState* __tstate = wxPyBeginAllowThreads();
41890 (arg1)->RemoveGrowableCol(arg2);
41891
41892 wxPyEndAllowThreads(__tstate);
41893 if (PyErr_Occurred()) SWIG_fail;
41894 }
41895 Py_INCREF(Py_None); resultobj = Py_None;
41896 return resultobj;
41897 fail:
41898 return NULL;
41899 }
41900
41901
41902 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41903 PyObject *resultobj;
41904 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41905 int arg2 ;
41906 PyObject * obj0 = 0 ;
41907 PyObject * obj1 = 0 ;
41908 char *kwnames[] = {
41909 (char *) "self",(char *) "direction", NULL
41910 };
41911
41912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41914 if (SWIG_arg_fail(1)) SWIG_fail;
41915 {
41916 arg2 = (int)(SWIG_As_int(obj1));
41917 if (SWIG_arg_fail(2)) SWIG_fail;
41918 }
41919 {
41920 PyThreadState* __tstate = wxPyBeginAllowThreads();
41921 (arg1)->SetFlexibleDirection(arg2);
41922
41923 wxPyEndAllowThreads(__tstate);
41924 if (PyErr_Occurred()) SWIG_fail;
41925 }
41926 Py_INCREF(Py_None); resultobj = Py_None;
41927 return resultobj;
41928 fail:
41929 return NULL;
41930 }
41931
41932
41933 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41934 PyObject *resultobj;
41935 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41936 int result;
41937 PyObject * obj0 = 0 ;
41938 char *kwnames[] = {
41939 (char *) "self", NULL
41940 };
41941
41942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41944 if (SWIG_arg_fail(1)) SWIG_fail;
41945 {
41946 PyThreadState* __tstate = wxPyBeginAllowThreads();
41947 result = (int)(arg1)->GetFlexibleDirection();
41948
41949 wxPyEndAllowThreads(__tstate);
41950 if (PyErr_Occurred()) SWIG_fail;
41951 }
41952 {
41953 resultobj = SWIG_From_int((int)(result));
41954 }
41955 return resultobj;
41956 fail:
41957 return NULL;
41958 }
41959
41960
41961 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41962 PyObject *resultobj;
41963 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41964 wxFlexSizerGrowMode arg2 ;
41965 PyObject * obj0 = 0 ;
41966 PyObject * obj1 = 0 ;
41967 char *kwnames[] = {
41968 (char *) "self",(char *) "mode", NULL
41969 };
41970
41971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41973 if (SWIG_arg_fail(1)) SWIG_fail;
41974 {
41975 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41976 if (SWIG_arg_fail(2)) SWIG_fail;
41977 }
41978 {
41979 PyThreadState* __tstate = wxPyBeginAllowThreads();
41980 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41981
41982 wxPyEndAllowThreads(__tstate);
41983 if (PyErr_Occurred()) SWIG_fail;
41984 }
41985 Py_INCREF(Py_None); resultobj = Py_None;
41986 return resultobj;
41987 fail:
41988 return NULL;
41989 }
41990
41991
41992 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41993 PyObject *resultobj;
41994 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41995 wxFlexSizerGrowMode result;
41996 PyObject * obj0 = 0 ;
41997 char *kwnames[] = {
41998 (char *) "self", NULL
41999 };
42000
42001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42003 if (SWIG_arg_fail(1)) SWIG_fail;
42004 {
42005 PyThreadState* __tstate = wxPyBeginAllowThreads();
42006 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42007
42008 wxPyEndAllowThreads(__tstate);
42009 if (PyErr_Occurred()) SWIG_fail;
42010 }
42011 resultobj = SWIG_From_int((result));
42012 return resultobj;
42013 fail:
42014 return NULL;
42015 }
42016
42017
42018 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42019 PyObject *resultobj;
42020 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42021 wxArrayInt *result;
42022 PyObject * obj0 = 0 ;
42023 char *kwnames[] = {
42024 (char *) "self", NULL
42025 };
42026
42027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42029 if (SWIG_arg_fail(1)) SWIG_fail;
42030 {
42031 PyThreadState* __tstate = wxPyBeginAllowThreads();
42032 {
42033 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42034 result = (wxArrayInt *) &_result_ref;
42035 }
42036
42037 wxPyEndAllowThreads(__tstate);
42038 if (PyErr_Occurred()) SWIG_fail;
42039 }
42040 {
42041 resultobj = PyList_New(0);
42042 size_t idx;
42043 for (idx = 0; idx < result->GetCount(); idx += 1) {
42044 PyObject* val = PyInt_FromLong( result->Item(idx) );
42045 PyList_Append(resultobj, val);
42046 Py_DECREF(val);
42047 }
42048 }
42049 return resultobj;
42050 fail:
42051 return NULL;
42052 }
42053
42054
42055 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42056 PyObject *resultobj;
42057 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42058 wxArrayInt *result;
42059 PyObject * obj0 = 0 ;
42060 char *kwnames[] = {
42061 (char *) "self", NULL
42062 };
42063
42064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42066 if (SWIG_arg_fail(1)) SWIG_fail;
42067 {
42068 PyThreadState* __tstate = wxPyBeginAllowThreads();
42069 {
42070 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42071 result = (wxArrayInt *) &_result_ref;
42072 }
42073
42074 wxPyEndAllowThreads(__tstate);
42075 if (PyErr_Occurred()) SWIG_fail;
42076 }
42077 {
42078 resultobj = PyList_New(0);
42079 size_t idx;
42080 for (idx = 0; idx < result->GetCount(); idx += 1) {
42081 PyObject* val = PyInt_FromLong( result->Item(idx) );
42082 PyList_Append(resultobj, val);
42083 Py_DECREF(val);
42084 }
42085 }
42086 return resultobj;
42087 fail:
42088 return NULL;
42089 }
42090
42091
42092 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42093 PyObject *obj;
42094 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42095 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42096 Py_INCREF(obj);
42097 return Py_BuildValue((char *)"");
42098 }
42099 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42100 PyObject *resultobj;
42101 wxStdDialogButtonSizer *result;
42102 char *kwnames[] = {
42103 NULL
42104 };
42105
42106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42107 {
42108 PyThreadState* __tstate = wxPyBeginAllowThreads();
42109 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42110
42111 wxPyEndAllowThreads(__tstate);
42112 if (PyErr_Occurred()) SWIG_fail;
42113 }
42114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42115 return resultobj;
42116 fail:
42117 return NULL;
42118 }
42119
42120
42121 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42122 PyObject *resultobj;
42123 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42124 wxButton *arg2 = (wxButton *) 0 ;
42125 PyObject * obj0 = 0 ;
42126 PyObject * obj1 = 0 ;
42127 char *kwnames[] = {
42128 (char *) "self",(char *) "button", NULL
42129 };
42130
42131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42133 if (SWIG_arg_fail(1)) SWIG_fail;
42134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42135 if (SWIG_arg_fail(2)) SWIG_fail;
42136 {
42137 PyThreadState* __tstate = wxPyBeginAllowThreads();
42138 (arg1)->AddButton(arg2);
42139
42140 wxPyEndAllowThreads(__tstate);
42141 if (PyErr_Occurred()) SWIG_fail;
42142 }
42143 Py_INCREF(Py_None); resultobj = Py_None;
42144 return resultobj;
42145 fail:
42146 return NULL;
42147 }
42148
42149
42150 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42151 PyObject *resultobj;
42152 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42153 PyObject * obj0 = 0 ;
42154 char *kwnames[] = {
42155 (char *) "self", NULL
42156 };
42157
42158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42160 if (SWIG_arg_fail(1)) SWIG_fail;
42161 {
42162 PyThreadState* __tstate = wxPyBeginAllowThreads();
42163 (arg1)->Realize();
42164
42165 wxPyEndAllowThreads(__tstate);
42166 if (PyErr_Occurred()) SWIG_fail;
42167 }
42168 Py_INCREF(Py_None); resultobj = Py_None;
42169 return resultobj;
42170 fail:
42171 return NULL;
42172 }
42173
42174
42175 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42176 PyObject *resultobj;
42177 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42178 wxButton *arg2 = (wxButton *) 0 ;
42179 PyObject * obj0 = 0 ;
42180 PyObject * obj1 = 0 ;
42181 char *kwnames[] = {
42182 (char *) "self",(char *) "button", NULL
42183 };
42184
42185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42187 if (SWIG_arg_fail(1)) SWIG_fail;
42188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42189 if (SWIG_arg_fail(2)) SWIG_fail;
42190 {
42191 PyThreadState* __tstate = wxPyBeginAllowThreads();
42192 (arg1)->SetAffirmativeButton(arg2);
42193
42194 wxPyEndAllowThreads(__tstate);
42195 if (PyErr_Occurred()) SWIG_fail;
42196 }
42197 Py_INCREF(Py_None); resultobj = Py_None;
42198 return resultobj;
42199 fail:
42200 return NULL;
42201 }
42202
42203
42204 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42205 PyObject *resultobj;
42206 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42207 wxButton *arg2 = (wxButton *) 0 ;
42208 PyObject * obj0 = 0 ;
42209 PyObject * obj1 = 0 ;
42210 char *kwnames[] = {
42211 (char *) "self",(char *) "button", NULL
42212 };
42213
42214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42216 if (SWIG_arg_fail(1)) SWIG_fail;
42217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42218 if (SWIG_arg_fail(2)) SWIG_fail;
42219 {
42220 PyThreadState* __tstate = wxPyBeginAllowThreads();
42221 (arg1)->SetNegativeButton(arg2);
42222
42223 wxPyEndAllowThreads(__tstate);
42224 if (PyErr_Occurred()) SWIG_fail;
42225 }
42226 Py_INCREF(Py_None); resultobj = Py_None;
42227 return resultobj;
42228 fail:
42229 return NULL;
42230 }
42231
42232
42233 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42234 PyObject *resultobj;
42235 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42236 wxButton *arg2 = (wxButton *) 0 ;
42237 PyObject * obj0 = 0 ;
42238 PyObject * obj1 = 0 ;
42239 char *kwnames[] = {
42240 (char *) "self",(char *) "button", NULL
42241 };
42242
42243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42245 if (SWIG_arg_fail(1)) SWIG_fail;
42246 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42247 if (SWIG_arg_fail(2)) SWIG_fail;
42248 {
42249 PyThreadState* __tstate = wxPyBeginAllowThreads();
42250 (arg1)->SetCancelButton(arg2);
42251
42252 wxPyEndAllowThreads(__tstate);
42253 if (PyErr_Occurred()) SWIG_fail;
42254 }
42255 Py_INCREF(Py_None); resultobj = Py_None;
42256 return resultobj;
42257 fail:
42258 return NULL;
42259 }
42260
42261
42262 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42263 PyObject *resultobj;
42264 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42265 wxButton *result;
42266 PyObject * obj0 = 0 ;
42267 char *kwnames[] = {
42268 (char *) "self", NULL
42269 };
42270
42271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42273 if (SWIG_arg_fail(1)) SWIG_fail;
42274 {
42275 PyThreadState* __tstate = wxPyBeginAllowThreads();
42276 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42277
42278 wxPyEndAllowThreads(__tstate);
42279 if (PyErr_Occurred()) SWIG_fail;
42280 }
42281 {
42282 resultobj = wxPyMake_wxObject(result, 0);
42283 }
42284 return resultobj;
42285 fail:
42286 return NULL;
42287 }
42288
42289
42290 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42291 PyObject *resultobj;
42292 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42293 wxButton *result;
42294 PyObject * obj0 = 0 ;
42295 char *kwnames[] = {
42296 (char *) "self", NULL
42297 };
42298
42299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42301 if (SWIG_arg_fail(1)) SWIG_fail;
42302 {
42303 PyThreadState* __tstate = wxPyBeginAllowThreads();
42304 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42305
42306 wxPyEndAllowThreads(__tstate);
42307 if (PyErr_Occurred()) SWIG_fail;
42308 }
42309 {
42310 resultobj = wxPyMake_wxObject(result, 0);
42311 }
42312 return resultobj;
42313 fail:
42314 return NULL;
42315 }
42316
42317
42318 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42319 PyObject *resultobj;
42320 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42321 wxButton *result;
42322 PyObject * obj0 = 0 ;
42323 char *kwnames[] = {
42324 (char *) "self", NULL
42325 };
42326
42327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42329 if (SWIG_arg_fail(1)) SWIG_fail;
42330 {
42331 PyThreadState* __tstate = wxPyBeginAllowThreads();
42332 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42333
42334 wxPyEndAllowThreads(__tstate);
42335 if (PyErr_Occurred()) SWIG_fail;
42336 }
42337 {
42338 resultobj = wxPyMake_wxObject(result, 0);
42339 }
42340 return resultobj;
42341 fail:
42342 return NULL;
42343 }
42344
42345
42346 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42347 PyObject *resultobj;
42348 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42349 wxButton *result;
42350 PyObject * obj0 = 0 ;
42351 char *kwnames[] = {
42352 (char *) "self", NULL
42353 };
42354
42355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42357 if (SWIG_arg_fail(1)) SWIG_fail;
42358 {
42359 PyThreadState* __tstate = wxPyBeginAllowThreads();
42360 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42361
42362 wxPyEndAllowThreads(__tstate);
42363 if (PyErr_Occurred()) SWIG_fail;
42364 }
42365 {
42366 resultobj = wxPyMake_wxObject(result, 0);
42367 }
42368 return resultobj;
42369 fail:
42370 return NULL;
42371 }
42372
42373
42374 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42375 PyObject *resultobj;
42376 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42377 wxButton *result;
42378 PyObject * obj0 = 0 ;
42379 char *kwnames[] = {
42380 (char *) "self", NULL
42381 };
42382
42383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42385 if (SWIG_arg_fail(1)) SWIG_fail;
42386 {
42387 PyThreadState* __tstate = wxPyBeginAllowThreads();
42388 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42389
42390 wxPyEndAllowThreads(__tstate);
42391 if (PyErr_Occurred()) SWIG_fail;
42392 }
42393 {
42394 resultobj = wxPyMake_wxObject(result, 0);
42395 }
42396 return resultobj;
42397 fail:
42398 return NULL;
42399 }
42400
42401
42402 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42403 PyObject *obj;
42404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42405 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42406 Py_INCREF(obj);
42407 return Py_BuildValue((char *)"");
42408 }
42409 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42410 PyObject *resultobj;
42411 int arg1 = (int) 0 ;
42412 int arg2 = (int) 0 ;
42413 wxGBPosition *result;
42414 PyObject * obj0 = 0 ;
42415 PyObject * obj1 = 0 ;
42416 char *kwnames[] = {
42417 (char *) "row",(char *) "col", NULL
42418 };
42419
42420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42421 if (obj0) {
42422 {
42423 arg1 = (int)(SWIG_As_int(obj0));
42424 if (SWIG_arg_fail(1)) SWIG_fail;
42425 }
42426 }
42427 if (obj1) {
42428 {
42429 arg2 = (int)(SWIG_As_int(obj1));
42430 if (SWIG_arg_fail(2)) SWIG_fail;
42431 }
42432 }
42433 {
42434 PyThreadState* __tstate = wxPyBeginAllowThreads();
42435 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42436
42437 wxPyEndAllowThreads(__tstate);
42438 if (PyErr_Occurred()) SWIG_fail;
42439 }
42440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42441 return resultobj;
42442 fail:
42443 return NULL;
42444 }
42445
42446
42447 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42448 PyObject *resultobj;
42449 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42450 int result;
42451 PyObject * obj0 = 0 ;
42452 char *kwnames[] = {
42453 (char *) "self", NULL
42454 };
42455
42456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42458 if (SWIG_arg_fail(1)) SWIG_fail;
42459 {
42460 PyThreadState* __tstate = wxPyBeginAllowThreads();
42461 result = (int)((wxGBPosition const *)arg1)->GetRow();
42462
42463 wxPyEndAllowThreads(__tstate);
42464 if (PyErr_Occurred()) SWIG_fail;
42465 }
42466 {
42467 resultobj = SWIG_From_int((int)(result));
42468 }
42469 return resultobj;
42470 fail:
42471 return NULL;
42472 }
42473
42474
42475 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42476 PyObject *resultobj;
42477 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42478 int result;
42479 PyObject * obj0 = 0 ;
42480 char *kwnames[] = {
42481 (char *) "self", NULL
42482 };
42483
42484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42486 if (SWIG_arg_fail(1)) SWIG_fail;
42487 {
42488 PyThreadState* __tstate = wxPyBeginAllowThreads();
42489 result = (int)((wxGBPosition const *)arg1)->GetCol();
42490
42491 wxPyEndAllowThreads(__tstate);
42492 if (PyErr_Occurred()) SWIG_fail;
42493 }
42494 {
42495 resultobj = SWIG_From_int((int)(result));
42496 }
42497 return resultobj;
42498 fail:
42499 return NULL;
42500 }
42501
42502
42503 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42504 PyObject *resultobj;
42505 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42506 int arg2 ;
42507 PyObject * obj0 = 0 ;
42508 PyObject * obj1 = 0 ;
42509 char *kwnames[] = {
42510 (char *) "self",(char *) "row", NULL
42511 };
42512
42513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42515 if (SWIG_arg_fail(1)) SWIG_fail;
42516 {
42517 arg2 = (int)(SWIG_As_int(obj1));
42518 if (SWIG_arg_fail(2)) SWIG_fail;
42519 }
42520 {
42521 PyThreadState* __tstate = wxPyBeginAllowThreads();
42522 (arg1)->SetRow(arg2);
42523
42524 wxPyEndAllowThreads(__tstate);
42525 if (PyErr_Occurred()) SWIG_fail;
42526 }
42527 Py_INCREF(Py_None); resultobj = Py_None;
42528 return resultobj;
42529 fail:
42530 return NULL;
42531 }
42532
42533
42534 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42535 PyObject *resultobj;
42536 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42537 int arg2 ;
42538 PyObject * obj0 = 0 ;
42539 PyObject * obj1 = 0 ;
42540 char *kwnames[] = {
42541 (char *) "self",(char *) "col", NULL
42542 };
42543
42544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42546 if (SWIG_arg_fail(1)) SWIG_fail;
42547 {
42548 arg2 = (int)(SWIG_As_int(obj1));
42549 if (SWIG_arg_fail(2)) SWIG_fail;
42550 }
42551 {
42552 PyThreadState* __tstate = wxPyBeginAllowThreads();
42553 (arg1)->SetCol(arg2);
42554
42555 wxPyEndAllowThreads(__tstate);
42556 if (PyErr_Occurred()) SWIG_fail;
42557 }
42558 Py_INCREF(Py_None); resultobj = Py_None;
42559 return resultobj;
42560 fail:
42561 return NULL;
42562 }
42563
42564
42565 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42566 PyObject *resultobj;
42567 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42568 wxGBPosition *arg2 = 0 ;
42569 bool result;
42570 wxGBPosition temp2 ;
42571 PyObject * obj0 = 0 ;
42572 PyObject * obj1 = 0 ;
42573 char *kwnames[] = {
42574 (char *) "self",(char *) "other", NULL
42575 };
42576
42577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42579 if (SWIG_arg_fail(1)) SWIG_fail;
42580 {
42581 arg2 = &temp2;
42582 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42583 }
42584 {
42585 PyThreadState* __tstate = wxPyBeginAllowThreads();
42586 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42587
42588 wxPyEndAllowThreads(__tstate);
42589 if (PyErr_Occurred()) SWIG_fail;
42590 }
42591 {
42592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42593 }
42594 return resultobj;
42595 fail:
42596 return NULL;
42597 }
42598
42599
42600 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42601 PyObject *resultobj;
42602 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42603 wxGBPosition *arg2 = 0 ;
42604 bool result;
42605 wxGBPosition temp2 ;
42606 PyObject * obj0 = 0 ;
42607 PyObject * obj1 = 0 ;
42608 char *kwnames[] = {
42609 (char *) "self",(char *) "other", NULL
42610 };
42611
42612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42614 if (SWIG_arg_fail(1)) SWIG_fail;
42615 {
42616 arg2 = &temp2;
42617 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42618 }
42619 {
42620 PyThreadState* __tstate = wxPyBeginAllowThreads();
42621 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42622
42623 wxPyEndAllowThreads(__tstate);
42624 if (PyErr_Occurred()) SWIG_fail;
42625 }
42626 {
42627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42628 }
42629 return resultobj;
42630 fail:
42631 return NULL;
42632 }
42633
42634
42635 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42636 PyObject *resultobj;
42637 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42638 int arg2 = (int) 0 ;
42639 int arg3 = (int) 0 ;
42640 PyObject * obj0 = 0 ;
42641 PyObject * obj1 = 0 ;
42642 PyObject * obj2 = 0 ;
42643 char *kwnames[] = {
42644 (char *) "self",(char *) "row",(char *) "col", NULL
42645 };
42646
42647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42649 if (SWIG_arg_fail(1)) SWIG_fail;
42650 if (obj1) {
42651 {
42652 arg2 = (int)(SWIG_As_int(obj1));
42653 if (SWIG_arg_fail(2)) SWIG_fail;
42654 }
42655 }
42656 if (obj2) {
42657 {
42658 arg3 = (int)(SWIG_As_int(obj2));
42659 if (SWIG_arg_fail(3)) SWIG_fail;
42660 }
42661 }
42662 {
42663 PyThreadState* __tstate = wxPyBeginAllowThreads();
42664 wxGBPosition_Set(arg1,arg2,arg3);
42665
42666 wxPyEndAllowThreads(__tstate);
42667 if (PyErr_Occurred()) SWIG_fail;
42668 }
42669 Py_INCREF(Py_None); resultobj = Py_None;
42670 return resultobj;
42671 fail:
42672 return NULL;
42673 }
42674
42675
42676 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42677 PyObject *resultobj;
42678 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42679 PyObject *result;
42680 PyObject * obj0 = 0 ;
42681 char *kwnames[] = {
42682 (char *) "self", NULL
42683 };
42684
42685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42687 if (SWIG_arg_fail(1)) SWIG_fail;
42688 {
42689 PyThreadState* __tstate = wxPyBeginAllowThreads();
42690 result = (PyObject *)wxGBPosition_Get(arg1);
42691
42692 wxPyEndAllowThreads(__tstate);
42693 if (PyErr_Occurred()) SWIG_fail;
42694 }
42695 resultobj = result;
42696 return resultobj;
42697 fail:
42698 return NULL;
42699 }
42700
42701
42702 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42703 PyObject *obj;
42704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42705 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42706 Py_INCREF(obj);
42707 return Py_BuildValue((char *)"");
42708 }
42709 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42710 PyObject *resultobj;
42711 int arg1 = (int) 1 ;
42712 int arg2 = (int) 1 ;
42713 wxGBSpan *result;
42714 PyObject * obj0 = 0 ;
42715 PyObject * obj1 = 0 ;
42716 char *kwnames[] = {
42717 (char *) "rowspan",(char *) "colspan", NULL
42718 };
42719
42720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42721 if (obj0) {
42722 {
42723 arg1 = (int)(SWIG_As_int(obj0));
42724 if (SWIG_arg_fail(1)) SWIG_fail;
42725 }
42726 }
42727 if (obj1) {
42728 {
42729 arg2 = (int)(SWIG_As_int(obj1));
42730 if (SWIG_arg_fail(2)) SWIG_fail;
42731 }
42732 }
42733 {
42734 PyThreadState* __tstate = wxPyBeginAllowThreads();
42735 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42736
42737 wxPyEndAllowThreads(__tstate);
42738 if (PyErr_Occurred()) SWIG_fail;
42739 }
42740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42741 return resultobj;
42742 fail:
42743 return NULL;
42744 }
42745
42746
42747 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42748 PyObject *resultobj;
42749 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42750 int result;
42751 PyObject * obj0 = 0 ;
42752 char *kwnames[] = {
42753 (char *) "self", NULL
42754 };
42755
42756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42758 if (SWIG_arg_fail(1)) SWIG_fail;
42759 {
42760 PyThreadState* __tstate = wxPyBeginAllowThreads();
42761 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42762
42763 wxPyEndAllowThreads(__tstate);
42764 if (PyErr_Occurred()) SWIG_fail;
42765 }
42766 {
42767 resultobj = SWIG_From_int((int)(result));
42768 }
42769 return resultobj;
42770 fail:
42771 return NULL;
42772 }
42773
42774
42775 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42776 PyObject *resultobj;
42777 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42778 int result;
42779 PyObject * obj0 = 0 ;
42780 char *kwnames[] = {
42781 (char *) "self", NULL
42782 };
42783
42784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42786 if (SWIG_arg_fail(1)) SWIG_fail;
42787 {
42788 PyThreadState* __tstate = wxPyBeginAllowThreads();
42789 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42790
42791 wxPyEndAllowThreads(__tstate);
42792 if (PyErr_Occurred()) SWIG_fail;
42793 }
42794 {
42795 resultobj = SWIG_From_int((int)(result));
42796 }
42797 return resultobj;
42798 fail:
42799 return NULL;
42800 }
42801
42802
42803 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42804 PyObject *resultobj;
42805 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42806 int arg2 ;
42807 PyObject * obj0 = 0 ;
42808 PyObject * obj1 = 0 ;
42809 char *kwnames[] = {
42810 (char *) "self",(char *) "rowspan", NULL
42811 };
42812
42813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42815 if (SWIG_arg_fail(1)) SWIG_fail;
42816 {
42817 arg2 = (int)(SWIG_As_int(obj1));
42818 if (SWIG_arg_fail(2)) SWIG_fail;
42819 }
42820 {
42821 PyThreadState* __tstate = wxPyBeginAllowThreads();
42822 (arg1)->SetRowspan(arg2);
42823
42824 wxPyEndAllowThreads(__tstate);
42825 if (PyErr_Occurred()) SWIG_fail;
42826 }
42827 Py_INCREF(Py_None); resultobj = Py_None;
42828 return resultobj;
42829 fail:
42830 return NULL;
42831 }
42832
42833
42834 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42835 PyObject *resultobj;
42836 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42837 int arg2 ;
42838 PyObject * obj0 = 0 ;
42839 PyObject * obj1 = 0 ;
42840 char *kwnames[] = {
42841 (char *) "self",(char *) "colspan", NULL
42842 };
42843
42844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42846 if (SWIG_arg_fail(1)) SWIG_fail;
42847 {
42848 arg2 = (int)(SWIG_As_int(obj1));
42849 if (SWIG_arg_fail(2)) SWIG_fail;
42850 }
42851 {
42852 PyThreadState* __tstate = wxPyBeginAllowThreads();
42853 (arg1)->SetColspan(arg2);
42854
42855 wxPyEndAllowThreads(__tstate);
42856 if (PyErr_Occurred()) SWIG_fail;
42857 }
42858 Py_INCREF(Py_None); resultobj = Py_None;
42859 return resultobj;
42860 fail:
42861 return NULL;
42862 }
42863
42864
42865 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42866 PyObject *resultobj;
42867 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42868 wxGBSpan *arg2 = 0 ;
42869 bool result;
42870 wxGBSpan temp2 ;
42871 PyObject * obj0 = 0 ;
42872 PyObject * obj1 = 0 ;
42873 char *kwnames[] = {
42874 (char *) "self",(char *) "other", NULL
42875 };
42876
42877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42879 if (SWIG_arg_fail(1)) SWIG_fail;
42880 {
42881 arg2 = &temp2;
42882 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42883 }
42884 {
42885 PyThreadState* __tstate = wxPyBeginAllowThreads();
42886 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42887
42888 wxPyEndAllowThreads(__tstate);
42889 if (PyErr_Occurred()) SWIG_fail;
42890 }
42891 {
42892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42893 }
42894 return resultobj;
42895 fail:
42896 return NULL;
42897 }
42898
42899
42900 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42901 PyObject *resultobj;
42902 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42903 wxGBSpan *arg2 = 0 ;
42904 bool result;
42905 wxGBSpan temp2 ;
42906 PyObject * obj0 = 0 ;
42907 PyObject * obj1 = 0 ;
42908 char *kwnames[] = {
42909 (char *) "self",(char *) "other", NULL
42910 };
42911
42912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42914 if (SWIG_arg_fail(1)) SWIG_fail;
42915 {
42916 arg2 = &temp2;
42917 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42918 }
42919 {
42920 PyThreadState* __tstate = wxPyBeginAllowThreads();
42921 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42922
42923 wxPyEndAllowThreads(__tstate);
42924 if (PyErr_Occurred()) SWIG_fail;
42925 }
42926 {
42927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42928 }
42929 return resultobj;
42930 fail:
42931 return NULL;
42932 }
42933
42934
42935 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42936 PyObject *resultobj;
42937 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42938 int arg2 = (int) 1 ;
42939 int arg3 = (int) 1 ;
42940 PyObject * obj0 = 0 ;
42941 PyObject * obj1 = 0 ;
42942 PyObject * obj2 = 0 ;
42943 char *kwnames[] = {
42944 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42945 };
42946
42947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42949 if (SWIG_arg_fail(1)) SWIG_fail;
42950 if (obj1) {
42951 {
42952 arg2 = (int)(SWIG_As_int(obj1));
42953 if (SWIG_arg_fail(2)) SWIG_fail;
42954 }
42955 }
42956 if (obj2) {
42957 {
42958 arg3 = (int)(SWIG_As_int(obj2));
42959 if (SWIG_arg_fail(3)) SWIG_fail;
42960 }
42961 }
42962 {
42963 PyThreadState* __tstate = wxPyBeginAllowThreads();
42964 wxGBSpan_Set(arg1,arg2,arg3);
42965
42966 wxPyEndAllowThreads(__tstate);
42967 if (PyErr_Occurred()) SWIG_fail;
42968 }
42969 Py_INCREF(Py_None); resultobj = Py_None;
42970 return resultobj;
42971 fail:
42972 return NULL;
42973 }
42974
42975
42976 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42977 PyObject *resultobj;
42978 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42979 PyObject *result;
42980 PyObject * obj0 = 0 ;
42981 char *kwnames[] = {
42982 (char *) "self", NULL
42983 };
42984
42985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42987 if (SWIG_arg_fail(1)) SWIG_fail;
42988 {
42989 PyThreadState* __tstate = wxPyBeginAllowThreads();
42990 result = (PyObject *)wxGBSpan_Get(arg1);
42991
42992 wxPyEndAllowThreads(__tstate);
42993 if (PyErr_Occurred()) SWIG_fail;
42994 }
42995 resultobj = result;
42996 return resultobj;
42997 fail:
42998 return NULL;
42999 }
43000
43001
43002 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43003 PyObject *obj;
43004 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43005 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43006 Py_INCREF(obj);
43007 return Py_BuildValue((char *)"");
43008 }
43009 static int _wrap_DefaultSpan_set(PyObject *) {
43010 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43011 return 1;
43012 }
43013
43014
43015 static PyObject *_wrap_DefaultSpan_get(void) {
43016 PyObject *pyobj;
43017
43018 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43019 return pyobj;
43020 }
43021
43022
43023 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43024 PyObject *resultobj;
43025 wxGBSizerItem *result;
43026 char *kwnames[] = {
43027 NULL
43028 };
43029
43030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43031 {
43032 PyThreadState* __tstate = wxPyBeginAllowThreads();
43033 result = (wxGBSizerItem *)new wxGBSizerItem();
43034
43035 wxPyEndAllowThreads(__tstate);
43036 if (PyErr_Occurred()) SWIG_fail;
43037 }
43038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43039 return resultobj;
43040 fail:
43041 return NULL;
43042 }
43043
43044
43045 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43046 PyObject *resultobj;
43047 wxWindow *arg1 = (wxWindow *) 0 ;
43048 wxGBPosition *arg2 = 0 ;
43049 wxGBSpan *arg3 = 0 ;
43050 int arg4 ;
43051 int arg5 ;
43052 PyObject *arg6 = (PyObject *) NULL ;
43053 wxGBSizerItem *result;
43054 wxGBPosition temp2 ;
43055 wxGBSpan temp3 ;
43056 PyObject * obj0 = 0 ;
43057 PyObject * obj1 = 0 ;
43058 PyObject * obj2 = 0 ;
43059 PyObject * obj3 = 0 ;
43060 PyObject * obj4 = 0 ;
43061 PyObject * obj5 = 0 ;
43062 char *kwnames[] = {
43063 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43064 };
43065
43066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43068 if (SWIG_arg_fail(1)) SWIG_fail;
43069 {
43070 arg2 = &temp2;
43071 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43072 }
43073 {
43074 arg3 = &temp3;
43075 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43076 }
43077 {
43078 arg4 = (int)(SWIG_As_int(obj3));
43079 if (SWIG_arg_fail(4)) SWIG_fail;
43080 }
43081 {
43082 arg5 = (int)(SWIG_As_int(obj4));
43083 if (SWIG_arg_fail(5)) SWIG_fail;
43084 }
43085 if (obj5) {
43086 arg6 = obj5;
43087 }
43088 {
43089 PyThreadState* __tstate = wxPyBeginAllowThreads();
43090 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43091
43092 wxPyEndAllowThreads(__tstate);
43093 if (PyErr_Occurred()) SWIG_fail;
43094 }
43095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43096 return resultobj;
43097 fail:
43098 return NULL;
43099 }
43100
43101
43102 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43103 PyObject *resultobj;
43104 wxSizer *arg1 = (wxSizer *) 0 ;
43105 wxGBPosition *arg2 = 0 ;
43106 wxGBSpan *arg3 = 0 ;
43107 int arg4 ;
43108 int arg5 ;
43109 PyObject *arg6 = (PyObject *) NULL ;
43110 wxGBSizerItem *result;
43111 wxGBPosition temp2 ;
43112 wxGBSpan temp3 ;
43113 PyObject * obj0 = 0 ;
43114 PyObject * obj1 = 0 ;
43115 PyObject * obj2 = 0 ;
43116 PyObject * obj3 = 0 ;
43117 PyObject * obj4 = 0 ;
43118 PyObject * obj5 = 0 ;
43119 char *kwnames[] = {
43120 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43121 };
43122
43123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43125 if (SWIG_arg_fail(1)) SWIG_fail;
43126 {
43127 arg2 = &temp2;
43128 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43129 }
43130 {
43131 arg3 = &temp3;
43132 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43133 }
43134 {
43135 arg4 = (int)(SWIG_As_int(obj3));
43136 if (SWIG_arg_fail(4)) SWIG_fail;
43137 }
43138 {
43139 arg5 = (int)(SWIG_As_int(obj4));
43140 if (SWIG_arg_fail(5)) SWIG_fail;
43141 }
43142 if (obj5) {
43143 arg6 = obj5;
43144 }
43145 {
43146 PyThreadState* __tstate = wxPyBeginAllowThreads();
43147 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43148
43149 wxPyEndAllowThreads(__tstate);
43150 if (PyErr_Occurred()) SWIG_fail;
43151 }
43152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43153 return resultobj;
43154 fail:
43155 return NULL;
43156 }
43157
43158
43159 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43160 PyObject *resultobj;
43161 int arg1 ;
43162 int arg2 ;
43163 wxGBPosition *arg3 = 0 ;
43164 wxGBSpan *arg4 = 0 ;
43165 int arg5 ;
43166 int arg6 ;
43167 PyObject *arg7 = (PyObject *) NULL ;
43168 wxGBSizerItem *result;
43169 wxGBPosition temp3 ;
43170 wxGBSpan temp4 ;
43171 PyObject * obj0 = 0 ;
43172 PyObject * obj1 = 0 ;
43173 PyObject * obj2 = 0 ;
43174 PyObject * obj3 = 0 ;
43175 PyObject * obj4 = 0 ;
43176 PyObject * obj5 = 0 ;
43177 PyObject * obj6 = 0 ;
43178 char *kwnames[] = {
43179 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43180 };
43181
43182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43183 {
43184 arg1 = (int)(SWIG_As_int(obj0));
43185 if (SWIG_arg_fail(1)) SWIG_fail;
43186 }
43187 {
43188 arg2 = (int)(SWIG_As_int(obj1));
43189 if (SWIG_arg_fail(2)) SWIG_fail;
43190 }
43191 {
43192 arg3 = &temp3;
43193 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43194 }
43195 {
43196 arg4 = &temp4;
43197 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43198 }
43199 {
43200 arg5 = (int)(SWIG_As_int(obj4));
43201 if (SWIG_arg_fail(5)) SWIG_fail;
43202 }
43203 {
43204 arg6 = (int)(SWIG_As_int(obj5));
43205 if (SWIG_arg_fail(6)) SWIG_fail;
43206 }
43207 if (obj6) {
43208 arg7 = obj6;
43209 }
43210 {
43211 PyThreadState* __tstate = wxPyBeginAllowThreads();
43212 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43213
43214 wxPyEndAllowThreads(__tstate);
43215 if (PyErr_Occurred()) SWIG_fail;
43216 }
43217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43218 return resultobj;
43219 fail:
43220 return NULL;
43221 }
43222
43223
43224 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43225 PyObject *resultobj;
43226 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43227 wxGBPosition result;
43228 PyObject * obj0 = 0 ;
43229 char *kwnames[] = {
43230 (char *) "self", NULL
43231 };
43232
43233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43235 if (SWIG_arg_fail(1)) SWIG_fail;
43236 {
43237 PyThreadState* __tstate = wxPyBeginAllowThreads();
43238 result = ((wxGBSizerItem const *)arg1)->GetPos();
43239
43240 wxPyEndAllowThreads(__tstate);
43241 if (PyErr_Occurred()) SWIG_fail;
43242 }
43243 {
43244 wxGBPosition * resultptr;
43245 resultptr = new wxGBPosition((wxGBPosition &)(result));
43246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43247 }
43248 return resultobj;
43249 fail:
43250 return NULL;
43251 }
43252
43253
43254 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43255 PyObject *resultobj;
43256 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43257 wxGBSpan result;
43258 PyObject * obj0 = 0 ;
43259 char *kwnames[] = {
43260 (char *) "self", NULL
43261 };
43262
43263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43265 if (SWIG_arg_fail(1)) SWIG_fail;
43266 {
43267 PyThreadState* __tstate = wxPyBeginAllowThreads();
43268 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43269
43270 wxPyEndAllowThreads(__tstate);
43271 if (PyErr_Occurred()) SWIG_fail;
43272 }
43273 {
43274 wxGBSpan * resultptr;
43275 resultptr = new wxGBSpan((wxGBSpan &)(result));
43276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43277 }
43278 return resultobj;
43279 fail:
43280 return NULL;
43281 }
43282
43283
43284 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43285 PyObject *resultobj;
43286 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43287 wxGBPosition *arg2 = 0 ;
43288 bool result;
43289 wxGBPosition temp2 ;
43290 PyObject * obj0 = 0 ;
43291 PyObject * obj1 = 0 ;
43292 char *kwnames[] = {
43293 (char *) "self",(char *) "pos", NULL
43294 };
43295
43296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43298 if (SWIG_arg_fail(1)) SWIG_fail;
43299 {
43300 arg2 = &temp2;
43301 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43302 }
43303 {
43304 PyThreadState* __tstate = wxPyBeginAllowThreads();
43305 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43306
43307 wxPyEndAllowThreads(__tstate);
43308 if (PyErr_Occurred()) SWIG_fail;
43309 }
43310 {
43311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43312 }
43313 return resultobj;
43314 fail:
43315 return NULL;
43316 }
43317
43318
43319 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43320 PyObject *resultobj;
43321 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43322 wxGBSpan *arg2 = 0 ;
43323 bool result;
43324 wxGBSpan temp2 ;
43325 PyObject * obj0 = 0 ;
43326 PyObject * obj1 = 0 ;
43327 char *kwnames[] = {
43328 (char *) "self",(char *) "span", NULL
43329 };
43330
43331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43333 if (SWIG_arg_fail(1)) SWIG_fail;
43334 {
43335 arg2 = &temp2;
43336 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43337 }
43338 {
43339 PyThreadState* __tstate = wxPyBeginAllowThreads();
43340 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43341
43342 wxPyEndAllowThreads(__tstate);
43343 if (PyErr_Occurred()) SWIG_fail;
43344 }
43345 {
43346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43347 }
43348 return resultobj;
43349 fail:
43350 return NULL;
43351 }
43352
43353
43354 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43355 PyObject *resultobj;
43356 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43357 wxGBSizerItem *arg2 = 0 ;
43358 bool result;
43359 PyObject * obj0 = 0 ;
43360 PyObject * obj1 = 0 ;
43361 char *kwnames[] = {
43362 (char *) "self",(char *) "other", NULL
43363 };
43364
43365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43367 if (SWIG_arg_fail(1)) SWIG_fail;
43368 {
43369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43370 if (SWIG_arg_fail(2)) SWIG_fail;
43371 if (arg2 == NULL) {
43372 SWIG_null_ref("wxGBSizerItem");
43373 }
43374 if (SWIG_arg_fail(2)) SWIG_fail;
43375 }
43376 {
43377 PyThreadState* __tstate = wxPyBeginAllowThreads();
43378 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43379
43380 wxPyEndAllowThreads(__tstate);
43381 if (PyErr_Occurred()) SWIG_fail;
43382 }
43383 {
43384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43385 }
43386 return resultobj;
43387 fail:
43388 return NULL;
43389 }
43390
43391
43392 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43393 PyObject *resultobj;
43394 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43395 wxGBPosition *arg2 = 0 ;
43396 wxGBSpan *arg3 = 0 ;
43397 bool result;
43398 wxGBPosition temp2 ;
43399 wxGBSpan temp3 ;
43400 PyObject * obj0 = 0 ;
43401 PyObject * obj1 = 0 ;
43402 PyObject * obj2 = 0 ;
43403 char *kwnames[] = {
43404 (char *) "self",(char *) "pos",(char *) "span", NULL
43405 };
43406
43407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43409 if (SWIG_arg_fail(1)) SWIG_fail;
43410 {
43411 arg2 = &temp2;
43412 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43413 }
43414 {
43415 arg3 = &temp3;
43416 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43417 }
43418 {
43419 PyThreadState* __tstate = wxPyBeginAllowThreads();
43420 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43421
43422 wxPyEndAllowThreads(__tstate);
43423 if (PyErr_Occurred()) SWIG_fail;
43424 }
43425 {
43426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43427 }
43428 return resultobj;
43429 fail:
43430 return NULL;
43431 }
43432
43433
43434 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43435 PyObject *resultobj;
43436 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43437 wxGBPosition result;
43438 PyObject * obj0 = 0 ;
43439 char *kwnames[] = {
43440 (char *) "self", NULL
43441 };
43442
43443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43445 if (SWIG_arg_fail(1)) SWIG_fail;
43446 {
43447 PyThreadState* __tstate = wxPyBeginAllowThreads();
43448 result = wxGBSizerItem_GetEndPos(arg1);
43449
43450 wxPyEndAllowThreads(__tstate);
43451 if (PyErr_Occurred()) SWIG_fail;
43452 }
43453 {
43454 wxGBPosition * resultptr;
43455 resultptr = new wxGBPosition((wxGBPosition &)(result));
43456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43457 }
43458 return resultobj;
43459 fail:
43460 return NULL;
43461 }
43462
43463
43464 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43465 PyObject *resultobj;
43466 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43467 wxGridBagSizer *result;
43468 PyObject * obj0 = 0 ;
43469 char *kwnames[] = {
43470 (char *) "self", NULL
43471 };
43472
43473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43475 if (SWIG_arg_fail(1)) SWIG_fail;
43476 {
43477 PyThreadState* __tstate = wxPyBeginAllowThreads();
43478 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43479
43480 wxPyEndAllowThreads(__tstate);
43481 if (PyErr_Occurred()) SWIG_fail;
43482 }
43483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43484 return resultobj;
43485 fail:
43486 return NULL;
43487 }
43488
43489
43490 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43491 PyObject *resultobj;
43492 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43493 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43494 PyObject * obj0 = 0 ;
43495 PyObject * obj1 = 0 ;
43496 char *kwnames[] = {
43497 (char *) "self",(char *) "sizer", NULL
43498 };
43499
43500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43502 if (SWIG_arg_fail(1)) SWIG_fail;
43503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43504 if (SWIG_arg_fail(2)) SWIG_fail;
43505 {
43506 PyThreadState* __tstate = wxPyBeginAllowThreads();
43507 (arg1)->SetGBSizer(arg2);
43508
43509 wxPyEndAllowThreads(__tstate);
43510 if (PyErr_Occurred()) SWIG_fail;
43511 }
43512 Py_INCREF(Py_None); resultobj = Py_None;
43513 return resultobj;
43514 fail:
43515 return NULL;
43516 }
43517
43518
43519 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43520 PyObject *obj;
43521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43522 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43523 Py_INCREF(obj);
43524 return Py_BuildValue((char *)"");
43525 }
43526 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43527 PyObject *resultobj;
43528 int arg1 = (int) 0 ;
43529 int arg2 = (int) 0 ;
43530 wxGridBagSizer *result;
43531 PyObject * obj0 = 0 ;
43532 PyObject * obj1 = 0 ;
43533 char *kwnames[] = {
43534 (char *) "vgap",(char *) "hgap", NULL
43535 };
43536
43537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43538 if (obj0) {
43539 {
43540 arg1 = (int)(SWIG_As_int(obj0));
43541 if (SWIG_arg_fail(1)) SWIG_fail;
43542 }
43543 }
43544 if (obj1) {
43545 {
43546 arg2 = (int)(SWIG_As_int(obj1));
43547 if (SWIG_arg_fail(2)) SWIG_fail;
43548 }
43549 }
43550 {
43551 PyThreadState* __tstate = wxPyBeginAllowThreads();
43552 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43553
43554 wxPyEndAllowThreads(__tstate);
43555 if (PyErr_Occurred()) SWIG_fail;
43556 }
43557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43558 return resultobj;
43559 fail:
43560 return NULL;
43561 }
43562
43563
43564 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43565 PyObject *resultobj;
43566 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43567 PyObject *arg2 = (PyObject *) 0 ;
43568 wxGBPosition *arg3 = 0 ;
43569 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43570 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43571 int arg5 = (int) 0 ;
43572 int arg6 = (int) 0 ;
43573 PyObject *arg7 = (PyObject *) NULL ;
43574 wxGBSizerItem *result;
43575 wxGBPosition temp3 ;
43576 wxGBSpan temp4 ;
43577 PyObject * obj0 = 0 ;
43578 PyObject * obj1 = 0 ;
43579 PyObject * obj2 = 0 ;
43580 PyObject * obj3 = 0 ;
43581 PyObject * obj4 = 0 ;
43582 PyObject * obj5 = 0 ;
43583 PyObject * obj6 = 0 ;
43584 char *kwnames[] = {
43585 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43586 };
43587
43588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43590 if (SWIG_arg_fail(1)) SWIG_fail;
43591 arg2 = obj1;
43592 {
43593 arg3 = &temp3;
43594 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43595 }
43596 if (obj3) {
43597 {
43598 arg4 = &temp4;
43599 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43600 }
43601 }
43602 if (obj4) {
43603 {
43604 arg5 = (int)(SWIG_As_int(obj4));
43605 if (SWIG_arg_fail(5)) SWIG_fail;
43606 }
43607 }
43608 if (obj5) {
43609 {
43610 arg6 = (int)(SWIG_As_int(obj5));
43611 if (SWIG_arg_fail(6)) SWIG_fail;
43612 }
43613 }
43614 if (obj6) {
43615 arg7 = obj6;
43616 }
43617 {
43618 PyThreadState* __tstate = wxPyBeginAllowThreads();
43619 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43620
43621 wxPyEndAllowThreads(__tstate);
43622 if (PyErr_Occurred()) SWIG_fail;
43623 }
43624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43625 return resultobj;
43626 fail:
43627 return NULL;
43628 }
43629
43630
43631 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43632 PyObject *resultobj;
43633 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43634 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43635 wxGBSizerItem *result;
43636 PyObject * obj0 = 0 ;
43637 PyObject * obj1 = 0 ;
43638 char *kwnames[] = {
43639 (char *) "self",(char *) "item", NULL
43640 };
43641
43642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43644 if (SWIG_arg_fail(1)) SWIG_fail;
43645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43646 if (SWIG_arg_fail(2)) SWIG_fail;
43647 {
43648 PyThreadState* __tstate = wxPyBeginAllowThreads();
43649 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43650
43651 wxPyEndAllowThreads(__tstate);
43652 if (PyErr_Occurred()) SWIG_fail;
43653 }
43654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43655 return resultobj;
43656 fail:
43657 return NULL;
43658 }
43659
43660
43661 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43662 PyObject *resultobj;
43663 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43664 int arg2 ;
43665 int arg3 ;
43666 wxSize result;
43667 PyObject * obj0 = 0 ;
43668 PyObject * obj1 = 0 ;
43669 PyObject * obj2 = 0 ;
43670 char *kwnames[] = {
43671 (char *) "self",(char *) "row",(char *) "col", NULL
43672 };
43673
43674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43676 if (SWIG_arg_fail(1)) SWIG_fail;
43677 {
43678 arg2 = (int)(SWIG_As_int(obj1));
43679 if (SWIG_arg_fail(2)) SWIG_fail;
43680 }
43681 {
43682 arg3 = (int)(SWIG_As_int(obj2));
43683 if (SWIG_arg_fail(3)) SWIG_fail;
43684 }
43685 {
43686 PyThreadState* __tstate = wxPyBeginAllowThreads();
43687 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43688
43689 wxPyEndAllowThreads(__tstate);
43690 if (PyErr_Occurred()) SWIG_fail;
43691 }
43692 {
43693 wxSize * resultptr;
43694 resultptr = new wxSize((wxSize &)(result));
43695 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43696 }
43697 return resultobj;
43698 fail:
43699 return NULL;
43700 }
43701
43702
43703 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43704 PyObject *resultobj;
43705 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43706 wxSize result;
43707 PyObject * obj0 = 0 ;
43708 char *kwnames[] = {
43709 (char *) "self", NULL
43710 };
43711
43712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43714 if (SWIG_arg_fail(1)) SWIG_fail;
43715 {
43716 PyThreadState* __tstate = wxPyBeginAllowThreads();
43717 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43718
43719 wxPyEndAllowThreads(__tstate);
43720 if (PyErr_Occurred()) SWIG_fail;
43721 }
43722 {
43723 wxSize * resultptr;
43724 resultptr = new wxSize((wxSize &)(result));
43725 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43726 }
43727 return resultobj;
43728 fail:
43729 return NULL;
43730 }
43731
43732
43733 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43734 PyObject *resultobj;
43735 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43736 wxSize *arg2 = 0 ;
43737 wxSize temp2 ;
43738 PyObject * obj0 = 0 ;
43739 PyObject * obj1 = 0 ;
43740 char *kwnames[] = {
43741 (char *) "self",(char *) "sz", NULL
43742 };
43743
43744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43746 if (SWIG_arg_fail(1)) SWIG_fail;
43747 {
43748 arg2 = &temp2;
43749 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43750 }
43751 {
43752 PyThreadState* __tstate = wxPyBeginAllowThreads();
43753 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43754
43755 wxPyEndAllowThreads(__tstate);
43756 if (PyErr_Occurred()) SWIG_fail;
43757 }
43758 Py_INCREF(Py_None); resultobj = Py_None;
43759 return resultobj;
43760 fail:
43761 return NULL;
43762 }
43763
43764
43765 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43766 PyObject *resultobj;
43767 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43768 wxWindow *arg2 = (wxWindow *) 0 ;
43769 wxGBPosition result;
43770 PyObject * obj0 = 0 ;
43771 PyObject * obj1 = 0 ;
43772
43773 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43775 if (SWIG_arg_fail(1)) SWIG_fail;
43776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43777 if (SWIG_arg_fail(2)) SWIG_fail;
43778 {
43779 PyThreadState* __tstate = wxPyBeginAllowThreads();
43780 result = (arg1)->GetItemPosition(arg2);
43781
43782 wxPyEndAllowThreads(__tstate);
43783 if (PyErr_Occurred()) SWIG_fail;
43784 }
43785 {
43786 wxGBPosition * resultptr;
43787 resultptr = new wxGBPosition((wxGBPosition &)(result));
43788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43789 }
43790 return resultobj;
43791 fail:
43792 return NULL;
43793 }
43794
43795
43796 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43797 PyObject *resultobj;
43798 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43799 wxSizer *arg2 = (wxSizer *) 0 ;
43800 wxGBPosition result;
43801 PyObject * obj0 = 0 ;
43802 PyObject * obj1 = 0 ;
43803
43804 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43806 if (SWIG_arg_fail(1)) SWIG_fail;
43807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43808 if (SWIG_arg_fail(2)) SWIG_fail;
43809 {
43810 PyThreadState* __tstate = wxPyBeginAllowThreads();
43811 result = (arg1)->GetItemPosition(arg2);
43812
43813 wxPyEndAllowThreads(__tstate);
43814 if (PyErr_Occurred()) SWIG_fail;
43815 }
43816 {
43817 wxGBPosition * resultptr;
43818 resultptr = new wxGBPosition((wxGBPosition &)(result));
43819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43820 }
43821 return resultobj;
43822 fail:
43823 return NULL;
43824 }
43825
43826
43827 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43828 PyObject *resultobj;
43829 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43830 size_t arg2 ;
43831 wxGBPosition result;
43832 PyObject * obj0 = 0 ;
43833 PyObject * obj1 = 0 ;
43834
43835 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43837 if (SWIG_arg_fail(1)) SWIG_fail;
43838 {
43839 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43840 if (SWIG_arg_fail(2)) SWIG_fail;
43841 }
43842 {
43843 PyThreadState* __tstate = wxPyBeginAllowThreads();
43844 result = (arg1)->GetItemPosition(arg2);
43845
43846 wxPyEndAllowThreads(__tstate);
43847 if (PyErr_Occurred()) SWIG_fail;
43848 }
43849 {
43850 wxGBPosition * resultptr;
43851 resultptr = new wxGBPosition((wxGBPosition &)(result));
43852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43853 }
43854 return resultobj;
43855 fail:
43856 return NULL;
43857 }
43858
43859
43860 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43861 int argc;
43862 PyObject *argv[3];
43863 int ii;
43864
43865 argc = PyObject_Length(args);
43866 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43867 argv[ii] = PyTuple_GetItem(args,ii);
43868 }
43869 if (argc == 2) {
43870 int _v;
43871 {
43872 void *ptr;
43873 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43874 _v = 0;
43875 PyErr_Clear();
43876 } else {
43877 _v = 1;
43878 }
43879 }
43880 if (_v) {
43881 {
43882 void *ptr;
43883 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43884 _v = 0;
43885 PyErr_Clear();
43886 } else {
43887 _v = 1;
43888 }
43889 }
43890 if (_v) {
43891 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43892 }
43893 }
43894 }
43895 if (argc == 2) {
43896 int _v;
43897 {
43898 void *ptr;
43899 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43900 _v = 0;
43901 PyErr_Clear();
43902 } else {
43903 _v = 1;
43904 }
43905 }
43906 if (_v) {
43907 {
43908 void *ptr;
43909 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43910 _v = 0;
43911 PyErr_Clear();
43912 } else {
43913 _v = 1;
43914 }
43915 }
43916 if (_v) {
43917 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43918 }
43919 }
43920 }
43921 if (argc == 2) {
43922 int _v;
43923 {
43924 void *ptr;
43925 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43926 _v = 0;
43927 PyErr_Clear();
43928 } else {
43929 _v = 1;
43930 }
43931 }
43932 if (_v) {
43933 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43934 if (_v) {
43935 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43936 }
43937 }
43938 }
43939
43940 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43941 return NULL;
43942 }
43943
43944
43945 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43946 PyObject *resultobj;
43947 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43948 wxWindow *arg2 = (wxWindow *) 0 ;
43949 wxGBPosition *arg3 = 0 ;
43950 bool result;
43951 wxGBPosition temp3 ;
43952 PyObject * obj0 = 0 ;
43953 PyObject * obj1 = 0 ;
43954 PyObject * obj2 = 0 ;
43955
43956 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43958 if (SWIG_arg_fail(1)) SWIG_fail;
43959 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43960 if (SWIG_arg_fail(2)) SWIG_fail;
43961 {
43962 arg3 = &temp3;
43963 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43964 }
43965 {
43966 PyThreadState* __tstate = wxPyBeginAllowThreads();
43967 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43968
43969 wxPyEndAllowThreads(__tstate);
43970 if (PyErr_Occurred()) SWIG_fail;
43971 }
43972 {
43973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43974 }
43975 return resultobj;
43976 fail:
43977 return NULL;
43978 }
43979
43980
43981 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43982 PyObject *resultobj;
43983 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43984 wxSizer *arg2 = (wxSizer *) 0 ;
43985 wxGBPosition *arg3 = 0 ;
43986 bool result;
43987 wxGBPosition temp3 ;
43988 PyObject * obj0 = 0 ;
43989 PyObject * obj1 = 0 ;
43990 PyObject * obj2 = 0 ;
43991
43992 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43994 if (SWIG_arg_fail(1)) SWIG_fail;
43995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43996 if (SWIG_arg_fail(2)) SWIG_fail;
43997 {
43998 arg3 = &temp3;
43999 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44000 }
44001 {
44002 PyThreadState* __tstate = wxPyBeginAllowThreads();
44003 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44004
44005 wxPyEndAllowThreads(__tstate);
44006 if (PyErr_Occurred()) SWIG_fail;
44007 }
44008 {
44009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44010 }
44011 return resultobj;
44012 fail:
44013 return NULL;
44014 }
44015
44016
44017 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44018 PyObject *resultobj;
44019 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44020 size_t arg2 ;
44021 wxGBPosition *arg3 = 0 ;
44022 bool result;
44023 wxGBPosition temp3 ;
44024 PyObject * obj0 = 0 ;
44025 PyObject * obj1 = 0 ;
44026 PyObject * obj2 = 0 ;
44027
44028 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44030 if (SWIG_arg_fail(1)) SWIG_fail;
44031 {
44032 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44033 if (SWIG_arg_fail(2)) SWIG_fail;
44034 }
44035 {
44036 arg3 = &temp3;
44037 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44038 }
44039 {
44040 PyThreadState* __tstate = wxPyBeginAllowThreads();
44041 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44042
44043 wxPyEndAllowThreads(__tstate);
44044 if (PyErr_Occurred()) SWIG_fail;
44045 }
44046 {
44047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44048 }
44049 return resultobj;
44050 fail:
44051 return NULL;
44052 }
44053
44054
44055 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44056 int argc;
44057 PyObject *argv[4];
44058 int ii;
44059
44060 argc = PyObject_Length(args);
44061 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44062 argv[ii] = PyTuple_GetItem(args,ii);
44063 }
44064 if (argc == 3) {
44065 int _v;
44066 {
44067 void *ptr;
44068 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44069 _v = 0;
44070 PyErr_Clear();
44071 } else {
44072 _v = 1;
44073 }
44074 }
44075 if (_v) {
44076 {
44077 void *ptr;
44078 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44079 _v = 0;
44080 PyErr_Clear();
44081 } else {
44082 _v = 1;
44083 }
44084 }
44085 if (_v) {
44086 {
44087 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44088 }
44089 if (_v) {
44090 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44091 }
44092 }
44093 }
44094 }
44095 if (argc == 3) {
44096 int _v;
44097 {
44098 void *ptr;
44099 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44100 _v = 0;
44101 PyErr_Clear();
44102 } else {
44103 _v = 1;
44104 }
44105 }
44106 if (_v) {
44107 {
44108 void *ptr;
44109 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44110 _v = 0;
44111 PyErr_Clear();
44112 } else {
44113 _v = 1;
44114 }
44115 }
44116 if (_v) {
44117 {
44118 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44119 }
44120 if (_v) {
44121 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44122 }
44123 }
44124 }
44125 }
44126 if (argc == 3) {
44127 int _v;
44128 {
44129 void *ptr;
44130 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44131 _v = 0;
44132 PyErr_Clear();
44133 } else {
44134 _v = 1;
44135 }
44136 }
44137 if (_v) {
44138 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44139 if (_v) {
44140 {
44141 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44142 }
44143 if (_v) {
44144 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44145 }
44146 }
44147 }
44148 }
44149
44150 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44151 return NULL;
44152 }
44153
44154
44155 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44156 PyObject *resultobj;
44157 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44158 wxWindow *arg2 = (wxWindow *) 0 ;
44159 wxGBSpan result;
44160 PyObject * obj0 = 0 ;
44161 PyObject * obj1 = 0 ;
44162
44163 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44165 if (SWIG_arg_fail(1)) SWIG_fail;
44166 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44167 if (SWIG_arg_fail(2)) SWIG_fail;
44168 {
44169 PyThreadState* __tstate = wxPyBeginAllowThreads();
44170 result = (arg1)->GetItemSpan(arg2);
44171
44172 wxPyEndAllowThreads(__tstate);
44173 if (PyErr_Occurred()) SWIG_fail;
44174 }
44175 {
44176 wxGBSpan * resultptr;
44177 resultptr = new wxGBSpan((wxGBSpan &)(result));
44178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44179 }
44180 return resultobj;
44181 fail:
44182 return NULL;
44183 }
44184
44185
44186 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44187 PyObject *resultobj;
44188 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44189 wxSizer *arg2 = (wxSizer *) 0 ;
44190 wxGBSpan result;
44191 PyObject * obj0 = 0 ;
44192 PyObject * obj1 = 0 ;
44193
44194 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44196 if (SWIG_arg_fail(1)) SWIG_fail;
44197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44198 if (SWIG_arg_fail(2)) SWIG_fail;
44199 {
44200 PyThreadState* __tstate = wxPyBeginAllowThreads();
44201 result = (arg1)->GetItemSpan(arg2);
44202
44203 wxPyEndAllowThreads(__tstate);
44204 if (PyErr_Occurred()) SWIG_fail;
44205 }
44206 {
44207 wxGBSpan * resultptr;
44208 resultptr = new wxGBSpan((wxGBSpan &)(result));
44209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44210 }
44211 return resultobj;
44212 fail:
44213 return NULL;
44214 }
44215
44216
44217 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44218 PyObject *resultobj;
44219 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44220 size_t arg2 ;
44221 wxGBSpan result;
44222 PyObject * obj0 = 0 ;
44223 PyObject * obj1 = 0 ;
44224
44225 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44227 if (SWIG_arg_fail(1)) SWIG_fail;
44228 {
44229 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44230 if (SWIG_arg_fail(2)) SWIG_fail;
44231 }
44232 {
44233 PyThreadState* __tstate = wxPyBeginAllowThreads();
44234 result = (arg1)->GetItemSpan(arg2);
44235
44236 wxPyEndAllowThreads(__tstate);
44237 if (PyErr_Occurred()) SWIG_fail;
44238 }
44239 {
44240 wxGBSpan * resultptr;
44241 resultptr = new wxGBSpan((wxGBSpan &)(result));
44242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44243 }
44244 return resultobj;
44245 fail:
44246 return NULL;
44247 }
44248
44249
44250 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44251 int argc;
44252 PyObject *argv[3];
44253 int ii;
44254
44255 argc = PyObject_Length(args);
44256 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44257 argv[ii] = PyTuple_GetItem(args,ii);
44258 }
44259 if (argc == 2) {
44260 int _v;
44261 {
44262 void *ptr;
44263 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44264 _v = 0;
44265 PyErr_Clear();
44266 } else {
44267 _v = 1;
44268 }
44269 }
44270 if (_v) {
44271 {
44272 void *ptr;
44273 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44274 _v = 0;
44275 PyErr_Clear();
44276 } else {
44277 _v = 1;
44278 }
44279 }
44280 if (_v) {
44281 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44282 }
44283 }
44284 }
44285 if (argc == 2) {
44286 int _v;
44287 {
44288 void *ptr;
44289 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44290 _v = 0;
44291 PyErr_Clear();
44292 } else {
44293 _v = 1;
44294 }
44295 }
44296 if (_v) {
44297 {
44298 void *ptr;
44299 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44300 _v = 0;
44301 PyErr_Clear();
44302 } else {
44303 _v = 1;
44304 }
44305 }
44306 if (_v) {
44307 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44308 }
44309 }
44310 }
44311 if (argc == 2) {
44312 int _v;
44313 {
44314 void *ptr;
44315 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44316 _v = 0;
44317 PyErr_Clear();
44318 } else {
44319 _v = 1;
44320 }
44321 }
44322 if (_v) {
44323 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44324 if (_v) {
44325 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44326 }
44327 }
44328 }
44329
44330 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44331 return NULL;
44332 }
44333
44334
44335 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44336 PyObject *resultobj;
44337 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44338 wxWindow *arg2 = (wxWindow *) 0 ;
44339 wxGBSpan *arg3 = 0 ;
44340 bool result;
44341 wxGBSpan temp3 ;
44342 PyObject * obj0 = 0 ;
44343 PyObject * obj1 = 0 ;
44344 PyObject * obj2 = 0 ;
44345
44346 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44348 if (SWIG_arg_fail(1)) SWIG_fail;
44349 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44350 if (SWIG_arg_fail(2)) SWIG_fail;
44351 {
44352 arg3 = &temp3;
44353 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44354 }
44355 {
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44358
44359 wxPyEndAllowThreads(__tstate);
44360 if (PyErr_Occurred()) SWIG_fail;
44361 }
44362 {
44363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44364 }
44365 return resultobj;
44366 fail:
44367 return NULL;
44368 }
44369
44370
44371 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44372 PyObject *resultobj;
44373 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44374 wxSizer *arg2 = (wxSizer *) 0 ;
44375 wxGBSpan *arg3 = 0 ;
44376 bool result;
44377 wxGBSpan temp3 ;
44378 PyObject * obj0 = 0 ;
44379 PyObject * obj1 = 0 ;
44380 PyObject * obj2 = 0 ;
44381
44382 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44384 if (SWIG_arg_fail(1)) SWIG_fail;
44385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44386 if (SWIG_arg_fail(2)) SWIG_fail;
44387 {
44388 arg3 = &temp3;
44389 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44390 }
44391 {
44392 PyThreadState* __tstate = wxPyBeginAllowThreads();
44393 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44394
44395 wxPyEndAllowThreads(__tstate);
44396 if (PyErr_Occurred()) SWIG_fail;
44397 }
44398 {
44399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44400 }
44401 return resultobj;
44402 fail:
44403 return NULL;
44404 }
44405
44406
44407 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44408 PyObject *resultobj;
44409 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44410 size_t arg2 ;
44411 wxGBSpan *arg3 = 0 ;
44412 bool result;
44413 wxGBSpan temp3 ;
44414 PyObject * obj0 = 0 ;
44415 PyObject * obj1 = 0 ;
44416 PyObject * obj2 = 0 ;
44417
44418 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44420 if (SWIG_arg_fail(1)) SWIG_fail;
44421 {
44422 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44423 if (SWIG_arg_fail(2)) SWIG_fail;
44424 }
44425 {
44426 arg3 = &temp3;
44427 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44428 }
44429 {
44430 PyThreadState* __tstate = wxPyBeginAllowThreads();
44431 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44432
44433 wxPyEndAllowThreads(__tstate);
44434 if (PyErr_Occurred()) SWIG_fail;
44435 }
44436 {
44437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44438 }
44439 return resultobj;
44440 fail:
44441 return NULL;
44442 }
44443
44444
44445 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44446 int argc;
44447 PyObject *argv[4];
44448 int ii;
44449
44450 argc = PyObject_Length(args);
44451 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44452 argv[ii] = PyTuple_GetItem(args,ii);
44453 }
44454 if (argc == 3) {
44455 int _v;
44456 {
44457 void *ptr;
44458 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44459 _v = 0;
44460 PyErr_Clear();
44461 } else {
44462 _v = 1;
44463 }
44464 }
44465 if (_v) {
44466 {
44467 void *ptr;
44468 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44469 _v = 0;
44470 PyErr_Clear();
44471 } else {
44472 _v = 1;
44473 }
44474 }
44475 if (_v) {
44476 {
44477 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44478 }
44479 if (_v) {
44480 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44481 }
44482 }
44483 }
44484 }
44485 if (argc == 3) {
44486 int _v;
44487 {
44488 void *ptr;
44489 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44490 _v = 0;
44491 PyErr_Clear();
44492 } else {
44493 _v = 1;
44494 }
44495 }
44496 if (_v) {
44497 {
44498 void *ptr;
44499 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44500 _v = 0;
44501 PyErr_Clear();
44502 } else {
44503 _v = 1;
44504 }
44505 }
44506 if (_v) {
44507 {
44508 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44509 }
44510 if (_v) {
44511 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44512 }
44513 }
44514 }
44515 }
44516 if (argc == 3) {
44517 int _v;
44518 {
44519 void *ptr;
44520 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44521 _v = 0;
44522 PyErr_Clear();
44523 } else {
44524 _v = 1;
44525 }
44526 }
44527 if (_v) {
44528 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44529 if (_v) {
44530 {
44531 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44532 }
44533 if (_v) {
44534 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44535 }
44536 }
44537 }
44538 }
44539
44540 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44541 return NULL;
44542 }
44543
44544
44545 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44546 PyObject *resultobj;
44547 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44548 wxWindow *arg2 = (wxWindow *) 0 ;
44549 wxGBSizerItem *result;
44550 PyObject * obj0 = 0 ;
44551 PyObject * obj1 = 0 ;
44552
44553 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44555 if (SWIG_arg_fail(1)) SWIG_fail;
44556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44557 if (SWIG_arg_fail(2)) SWIG_fail;
44558 {
44559 PyThreadState* __tstate = wxPyBeginAllowThreads();
44560 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44561
44562 wxPyEndAllowThreads(__tstate);
44563 if (PyErr_Occurred()) SWIG_fail;
44564 }
44565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44566 return resultobj;
44567 fail:
44568 return NULL;
44569 }
44570
44571
44572 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44573 PyObject *resultobj;
44574 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44575 wxSizer *arg2 = (wxSizer *) 0 ;
44576 wxGBSizerItem *result;
44577 PyObject * obj0 = 0 ;
44578 PyObject * obj1 = 0 ;
44579
44580 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44582 if (SWIG_arg_fail(1)) SWIG_fail;
44583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44584 if (SWIG_arg_fail(2)) SWIG_fail;
44585 {
44586 PyThreadState* __tstate = wxPyBeginAllowThreads();
44587 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44588
44589 wxPyEndAllowThreads(__tstate);
44590 if (PyErr_Occurred()) SWIG_fail;
44591 }
44592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44593 return resultobj;
44594 fail:
44595 return NULL;
44596 }
44597
44598
44599 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44600 int argc;
44601 PyObject *argv[3];
44602 int ii;
44603
44604 argc = PyObject_Length(args);
44605 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44606 argv[ii] = PyTuple_GetItem(args,ii);
44607 }
44608 if (argc == 2) {
44609 int _v;
44610 {
44611 void *ptr;
44612 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44613 _v = 0;
44614 PyErr_Clear();
44615 } else {
44616 _v = 1;
44617 }
44618 }
44619 if (_v) {
44620 {
44621 void *ptr;
44622 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44623 _v = 0;
44624 PyErr_Clear();
44625 } else {
44626 _v = 1;
44627 }
44628 }
44629 if (_v) {
44630 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44631 }
44632 }
44633 }
44634 if (argc == 2) {
44635 int _v;
44636 {
44637 void *ptr;
44638 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44639 _v = 0;
44640 PyErr_Clear();
44641 } else {
44642 _v = 1;
44643 }
44644 }
44645 if (_v) {
44646 {
44647 void *ptr;
44648 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44649 _v = 0;
44650 PyErr_Clear();
44651 } else {
44652 _v = 1;
44653 }
44654 }
44655 if (_v) {
44656 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44657 }
44658 }
44659 }
44660
44661 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44662 return NULL;
44663 }
44664
44665
44666 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44667 PyObject *resultobj;
44668 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44669 wxGBPosition *arg2 = 0 ;
44670 wxGBSizerItem *result;
44671 wxGBPosition temp2 ;
44672 PyObject * obj0 = 0 ;
44673 PyObject * obj1 = 0 ;
44674 char *kwnames[] = {
44675 (char *) "self",(char *) "pos", NULL
44676 };
44677
44678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44680 if (SWIG_arg_fail(1)) SWIG_fail;
44681 {
44682 arg2 = &temp2;
44683 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44684 }
44685 {
44686 PyThreadState* __tstate = wxPyBeginAllowThreads();
44687 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44688
44689 wxPyEndAllowThreads(__tstate);
44690 if (PyErr_Occurred()) SWIG_fail;
44691 }
44692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44693 return resultobj;
44694 fail:
44695 return NULL;
44696 }
44697
44698
44699 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44700 PyObject *resultobj;
44701 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44702 wxPoint *arg2 = 0 ;
44703 wxGBSizerItem *result;
44704 wxPoint temp2 ;
44705 PyObject * obj0 = 0 ;
44706 PyObject * obj1 = 0 ;
44707 char *kwnames[] = {
44708 (char *) "self",(char *) "pt", NULL
44709 };
44710
44711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44713 if (SWIG_arg_fail(1)) SWIG_fail;
44714 {
44715 arg2 = &temp2;
44716 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44717 }
44718 {
44719 PyThreadState* __tstate = wxPyBeginAllowThreads();
44720 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44721
44722 wxPyEndAllowThreads(__tstate);
44723 if (PyErr_Occurred()) SWIG_fail;
44724 }
44725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44726 return resultobj;
44727 fail:
44728 return NULL;
44729 }
44730
44731
44732 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44733 PyObject *resultobj;
44734 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44735 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44736 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44737 bool result;
44738 PyObject * obj0 = 0 ;
44739 PyObject * obj1 = 0 ;
44740 PyObject * obj2 = 0 ;
44741 char *kwnames[] = {
44742 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44743 };
44744
44745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44747 if (SWIG_arg_fail(1)) SWIG_fail;
44748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44749 if (SWIG_arg_fail(2)) SWIG_fail;
44750 if (obj2) {
44751 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44752 if (SWIG_arg_fail(3)) SWIG_fail;
44753 }
44754 {
44755 PyThreadState* __tstate = wxPyBeginAllowThreads();
44756 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44757
44758 wxPyEndAllowThreads(__tstate);
44759 if (PyErr_Occurred()) SWIG_fail;
44760 }
44761 {
44762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44763 }
44764 return resultobj;
44765 fail:
44766 return NULL;
44767 }
44768
44769
44770 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44771 PyObject *resultobj;
44772 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44773 wxGBPosition *arg2 = 0 ;
44774 wxGBSpan *arg3 = 0 ;
44775 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44776 bool result;
44777 wxGBPosition temp2 ;
44778 wxGBSpan temp3 ;
44779 PyObject * obj0 = 0 ;
44780 PyObject * obj1 = 0 ;
44781 PyObject * obj2 = 0 ;
44782 PyObject * obj3 = 0 ;
44783 char *kwnames[] = {
44784 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44785 };
44786
44787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44789 if (SWIG_arg_fail(1)) SWIG_fail;
44790 {
44791 arg2 = &temp2;
44792 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44793 }
44794 {
44795 arg3 = &temp3;
44796 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44797 }
44798 if (obj3) {
44799 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44800 if (SWIG_arg_fail(4)) SWIG_fail;
44801 }
44802 {
44803 PyThreadState* __tstate = wxPyBeginAllowThreads();
44804 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44805
44806 wxPyEndAllowThreads(__tstate);
44807 if (PyErr_Occurred()) SWIG_fail;
44808 }
44809 {
44810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44811 }
44812 return resultobj;
44813 fail:
44814 return NULL;
44815 }
44816
44817
44818 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44819 PyObject *obj;
44820 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44821 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44822 Py_INCREF(obj);
44823 return Py_BuildValue((char *)"");
44824 }
44825 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44826 PyObject *resultobj;
44827 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44828 wxRelationship arg2 ;
44829 wxWindow *arg3 = (wxWindow *) 0 ;
44830 wxEdge arg4 ;
44831 int arg5 = (int) 0 ;
44832 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44833 PyObject * obj0 = 0 ;
44834 PyObject * obj1 = 0 ;
44835 PyObject * obj2 = 0 ;
44836 PyObject * obj3 = 0 ;
44837 PyObject * obj4 = 0 ;
44838 PyObject * obj5 = 0 ;
44839 char *kwnames[] = {
44840 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44841 };
44842
44843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44845 if (SWIG_arg_fail(1)) SWIG_fail;
44846 {
44847 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44848 if (SWIG_arg_fail(2)) SWIG_fail;
44849 }
44850 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44851 if (SWIG_arg_fail(3)) SWIG_fail;
44852 {
44853 arg4 = (wxEdge)(SWIG_As_int(obj3));
44854 if (SWIG_arg_fail(4)) SWIG_fail;
44855 }
44856 if (obj4) {
44857 {
44858 arg5 = (int)(SWIG_As_int(obj4));
44859 if (SWIG_arg_fail(5)) SWIG_fail;
44860 }
44861 }
44862 if (obj5) {
44863 {
44864 arg6 = (int)(SWIG_As_int(obj5));
44865 if (SWIG_arg_fail(6)) SWIG_fail;
44866 }
44867 }
44868 {
44869 PyThreadState* __tstate = wxPyBeginAllowThreads();
44870 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44871
44872 wxPyEndAllowThreads(__tstate);
44873 if (PyErr_Occurred()) SWIG_fail;
44874 }
44875 Py_INCREF(Py_None); resultobj = Py_None;
44876 return resultobj;
44877 fail:
44878 return NULL;
44879 }
44880
44881
44882 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44883 PyObject *resultobj;
44884 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44885 wxWindow *arg2 = (wxWindow *) 0 ;
44886 int arg3 = (int) 0 ;
44887 PyObject * obj0 = 0 ;
44888 PyObject * obj1 = 0 ;
44889 PyObject * obj2 = 0 ;
44890 char *kwnames[] = {
44891 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44892 };
44893
44894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44896 if (SWIG_arg_fail(1)) SWIG_fail;
44897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44898 if (SWIG_arg_fail(2)) SWIG_fail;
44899 if (obj2) {
44900 {
44901 arg3 = (int)(SWIG_As_int(obj2));
44902 if (SWIG_arg_fail(3)) SWIG_fail;
44903 }
44904 }
44905 {
44906 PyThreadState* __tstate = wxPyBeginAllowThreads();
44907 (arg1)->LeftOf(arg2,arg3);
44908
44909 wxPyEndAllowThreads(__tstate);
44910 if (PyErr_Occurred()) SWIG_fail;
44911 }
44912 Py_INCREF(Py_None); resultobj = Py_None;
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44920 PyObject *resultobj;
44921 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44922 wxWindow *arg2 = (wxWindow *) 0 ;
44923 int arg3 = (int) 0 ;
44924 PyObject * obj0 = 0 ;
44925 PyObject * obj1 = 0 ;
44926 PyObject * obj2 = 0 ;
44927 char *kwnames[] = {
44928 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44929 };
44930
44931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44933 if (SWIG_arg_fail(1)) SWIG_fail;
44934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44935 if (SWIG_arg_fail(2)) SWIG_fail;
44936 if (obj2) {
44937 {
44938 arg3 = (int)(SWIG_As_int(obj2));
44939 if (SWIG_arg_fail(3)) SWIG_fail;
44940 }
44941 }
44942 {
44943 PyThreadState* __tstate = wxPyBeginAllowThreads();
44944 (arg1)->RightOf(arg2,arg3);
44945
44946 wxPyEndAllowThreads(__tstate);
44947 if (PyErr_Occurred()) SWIG_fail;
44948 }
44949 Py_INCREF(Py_None); resultobj = Py_None;
44950 return resultobj;
44951 fail:
44952 return NULL;
44953 }
44954
44955
44956 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44957 PyObject *resultobj;
44958 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44959 wxWindow *arg2 = (wxWindow *) 0 ;
44960 int arg3 = (int) 0 ;
44961 PyObject * obj0 = 0 ;
44962 PyObject * obj1 = 0 ;
44963 PyObject * obj2 = 0 ;
44964 char *kwnames[] = {
44965 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44966 };
44967
44968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44970 if (SWIG_arg_fail(1)) SWIG_fail;
44971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44972 if (SWIG_arg_fail(2)) SWIG_fail;
44973 if (obj2) {
44974 {
44975 arg3 = (int)(SWIG_As_int(obj2));
44976 if (SWIG_arg_fail(3)) SWIG_fail;
44977 }
44978 }
44979 {
44980 PyThreadState* __tstate = wxPyBeginAllowThreads();
44981 (arg1)->Above(arg2,arg3);
44982
44983 wxPyEndAllowThreads(__tstate);
44984 if (PyErr_Occurred()) SWIG_fail;
44985 }
44986 Py_INCREF(Py_None); resultobj = Py_None;
44987 return resultobj;
44988 fail:
44989 return NULL;
44990 }
44991
44992
44993 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44994 PyObject *resultobj;
44995 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44996 wxWindow *arg2 = (wxWindow *) 0 ;
44997 int arg3 = (int) 0 ;
44998 PyObject * obj0 = 0 ;
44999 PyObject * obj1 = 0 ;
45000 PyObject * obj2 = 0 ;
45001 char *kwnames[] = {
45002 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45003 };
45004
45005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45007 if (SWIG_arg_fail(1)) SWIG_fail;
45008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45009 if (SWIG_arg_fail(2)) SWIG_fail;
45010 if (obj2) {
45011 {
45012 arg3 = (int)(SWIG_As_int(obj2));
45013 if (SWIG_arg_fail(3)) SWIG_fail;
45014 }
45015 }
45016 {
45017 PyThreadState* __tstate = wxPyBeginAllowThreads();
45018 (arg1)->Below(arg2,arg3);
45019
45020 wxPyEndAllowThreads(__tstate);
45021 if (PyErr_Occurred()) SWIG_fail;
45022 }
45023 Py_INCREF(Py_None); resultobj = Py_None;
45024 return resultobj;
45025 fail:
45026 return NULL;
45027 }
45028
45029
45030 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45031 PyObject *resultobj;
45032 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45033 wxWindow *arg2 = (wxWindow *) 0 ;
45034 wxEdge arg3 ;
45035 int arg4 = (int) 0 ;
45036 PyObject * obj0 = 0 ;
45037 PyObject * obj1 = 0 ;
45038 PyObject * obj2 = 0 ;
45039 PyObject * obj3 = 0 ;
45040 char *kwnames[] = {
45041 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45042 };
45043
45044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45046 if (SWIG_arg_fail(1)) SWIG_fail;
45047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45048 if (SWIG_arg_fail(2)) SWIG_fail;
45049 {
45050 arg3 = (wxEdge)(SWIG_As_int(obj2));
45051 if (SWIG_arg_fail(3)) SWIG_fail;
45052 }
45053 if (obj3) {
45054 {
45055 arg4 = (int)(SWIG_As_int(obj3));
45056 if (SWIG_arg_fail(4)) SWIG_fail;
45057 }
45058 }
45059 {
45060 PyThreadState* __tstate = wxPyBeginAllowThreads();
45061 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
45062
45063 wxPyEndAllowThreads(__tstate);
45064 if (PyErr_Occurred()) SWIG_fail;
45065 }
45066 Py_INCREF(Py_None); resultobj = Py_None;
45067 return resultobj;
45068 fail:
45069 return NULL;
45070 }
45071
45072
45073 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45074 PyObject *resultobj;
45075 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45076 wxWindow *arg2 = (wxWindow *) 0 ;
45077 wxEdge arg3 ;
45078 int arg4 ;
45079 PyObject * obj0 = 0 ;
45080 PyObject * obj1 = 0 ;
45081 PyObject * obj2 = 0 ;
45082 PyObject * obj3 = 0 ;
45083 char *kwnames[] = {
45084 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45085 };
45086
45087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45089 if (SWIG_arg_fail(1)) SWIG_fail;
45090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45091 if (SWIG_arg_fail(2)) SWIG_fail;
45092 {
45093 arg3 = (wxEdge)(SWIG_As_int(obj2));
45094 if (SWIG_arg_fail(3)) SWIG_fail;
45095 }
45096 {
45097 arg4 = (int)(SWIG_As_int(obj3));
45098 if (SWIG_arg_fail(4)) SWIG_fail;
45099 }
45100 {
45101 PyThreadState* __tstate = wxPyBeginAllowThreads();
45102 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
45103
45104 wxPyEndAllowThreads(__tstate);
45105 if (PyErr_Occurred()) SWIG_fail;
45106 }
45107 Py_INCREF(Py_None); resultobj = Py_None;
45108 return resultobj;
45109 fail:
45110 return NULL;
45111 }
45112
45113
45114 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45115 PyObject *resultobj;
45116 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45117 int arg2 ;
45118 PyObject * obj0 = 0 ;
45119 PyObject * obj1 = 0 ;
45120 char *kwnames[] = {
45121 (char *) "self",(char *) "val", NULL
45122 };
45123
45124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45126 if (SWIG_arg_fail(1)) SWIG_fail;
45127 {
45128 arg2 = (int)(SWIG_As_int(obj1));
45129 if (SWIG_arg_fail(2)) SWIG_fail;
45130 }
45131 {
45132 PyThreadState* __tstate = wxPyBeginAllowThreads();
45133 (arg1)->Absolute(arg2);
45134
45135 wxPyEndAllowThreads(__tstate);
45136 if (PyErr_Occurred()) SWIG_fail;
45137 }
45138 Py_INCREF(Py_None); resultobj = Py_None;
45139 return resultobj;
45140 fail:
45141 return NULL;
45142 }
45143
45144
45145 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45146 PyObject *resultobj;
45147 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45148 PyObject * obj0 = 0 ;
45149 char *kwnames[] = {
45150 (char *) "self", NULL
45151 };
45152
45153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45155 if (SWIG_arg_fail(1)) SWIG_fail;
45156 {
45157 PyThreadState* __tstate = wxPyBeginAllowThreads();
45158 (arg1)->Unconstrained();
45159
45160 wxPyEndAllowThreads(__tstate);
45161 if (PyErr_Occurred()) SWIG_fail;
45162 }
45163 Py_INCREF(Py_None); resultobj = Py_None;
45164 return resultobj;
45165 fail:
45166 return NULL;
45167 }
45168
45169
45170 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45171 PyObject *resultobj;
45172 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45173 PyObject * obj0 = 0 ;
45174 char *kwnames[] = {
45175 (char *) "self", NULL
45176 };
45177
45178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45180 if (SWIG_arg_fail(1)) SWIG_fail;
45181 {
45182 PyThreadState* __tstate = wxPyBeginAllowThreads();
45183 (arg1)->AsIs();
45184
45185 wxPyEndAllowThreads(__tstate);
45186 if (PyErr_Occurred()) SWIG_fail;
45187 }
45188 Py_INCREF(Py_None); resultobj = Py_None;
45189 return resultobj;
45190 fail:
45191 return NULL;
45192 }
45193
45194
45195 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45196 PyObject *resultobj;
45197 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45198 wxWindow *result;
45199 PyObject * obj0 = 0 ;
45200 char *kwnames[] = {
45201 (char *) "self", NULL
45202 };
45203
45204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45206 if (SWIG_arg_fail(1)) SWIG_fail;
45207 {
45208 PyThreadState* __tstate = wxPyBeginAllowThreads();
45209 result = (wxWindow *)(arg1)->GetOtherWindow();
45210
45211 wxPyEndAllowThreads(__tstate);
45212 if (PyErr_Occurred()) SWIG_fail;
45213 }
45214 {
45215 resultobj = wxPyMake_wxObject(result, 0);
45216 }
45217 return resultobj;
45218 fail:
45219 return NULL;
45220 }
45221
45222
45223 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45224 PyObject *resultobj;
45225 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45226 wxEdge result;
45227 PyObject * obj0 = 0 ;
45228 char *kwnames[] = {
45229 (char *) "self", NULL
45230 };
45231
45232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45234 if (SWIG_arg_fail(1)) SWIG_fail;
45235 {
45236 PyThreadState* __tstate = wxPyBeginAllowThreads();
45237 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45238
45239 wxPyEndAllowThreads(__tstate);
45240 if (PyErr_Occurred()) SWIG_fail;
45241 }
45242 resultobj = SWIG_From_int((result));
45243 return resultobj;
45244 fail:
45245 return NULL;
45246 }
45247
45248
45249 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45250 PyObject *resultobj;
45251 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45252 wxEdge arg2 ;
45253 PyObject * obj0 = 0 ;
45254 PyObject * obj1 = 0 ;
45255 char *kwnames[] = {
45256 (char *) "self",(char *) "which", NULL
45257 };
45258
45259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45261 if (SWIG_arg_fail(1)) SWIG_fail;
45262 {
45263 arg2 = (wxEdge)(SWIG_As_int(obj1));
45264 if (SWIG_arg_fail(2)) SWIG_fail;
45265 }
45266 {
45267 PyThreadState* __tstate = wxPyBeginAllowThreads();
45268 (arg1)->SetEdge((wxEdge )arg2);
45269
45270 wxPyEndAllowThreads(__tstate);
45271 if (PyErr_Occurred()) SWIG_fail;
45272 }
45273 Py_INCREF(Py_None); resultobj = Py_None;
45274 return resultobj;
45275 fail:
45276 return NULL;
45277 }
45278
45279
45280 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45281 PyObject *resultobj;
45282 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45283 int arg2 ;
45284 PyObject * obj0 = 0 ;
45285 PyObject * obj1 = 0 ;
45286 char *kwnames[] = {
45287 (char *) "self",(char *) "v", NULL
45288 };
45289
45290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45292 if (SWIG_arg_fail(1)) SWIG_fail;
45293 {
45294 arg2 = (int)(SWIG_As_int(obj1));
45295 if (SWIG_arg_fail(2)) SWIG_fail;
45296 }
45297 {
45298 PyThreadState* __tstate = wxPyBeginAllowThreads();
45299 (arg1)->SetValue(arg2);
45300
45301 wxPyEndAllowThreads(__tstate);
45302 if (PyErr_Occurred()) SWIG_fail;
45303 }
45304 Py_INCREF(Py_None); resultobj = Py_None;
45305 return resultobj;
45306 fail:
45307 return NULL;
45308 }
45309
45310
45311 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45312 PyObject *resultobj;
45313 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45314 int result;
45315 PyObject * obj0 = 0 ;
45316 char *kwnames[] = {
45317 (char *) "self", NULL
45318 };
45319
45320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45322 if (SWIG_arg_fail(1)) SWIG_fail;
45323 {
45324 PyThreadState* __tstate = wxPyBeginAllowThreads();
45325 result = (int)(arg1)->GetMargin();
45326
45327 wxPyEndAllowThreads(__tstate);
45328 if (PyErr_Occurred()) SWIG_fail;
45329 }
45330 {
45331 resultobj = SWIG_From_int((int)(result));
45332 }
45333 return resultobj;
45334 fail:
45335 return NULL;
45336 }
45337
45338
45339 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45340 PyObject *resultobj;
45341 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45342 int arg2 ;
45343 PyObject * obj0 = 0 ;
45344 PyObject * obj1 = 0 ;
45345 char *kwnames[] = {
45346 (char *) "self",(char *) "m", NULL
45347 };
45348
45349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45351 if (SWIG_arg_fail(1)) SWIG_fail;
45352 {
45353 arg2 = (int)(SWIG_As_int(obj1));
45354 if (SWIG_arg_fail(2)) SWIG_fail;
45355 }
45356 {
45357 PyThreadState* __tstate = wxPyBeginAllowThreads();
45358 (arg1)->SetMargin(arg2);
45359
45360 wxPyEndAllowThreads(__tstate);
45361 if (PyErr_Occurred()) SWIG_fail;
45362 }
45363 Py_INCREF(Py_None); resultobj = Py_None;
45364 return resultobj;
45365 fail:
45366 return NULL;
45367 }
45368
45369
45370 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45371 PyObject *resultobj;
45372 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45373 int result;
45374 PyObject * obj0 = 0 ;
45375 char *kwnames[] = {
45376 (char *) "self", NULL
45377 };
45378
45379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45381 if (SWIG_arg_fail(1)) SWIG_fail;
45382 {
45383 PyThreadState* __tstate = wxPyBeginAllowThreads();
45384 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45385
45386 wxPyEndAllowThreads(__tstate);
45387 if (PyErr_Occurred()) SWIG_fail;
45388 }
45389 {
45390 resultobj = SWIG_From_int((int)(result));
45391 }
45392 return resultobj;
45393 fail:
45394 return NULL;
45395 }
45396
45397
45398 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45399 PyObject *resultobj;
45400 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45401 int result;
45402 PyObject * obj0 = 0 ;
45403 char *kwnames[] = {
45404 (char *) "self", NULL
45405 };
45406
45407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45409 if (SWIG_arg_fail(1)) SWIG_fail;
45410 {
45411 PyThreadState* __tstate = wxPyBeginAllowThreads();
45412 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45413
45414 wxPyEndAllowThreads(__tstate);
45415 if (PyErr_Occurred()) SWIG_fail;
45416 }
45417 {
45418 resultobj = SWIG_From_int((int)(result));
45419 }
45420 return resultobj;
45421 fail:
45422 return NULL;
45423 }
45424
45425
45426 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45427 PyObject *resultobj;
45428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45429 int result;
45430 PyObject * obj0 = 0 ;
45431 char *kwnames[] = {
45432 (char *) "self", NULL
45433 };
45434
45435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45437 if (SWIG_arg_fail(1)) SWIG_fail;
45438 {
45439 PyThreadState* __tstate = wxPyBeginAllowThreads();
45440 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45441
45442 wxPyEndAllowThreads(__tstate);
45443 if (PyErr_Occurred()) SWIG_fail;
45444 }
45445 {
45446 resultobj = SWIG_From_int((int)(result));
45447 }
45448 return resultobj;
45449 fail:
45450 return NULL;
45451 }
45452
45453
45454 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45455 PyObject *resultobj;
45456 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45457 bool result;
45458 PyObject * obj0 = 0 ;
45459 char *kwnames[] = {
45460 (char *) "self", NULL
45461 };
45462
45463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45465 if (SWIG_arg_fail(1)) SWIG_fail;
45466 {
45467 PyThreadState* __tstate = wxPyBeginAllowThreads();
45468 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45469
45470 wxPyEndAllowThreads(__tstate);
45471 if (PyErr_Occurred()) SWIG_fail;
45472 }
45473 {
45474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45475 }
45476 return resultobj;
45477 fail:
45478 return NULL;
45479 }
45480
45481
45482 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45483 PyObject *resultobj;
45484 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45485 bool arg2 ;
45486 PyObject * obj0 = 0 ;
45487 PyObject * obj1 = 0 ;
45488 char *kwnames[] = {
45489 (char *) "self",(char *) "d", NULL
45490 };
45491
45492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45494 if (SWIG_arg_fail(1)) SWIG_fail;
45495 {
45496 arg2 = (bool)(SWIG_As_bool(obj1));
45497 if (SWIG_arg_fail(2)) SWIG_fail;
45498 }
45499 {
45500 PyThreadState* __tstate = wxPyBeginAllowThreads();
45501 (arg1)->SetDone(arg2);
45502
45503 wxPyEndAllowThreads(__tstate);
45504 if (PyErr_Occurred()) SWIG_fail;
45505 }
45506 Py_INCREF(Py_None); resultobj = Py_None;
45507 return resultobj;
45508 fail:
45509 return NULL;
45510 }
45511
45512
45513 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45514 PyObject *resultobj;
45515 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45516 wxRelationship result;
45517 PyObject * obj0 = 0 ;
45518 char *kwnames[] = {
45519 (char *) "self", NULL
45520 };
45521
45522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45524 if (SWIG_arg_fail(1)) SWIG_fail;
45525 {
45526 PyThreadState* __tstate = wxPyBeginAllowThreads();
45527 result = (wxRelationship)(arg1)->GetRelationship();
45528
45529 wxPyEndAllowThreads(__tstate);
45530 if (PyErr_Occurred()) SWIG_fail;
45531 }
45532 resultobj = SWIG_From_int((result));
45533 return resultobj;
45534 fail:
45535 return NULL;
45536 }
45537
45538
45539 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45540 PyObject *resultobj;
45541 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45542 wxRelationship arg2 ;
45543 PyObject * obj0 = 0 ;
45544 PyObject * obj1 = 0 ;
45545 char *kwnames[] = {
45546 (char *) "self",(char *) "r", NULL
45547 };
45548
45549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45551 if (SWIG_arg_fail(1)) SWIG_fail;
45552 {
45553 arg2 = (wxRelationship)(SWIG_As_int(obj1));
45554 if (SWIG_arg_fail(2)) SWIG_fail;
45555 }
45556 {
45557 PyThreadState* __tstate = wxPyBeginAllowThreads();
45558 (arg1)->SetRelationship((wxRelationship )arg2);
45559
45560 wxPyEndAllowThreads(__tstate);
45561 if (PyErr_Occurred()) SWIG_fail;
45562 }
45563 Py_INCREF(Py_None); resultobj = Py_None;
45564 return resultobj;
45565 fail:
45566 return NULL;
45567 }
45568
45569
45570 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45571 PyObject *resultobj;
45572 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45573 wxWindow *arg2 = (wxWindow *) 0 ;
45574 bool result;
45575 PyObject * obj0 = 0 ;
45576 PyObject * obj1 = 0 ;
45577 char *kwnames[] = {
45578 (char *) "self",(char *) "otherW", NULL
45579 };
45580
45581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45583 if (SWIG_arg_fail(1)) SWIG_fail;
45584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45585 if (SWIG_arg_fail(2)) SWIG_fail;
45586 {
45587 PyThreadState* __tstate = wxPyBeginAllowThreads();
45588 result = (bool)(arg1)->ResetIfWin(arg2);
45589
45590 wxPyEndAllowThreads(__tstate);
45591 if (PyErr_Occurred()) SWIG_fail;
45592 }
45593 {
45594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45595 }
45596 return resultobj;
45597 fail:
45598 return NULL;
45599 }
45600
45601
45602 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45603 PyObject *resultobj;
45604 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45605 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45606 wxWindow *arg3 = (wxWindow *) 0 ;
45607 bool result;
45608 PyObject * obj0 = 0 ;
45609 PyObject * obj1 = 0 ;
45610 PyObject * obj2 = 0 ;
45611 char *kwnames[] = {
45612 (char *) "self",(char *) "constraints",(char *) "win", NULL
45613 };
45614
45615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45617 if (SWIG_arg_fail(1)) SWIG_fail;
45618 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45619 if (SWIG_arg_fail(2)) SWIG_fail;
45620 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45621 if (SWIG_arg_fail(3)) SWIG_fail;
45622 {
45623 PyThreadState* __tstate = wxPyBeginAllowThreads();
45624 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45625
45626 wxPyEndAllowThreads(__tstate);
45627 if (PyErr_Occurred()) SWIG_fail;
45628 }
45629 {
45630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45631 }
45632 return resultobj;
45633 fail:
45634 return NULL;
45635 }
45636
45637
45638 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45639 PyObject *resultobj;
45640 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45641 wxEdge arg2 ;
45642 wxWindow *arg3 = (wxWindow *) 0 ;
45643 wxWindow *arg4 = (wxWindow *) 0 ;
45644 int result;
45645 PyObject * obj0 = 0 ;
45646 PyObject * obj1 = 0 ;
45647 PyObject * obj2 = 0 ;
45648 PyObject * obj3 = 0 ;
45649 char *kwnames[] = {
45650 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45651 };
45652
45653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45655 if (SWIG_arg_fail(1)) SWIG_fail;
45656 {
45657 arg2 = (wxEdge)(SWIG_As_int(obj1));
45658 if (SWIG_arg_fail(2)) SWIG_fail;
45659 }
45660 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45661 if (SWIG_arg_fail(3)) SWIG_fail;
45662 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45663 if (SWIG_arg_fail(4)) SWIG_fail;
45664 {
45665 PyThreadState* __tstate = wxPyBeginAllowThreads();
45666 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45667
45668 wxPyEndAllowThreads(__tstate);
45669 if (PyErr_Occurred()) SWIG_fail;
45670 }
45671 {
45672 resultobj = SWIG_From_int((int)(result));
45673 }
45674 return resultobj;
45675 fail:
45676 return NULL;
45677 }
45678
45679
45680 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45681 PyObject *obj;
45682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45683 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45684 Py_INCREF(obj);
45685 return Py_BuildValue((char *)"");
45686 }
45687 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45688 PyObject *resultobj;
45689 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45690 wxIndividualLayoutConstraint *result;
45691 PyObject * obj0 = 0 ;
45692 char *kwnames[] = {
45693 (char *) "self", NULL
45694 };
45695
45696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45698 if (SWIG_arg_fail(1)) SWIG_fail;
45699 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45700
45701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45702 return resultobj;
45703 fail:
45704 return NULL;
45705 }
45706
45707
45708 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45709 PyObject *resultobj;
45710 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45711 wxIndividualLayoutConstraint *result;
45712 PyObject * obj0 = 0 ;
45713 char *kwnames[] = {
45714 (char *) "self", NULL
45715 };
45716
45717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45719 if (SWIG_arg_fail(1)) SWIG_fail;
45720 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45721
45722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45723 return resultobj;
45724 fail:
45725 return NULL;
45726 }
45727
45728
45729 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45730 PyObject *resultobj;
45731 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45732 wxIndividualLayoutConstraint *result;
45733 PyObject * obj0 = 0 ;
45734 char *kwnames[] = {
45735 (char *) "self", NULL
45736 };
45737
45738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45740 if (SWIG_arg_fail(1)) SWIG_fail;
45741 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45742
45743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45744 return resultobj;
45745 fail:
45746 return NULL;
45747 }
45748
45749
45750 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45751 PyObject *resultobj;
45752 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45753 wxIndividualLayoutConstraint *result;
45754 PyObject * obj0 = 0 ;
45755 char *kwnames[] = {
45756 (char *) "self", NULL
45757 };
45758
45759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45761 if (SWIG_arg_fail(1)) SWIG_fail;
45762 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45763
45764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45765 return resultobj;
45766 fail:
45767 return NULL;
45768 }
45769
45770
45771 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45772 PyObject *resultobj;
45773 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45774 wxIndividualLayoutConstraint *result;
45775 PyObject * obj0 = 0 ;
45776 char *kwnames[] = {
45777 (char *) "self", NULL
45778 };
45779
45780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45782 if (SWIG_arg_fail(1)) SWIG_fail;
45783 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45784
45785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45786 return resultobj;
45787 fail:
45788 return NULL;
45789 }
45790
45791
45792 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45793 PyObject *resultobj;
45794 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45795 wxIndividualLayoutConstraint *result;
45796 PyObject * obj0 = 0 ;
45797 char *kwnames[] = {
45798 (char *) "self", NULL
45799 };
45800
45801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45803 if (SWIG_arg_fail(1)) SWIG_fail;
45804 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45805
45806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45807 return resultobj;
45808 fail:
45809 return NULL;
45810 }
45811
45812
45813 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45814 PyObject *resultobj;
45815 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45816 wxIndividualLayoutConstraint *result;
45817 PyObject * obj0 = 0 ;
45818 char *kwnames[] = {
45819 (char *) "self", NULL
45820 };
45821
45822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45824 if (SWIG_arg_fail(1)) SWIG_fail;
45825 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45826
45827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45828 return resultobj;
45829 fail:
45830 return NULL;
45831 }
45832
45833
45834 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45835 PyObject *resultobj;
45836 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45837 wxIndividualLayoutConstraint *result;
45838 PyObject * obj0 = 0 ;
45839 char *kwnames[] = {
45840 (char *) "self", NULL
45841 };
45842
45843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45845 if (SWIG_arg_fail(1)) SWIG_fail;
45846 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45847
45848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45849 return resultobj;
45850 fail:
45851 return NULL;
45852 }
45853
45854
45855 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45856 PyObject *resultobj;
45857 wxLayoutConstraints *result;
45858 char *kwnames[] = {
45859 NULL
45860 };
45861
45862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45863 {
45864 PyThreadState* __tstate = wxPyBeginAllowThreads();
45865 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45866
45867 wxPyEndAllowThreads(__tstate);
45868 if (PyErr_Occurred()) SWIG_fail;
45869 }
45870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45871 return resultobj;
45872 fail:
45873 return NULL;
45874 }
45875
45876
45877 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45878 PyObject *resultobj;
45879 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45880 wxWindow *arg2 = (wxWindow *) 0 ;
45881 int *arg3 = (int *) 0 ;
45882 bool result;
45883 int temp3 ;
45884 int res3 = 0 ;
45885 PyObject * obj0 = 0 ;
45886 PyObject * obj1 = 0 ;
45887 char *kwnames[] = {
45888 (char *) "self",(char *) "win", NULL
45889 };
45890
45891 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45894 if (SWIG_arg_fail(1)) SWIG_fail;
45895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45896 if (SWIG_arg_fail(2)) SWIG_fail;
45897 {
45898 PyThreadState* __tstate = wxPyBeginAllowThreads();
45899 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45900
45901 wxPyEndAllowThreads(__tstate);
45902 if (PyErr_Occurred()) SWIG_fail;
45903 }
45904 {
45905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45906 }
45907 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45908 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45909 return resultobj;
45910 fail:
45911 return NULL;
45912 }
45913
45914
45915 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45916 PyObject *resultobj;
45917 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45918 bool result;
45919 PyObject * obj0 = 0 ;
45920 char *kwnames[] = {
45921 (char *) "self", NULL
45922 };
45923
45924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45926 if (SWIG_arg_fail(1)) SWIG_fail;
45927 {
45928 PyThreadState* __tstate = wxPyBeginAllowThreads();
45929 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45930
45931 wxPyEndAllowThreads(__tstate);
45932 if (PyErr_Occurred()) SWIG_fail;
45933 }
45934 {
45935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45936 }
45937 return resultobj;
45938 fail:
45939 return NULL;
45940 }
45941
45942
45943 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45944 PyObject *obj;
45945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45946 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45947 Py_INCREF(obj);
45948 return Py_BuildValue((char *)"");
45949 }
45950 static PyMethodDef SwigMethods[] = {
45951 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45952 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45953 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45956 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45977 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45990 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46005 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46059 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46087 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46106 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46108 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46116 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46117 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46129 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46141 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46145 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46151 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46161 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46171 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46174 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46181 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46189 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46197 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46280 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46282 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46284 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46286 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46288 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46290 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46292 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46294 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46296 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46298 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46300 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46302 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46304 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46318 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46336 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46339 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46342 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46354 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46359 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46365 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46371 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46434 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46441 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46477 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46487 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46493 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46495 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46497 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46500 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46504 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46507 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46510 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46512 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46517 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46525 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46529 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46532 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46534 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46538 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46555 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46557 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46560 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46562 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46566 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46570 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46581 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46584 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46587 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46591 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46598 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46603 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46608 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46612 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46657 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46677 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46684 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46688 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46698 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46758 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46849 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46869 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46911 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46926 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46929 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46984 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47013 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47057 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47065 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47084 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47085 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47122 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47152 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47155 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47159 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47162 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47172 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47184 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47196 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47206 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47216 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47230 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47237 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47238 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47239 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47240 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47241 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47246 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47273 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47285 { NULL, NULL, 0, NULL }
47286 };
47287
47288
47289 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47290
47291 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47292 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47293 }
47294 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47295 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47296 }
47297 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47298 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47299 }
47300 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47301 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47302 }
47303 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47304 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47305 }
47306 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47307 return (void *)((wxSizer *) ((wxGridSizer *) x));
47308 }
47309 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47310 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47311 }
47312 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47313 return (void *)((wxSizer *) ((wxPySizer *) x));
47314 }
47315 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47316 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47317 }
47318 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47319 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47320 }
47321 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47322 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47323 }
47324 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47325 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47326 }
47327 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47328 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47329 }
47330 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47331 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47332 }
47333 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47334 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47335 }
47336 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47337 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47338 }
47339 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47340 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47341 }
47342 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47343 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47344 }
47345 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47346 return (void *)((wxEvent *) ((wxPyEvent *) x));
47347 }
47348 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47349 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47350 }
47351 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47352 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47353 }
47354 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47355 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47356 }
47357 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47358 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47359 }
47360 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47361 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47362 }
47363 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47364 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47365 }
47366 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47367 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47368 }
47369 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47370 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47371 }
47372 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47373 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47374 }
47375 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47376 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47377 }
47378 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47379 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47380 }
47381 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47382 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47383 }
47384 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47385 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47386 }
47387 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47388 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47389 }
47390 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47391 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47392 }
47393 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47394 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47395 }
47396 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47397 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47398 }
47399 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47400 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47401 }
47402 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47403 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47404 }
47405 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47406 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47407 }
47408 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47409 return (void *)((wxEvent *) ((wxShowEvent *) x));
47410 }
47411 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47412 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47413 }
47414 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47415 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47416 }
47417 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47418 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47419 }
47420 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47421 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47422 }
47423 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47424 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47425 }
47426 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47427 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47428 }
47429 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47430 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47431 }
47432 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47433 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47434 }
47435 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47436 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47437 }
47438 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47439 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47440 }
47441 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47442 return (void *)((wxControl *) ((wxControlWithItems *) x));
47443 }
47444 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47445 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47446 }
47447 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47448 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47449 }
47450 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47451 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47452 }
47453 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47454 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47455 }
47456 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47457 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47458 }
47459 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47460 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47461 }
47462 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47463 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47464 }
47465 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47466 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47467 }
47468 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47469 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47470 }
47471 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47472 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47473 }
47474 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47475 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47476 }
47477 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47478 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47479 }
47480 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47481 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47482 }
47483 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47484 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47485 }
47486 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47487 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47488 }
47489 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47490 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47491 }
47492 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47493 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47494 }
47495 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47496 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47497 }
47498 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47499 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47500 }
47501 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47502 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47503 }
47504 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47505 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47506 }
47507 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47508 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47509 }
47510 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47511 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47512 }
47513 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47514 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47515 }
47516 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47517 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47518 }
47519 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47520 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47521 }
47522 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47523 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47524 }
47525 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47526 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47527 }
47528 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47529 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47530 }
47531 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47532 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47533 }
47534 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47535 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47536 }
47537 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47538 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47539 }
47540 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47541 return (void *)((wxObject *) ((wxSizerItem *) x));
47542 }
47543 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47544 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47545 }
47546 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47547 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47548 }
47549 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47550 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47551 }
47552 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47553 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47554 }
47555 static void *_p_wxSizerTo_p_wxObject(void *x) {
47556 return (void *)((wxObject *) ((wxSizer *) x));
47557 }
47558 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47559 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47560 }
47561 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47562 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47563 }
47564 static void *_p_wxEventTo_p_wxObject(void *x) {
47565 return (void *)((wxObject *) ((wxEvent *) x));
47566 }
47567 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47568 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47569 }
47570 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47571 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47572 }
47573 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47574 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47575 }
47576 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47577 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47578 }
47579 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47580 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47581 }
47582 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47583 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47584 }
47585 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47586 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47587 }
47588 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47589 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47590 }
47591 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47592 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47593 }
47594 static void *_p_wxControlTo_p_wxObject(void *x) {
47595 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47596 }
47597 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47598 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47599 }
47600 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47601 return (void *)((wxObject *) ((wxFSFile *) x));
47602 }
47603 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47604 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47605 }
47606 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47607 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47608 }
47609 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47610 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47611 }
47612 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47613 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47614 }
47615 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47616 return (void *)((wxObject *) ((wxMenuItem *) x));
47617 }
47618 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47619 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47620 }
47621 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47622 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47623 }
47624 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47625 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47626 }
47627 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47628 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47629 }
47630 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47631 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47632 }
47633 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47634 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47635 }
47636 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47637 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47638 }
47639 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47640 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47641 }
47642 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47643 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47644 }
47645 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47646 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47647 }
47648 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47649 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47650 }
47651 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47652 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47653 }
47654 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47655 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47656 }
47657 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47658 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47659 }
47660 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47661 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47662 }
47663 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47664 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47665 }
47666 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47667 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47668 }
47669 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47670 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47671 }
47672 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
47673 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
47674 }
47675 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47676 return (void *)((wxObject *) ((wxImageHandler *) x));
47677 }
47678 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47679 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47680 }
47681 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47682 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47683 }
47684 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47685 return (void *)((wxObject *) ((wxEvtHandler *) x));
47686 }
47687 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47688 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47689 }
47690 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47691 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47692 }
47693 static void *_p_wxImageTo_p_wxObject(void *x) {
47694 return (void *)((wxObject *) ((wxImage *) x));
47695 }
47696 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47697 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47698 }
47699 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47700 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47701 }
47702 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47703 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47704 }
47705 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47706 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47707 }
47708 static void *_p_wxWindowTo_p_wxObject(void *x) {
47709 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47710 }
47711 static void *_p_wxMenuTo_p_wxObject(void *x) {
47712 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47713 }
47714 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47715 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47716 }
47717 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47718 return (void *)((wxObject *) ((wxFileSystem *) x));
47719 }
47720 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47721 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47722 }
47723 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47724 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47725 }
47726 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47727 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47728 }
47729 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47730 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47731 }
47732 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47733 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47734 }
47735 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47736 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47737 }
47738 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47739 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47740 }
47741 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47742 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47743 }
47744 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47745 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47746 }
47747 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47748 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47749 }
47750 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47751 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47752 }
47753 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47754 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47755 }
47756 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47757 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47758 }
47759 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47760 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47761 }
47762 static void *_p_wxControlTo_p_wxWindow(void *x) {
47763 return (void *)((wxWindow *) ((wxControl *) x));
47764 }
47765 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47766 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47767 }
47768 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47769 return (void *)((wxWindow *) ((wxMenuBar *) x));
47770 }
47771 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47772 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47773 }
47774 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47775 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47776 }
47777 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47778 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47779 }
47780 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47781 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47782 }
47783 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47784 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47785 }
47786 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47787 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47788 }
47789 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47790 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47791 }
47792 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47793 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47794 }
47795 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47796 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47797 }
47798 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47799 return (void *)((wxValidator *) ((wxPyValidator *) x));
47800 }
47801 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}};
47802 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}};
47803 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}};
47804 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}};
47805 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}};
47806 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}};
47807 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}};
47808 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}};
47809 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}};
47810 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}};
47811 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}};
47812 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}};
47813 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}};
47814 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}};
47815 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}};
47816 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}};
47817 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}};
47818 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}};
47819 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}};
47820 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}};
47821 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}};
47822 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}};
47823 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}};
47824 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}};
47825 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}};
47826 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}};
47827 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}};
47828 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}};
47829 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}};
47830 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}};
47831 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}};
47832 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}};
47833 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}};
47834 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}};
47835 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}};
47836 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}};
47837 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}};
47838 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}};
47839 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}};
47840 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}};
47841 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}};
47842 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}};
47843 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}};
47844 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}};
47845 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}};
47846 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}};
47847 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}};
47848 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}};
47849 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}};
47850 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}};
47851 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}};
47852 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}};
47853 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}};
47854 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}};
47855 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}};
47856 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}};
47857 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}};
47858 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}};
47859 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}};
47860 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}};
47861 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}};
47862 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}};
47863 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}};
47864 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}};
47865 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}};
47866 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}};
47867 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}};
47868 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}};
47869 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}};
47870 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}};
47871 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}};
47872 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}};
47873 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}};
47874 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}};
47875 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}};
47876 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}};
47877 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}};
47878 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}};
47879 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}};
47880 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}};
47881 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}};
47882 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}};
47883 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}};
47884 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}};
47885 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}};
47886 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}};
47887 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}};
47888 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}};
47889 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}};
47890 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}};
47891 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}};
47892 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}};
47893 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}};
47894 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}};
47895 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}};
47896 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}};
47897 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}};
47898 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}};
47899 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}};
47900 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}};
47901 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}};
47902 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}};
47903 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}};
47904 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}};
47905 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}};
47906 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}};
47907 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}};
47908 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}};
47909 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}};
47910 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}};
47911 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}};
47912 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}};
47913 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}};
47914 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}};
47915 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}};
47916 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}};
47917 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}};
47918 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}};
47919 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}};
47920 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}};
47921 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}};
47922 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}};
47923 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}};
47924 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}};
47925 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}};
47926 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}};
47927 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}};
47928 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}};
47929 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}};
47930 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}};
47931 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}};
47932
47933 static swig_type_info *swig_types_initial[] = {
47934 _swigt__p_wxLayoutConstraints,
47935 _swigt__p_wxRealPoint,
47936 _swigt__p_wxSizerItem,
47937 _swigt__p_wxGBSizerItem,
47938 _swigt__p_wxScrollEvent,
47939 _swigt__p_wxEventLoop,
47940 _swigt__p_wxIndividualLayoutConstraint,
47941 _swigt__p_wxSizer,
47942 _swigt__p_wxBoxSizer,
47943 _swigt__p_wxStaticBoxSizer,
47944 _swigt__p_wxGridBagSizer,
47945 _swigt__p_wxAcceleratorEntry,
47946 _swigt__p_wxUpdateUIEvent,
47947 _swigt__p_wxEvent,
47948 _swigt__p_buffer,
47949 _swigt__p_wxMenu,
47950 _swigt__p_wxGridSizer,
47951 _swigt__p_wxFlexGridSizer,
47952 _swigt__p_wxInitDialogEvent,
47953 _swigt__p_wxItemContainer,
47954 _swigt__p_wxPaintEvent,
47955 _swigt__p_wxNcPaintEvent,
47956 _swigt__p_wxSysColourChangedEvent,
47957 _swigt__p_wxMouseCaptureChangedEvent,
47958 _swigt__p_wxDisplayChangedEvent,
47959 _swigt__p_wxPaletteChangedEvent,
47960 _swigt__p_wxControl,
47961 _swigt__p_wxFont,
47962 _swigt__p_wxMenuBarBase,
47963 _swigt__p_wxSetCursorEvent,
47964 _swigt__p_wxFSFile,
47965 _swigt__p_wxCaret,
47966 _swigt__ptrdiff_t,
47967 _swigt__std__ptrdiff_t,
47968 _swigt__p_wxRegion,
47969 _swigt__p_wxPoint2D,
47970 _swigt__p_wxImage_HSVValue,
47971 _swigt__p_int,
47972 _swigt__p_wxSize,
47973 _swigt__p_wxDC,
47974 _swigt__p_wxPySizer,
47975 _swigt__p_wxVisualAttributes,
47976 _swigt__p_wxImage_RGBValue,
47977 _swigt__p_wxNotifyEvent,
47978 _swigt__p_wxPyEvent,
47979 _swigt__p_wxPropagationDisabler,
47980 _swigt__p_form_ops_t,
47981 _swigt__p_wxAppTraits,
47982 _swigt__p_wxArrayString,
47983 _swigt__p_wxShowEvent,
47984 _swigt__p_wxToolTip,
47985 _swigt__p_wxMoveEvent,
47986 _swigt__p_wxSizeEvent,
47987 _swigt__p_wxActivateEvent,
47988 _swigt__p_wxIconizeEvent,
47989 _swigt__p_wxMaximizeEvent,
47990 _swigt__p_wxQueryNewPaletteEvent,
47991 _swigt__p_wxWindowCreateEvent,
47992 _swigt__p_wxIdleEvent,
47993 _swigt__p_wxDateEvent,
47994 _swigt__p_wxMenuItem,
47995 _swigt__p_wxStaticBox,
47996 _swigt__p_long,
47997 _swigt__p_wxDuplexMode,
47998 _swigt__p_wxTIFFHandler,
47999 _swigt__p_wxXPMHandler,
48000 _swigt__p_wxPNMHandler,
48001 _swigt__p_wxJPEGHandler,
48002 _swigt__p_wxPCXHandler,
48003 _swigt__p_wxGIFHandler,
48004 _swigt__p_wxPNGHandler,
48005 _swigt__p_wxANIHandler,
48006 _swigt__p_wxPyImageHandler,
48007 _swigt__p_wxMemoryFSHandler,
48008 _swigt__p_wxZipFSHandler,
48009 _swigt__p_wxInternetFSHandler,
48010 _swigt__p_wxPyFileSystemHandler,
48011 _swigt__p_wxEvtHandler,
48012 _swigt__p_wxCURHandler,
48013 _swigt__p_wxICOHandler,
48014 _swigt__p_wxBMPHandler,
48015 _swigt__p_wxImageHandler,
48016 _swigt__p_wxFileSystemHandler,
48017 _swigt__p_wxRect,
48018 _swigt__p_wxButton,
48019 _swigt__p_wxGBSpan,
48020 _swigt__p_wxPropagateOnce,
48021 _swigt__p_wxAcceleratorTable,
48022 _swigt__p_wxStdDialogButtonSizer,
48023 _swigt__p_char,
48024 _swigt__p_wxGBPosition,
48025 _swigt__p_wxImage,
48026 _swigt__p_wxFrame,
48027 _swigt__p_wxScrollWinEvent,
48028 _swigt__p_wxPaperSize,
48029 _swigt__p_wxImageHistogram,
48030 _swigt__p_wxPoint,
48031 _swigt__p_wxCursor,
48032 _swigt__p_wxObject,
48033 _swigt__p_wxInputStream,
48034 _swigt__p_wxOutputStream,
48035 _swigt__p_wxPyInputStream,
48036 _swigt__p_wxDateTime,
48037 _swigt__p_wxKeyEvent,
48038 _swigt__p_wxNavigationKeyEvent,
48039 _swigt__p_wxWindowDestroyEvent,
48040 _swigt__p_unsigned_long,
48041 _swigt__p_wxWindow,
48042 _swigt__p_wxMenuBar,
48043 _swigt__p_wxFileSystem,
48044 _swigt__p_wxBitmap,
48045 _swigt__unsigned_int,
48046 _swigt__p_unsigned_int,
48047 _swigt__p_wxMenuEvent,
48048 _swigt__p_wxContextMenuEvent,
48049 _swigt__p_unsigned_char,
48050 _swigt__p_wxMouseEvent,
48051 _swigt__p_wxEraseEvent,
48052 _swigt__p_wxCloseEvent,
48053 _swigt__p_wxPyApp,
48054 _swigt__p_wxCommandEvent,
48055 _swigt__p_wxPyCommandEvent,
48056 _swigt__p_wxPyDropTarget,
48057 _swigt__p_wxQuantize,
48058 _swigt__p_wxFocusEvent,
48059 _swigt__p_wxChildFocusEvent,
48060 _swigt__p_wxDropFilesEvent,
48061 _swigt__p_wxControlWithItems,
48062 _swigt__p_wxColour,
48063 _swigt__p_wxValidator,
48064 _swigt__p_wxPyValidator,
48065 0
48066 };
48067
48068
48069 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48070
48071 static swig_const_info swig_const_table[] = {
48072 {0, 0, 0, 0.0, 0, 0}};
48073
48074 #ifdef __cplusplus
48075 }
48076 #endif
48077
48078
48079 #ifdef __cplusplus
48080 extern "C" {
48081 #endif
48082
48083 /* Python-specific SWIG API */
48084 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48085 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48086 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48087
48088 /* -----------------------------------------------------------------------------
48089 * global variable support code.
48090 * ----------------------------------------------------------------------------- */
48091
48092 typedef struct swig_globalvar {
48093 char *name; /* Name of global variable */
48094 PyObject *(*get_attr)(); /* Return the current value */
48095 int (*set_attr)(PyObject *); /* Set the value */
48096 struct swig_globalvar *next;
48097 } swig_globalvar;
48098
48099 typedef struct swig_varlinkobject {
48100 PyObject_HEAD
48101 swig_globalvar *vars;
48102 } swig_varlinkobject;
48103
48104 static PyObject *
48105 swig_varlink_repr(swig_varlinkobject *v) {
48106 v = v;
48107 return PyString_FromString("<Swig global variables>");
48108 }
48109
48110 static int
48111 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48112 swig_globalvar *var;
48113 flags = flags;
48114 fprintf(fp,"Swig global variables { ");
48115 for (var = v->vars; var; var=var->next) {
48116 fprintf(fp,"%s", var->name);
48117 if (var->next) fprintf(fp,", ");
48118 }
48119 fprintf(fp," }\n");
48120 return 0;
48121 }
48122
48123 static PyObject *
48124 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48125 swig_globalvar *var = v->vars;
48126 while (var) {
48127 if (strcmp(var->name,n) == 0) {
48128 return (*var->get_attr)();
48129 }
48130 var = var->next;
48131 }
48132 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48133 return NULL;
48134 }
48135
48136 static int
48137 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48138 swig_globalvar *var = v->vars;
48139 while (var) {
48140 if (strcmp(var->name,n) == 0) {
48141 return (*var->set_attr)(p);
48142 }
48143 var = var->next;
48144 }
48145 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48146 return 1;
48147 }
48148
48149 static PyTypeObject varlinktype = {
48150 PyObject_HEAD_INIT(0)
48151 0, /* Number of items in variable part (ob_size) */
48152 (char *)"swigvarlink", /* Type name (tp_name) */
48153 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
48154 0, /* Itemsize (tp_itemsize) */
48155 0, /* Deallocator (tp_dealloc) */
48156 (printfunc) swig_varlink_print, /* Print (tp_print) */
48157 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
48158 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
48159 0, /* tp_compare */
48160 (reprfunc) swig_varlink_repr, /* tp_repr */
48161 0, /* tp_as_number */
48162 0, /* tp_as_sequence */
48163 0, /* tp_as_mapping */
48164 0, /* tp_hash */
48165 0, /* tp_call */
48166 0, /* tp_str */
48167 0, /* tp_getattro */
48168 0, /* tp_setattro */
48169 0, /* tp_as_buffer */
48170 0, /* tp_flags */
48171 0, /* tp_doc */
48172 #if PY_VERSION_HEX >= 0x02000000
48173 0, /* tp_traverse */
48174 0, /* tp_clear */
48175 #endif
48176 #if PY_VERSION_HEX >= 0x02010000
48177 0, /* tp_richcompare */
48178 0, /* tp_weaklistoffset */
48179 #endif
48180 #if PY_VERSION_HEX >= 0x02020000
48181 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
48182 #endif
48183 #if PY_VERSION_HEX >= 0x02030000
48184 0, /* tp_del */
48185 #endif
48186 #ifdef COUNT_ALLOCS
48187 0,0,0,0 /* tp_alloc -> tp_next */
48188 #endif
48189 };
48190
48191 /* Create a variable linking object for use later */
48192 static PyObject *
48193 SWIG_Python_newvarlink(void) {
48194 swig_varlinkobject *result = 0;
48195 result = PyMem_NEW(swig_varlinkobject,1);
48196 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
48197 result->ob_type = &varlinktype;
48198 result->vars = 0;
48199 result->ob_refcnt = 0;
48200 Py_XINCREF((PyObject *) result);
48201 return ((PyObject*) result);
48202 }
48203
48204 static void
48205 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
48206 swig_varlinkobject *v;
48207 swig_globalvar *gv;
48208 v= (swig_varlinkobject *) p;
48209 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
48210 gv->name = (char *) malloc(strlen(name)+1);
48211 strcpy(gv->name,name);
48212 gv->get_attr = get_attr;
48213 gv->set_attr = set_attr;
48214 gv->next = v->vars;
48215 v->vars = gv;
48216 }
48217
48218 /* -----------------------------------------------------------------------------
48219 * constants/methods manipulation
48220 * ----------------------------------------------------------------------------- */
48221
48222 /* Install Constants */
48223 static void
48224 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
48225 PyObject *obj = 0;
48226 size_t i;
48227 for (i = 0; constants[i].type; i++) {
48228 switch(constants[i].type) {
48229 case SWIG_PY_INT:
48230 obj = PyInt_FromLong(constants[i].lvalue);
48231 break;
48232 case SWIG_PY_FLOAT:
48233 obj = PyFloat_FromDouble(constants[i].dvalue);
48234 break;
48235 case SWIG_PY_STRING:
48236 if (constants[i].pvalue) {
48237 obj = PyString_FromString((char *) constants[i].pvalue);
48238 } else {
48239 Py_INCREF(Py_None);
48240 obj = Py_None;
48241 }
48242 break;
48243 case SWIG_PY_POINTER:
48244 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
48245 break;
48246 case SWIG_PY_BINARY:
48247 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
48248 break;
48249 default:
48250 obj = 0;
48251 break;
48252 }
48253 if (obj) {
48254 PyDict_SetItemString(d,constants[i].name,obj);
48255 Py_DECREF(obj);
48256 }
48257 }
48258 }
48259
48260 /* -----------------------------------------------------------------------------*/
48261 /* Fix SwigMethods to carry the callback ptrs when needed */
48262 /* -----------------------------------------------------------------------------*/
48263
48264 static void
48265 SWIG_Python_FixMethods(PyMethodDef *methods,
48266 swig_const_info *const_table,
48267 swig_type_info **types,
48268 swig_type_info **types_initial) {
48269 size_t i;
48270 for (i = 0; methods[i].ml_name; ++i) {
48271 char *c = methods[i].ml_doc;
48272 if (c && (c = strstr(c, "swig_ptr: "))) {
48273 int j;
48274 swig_const_info *ci = 0;
48275 char *name = c + 10;
48276 for (j = 0; const_table[j].type; j++) {
48277 if (strncmp(const_table[j].name, name,
48278 strlen(const_table[j].name)) == 0) {
48279 ci = &(const_table[j]);
48280 break;
48281 }
48282 }
48283 if (ci) {
48284 size_t shift = (ci->ptype) - types;
48285 swig_type_info *ty = types_initial[shift];
48286 size_t ldoc = (c - methods[i].ml_doc);
48287 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
48288 char *ndoc = (char*)malloc(ldoc + lptr + 10);
48289 char *buff = ndoc;
48290 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
48291 strncpy(buff, methods[i].ml_doc, ldoc);
48292 buff += ldoc;
48293 strncpy(buff, "swig_ptr: ", 10);
48294 buff += 10;
48295 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
48296 methods[i].ml_doc = ndoc;
48297 }
48298 }
48299 }
48300 }
48301
48302 /* -----------------------------------------------------------------------------*
48303 * Initialize type list
48304 * -----------------------------------------------------------------------------*/
48305
48306 #if PY_MAJOR_VERSION < 2
48307 /* PyModule_AddObject function was introduced in Python 2.0. The following function
48308 is copied out of Python/modsupport.c in python version 2.3.4 */
48309 static int
48310 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
48311 {
48312 PyObject *dict;
48313 if (!PyModule_Check(m)) {
48314 PyErr_SetString(PyExc_TypeError,
48315 "PyModule_AddObject() needs module as first arg");
48316 return -1;
48317 }
48318 if (!o) {
48319 PyErr_SetString(PyExc_TypeError,
48320 "PyModule_AddObject() needs non-NULL value");
48321 return -1;
48322 }
48323
48324 dict = PyModule_GetDict(m);
48325 if (dict == NULL) {
48326 /* Internal error -- modules must have a dict! */
48327 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
48328 PyModule_GetName(m));
48329 return -1;
48330 }
48331 if (PyDict_SetItemString(dict, name, o))
48332 return -1;
48333 Py_DECREF(o);
48334 return 0;
48335 }
48336 #endif
48337
48338 static swig_type_info **
48339 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
48340 static PyMethodDef swig_empty_runtime_method_table[] = {
48341 {
48342 NULL, NULL, 0, NULL
48343 }
48344 };/* Sentinel */
48345
48346 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
48347 swig_empty_runtime_method_table);
48348 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
48349 if (pointer && module) {
48350 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
48351 }
48352 return type_list_handle;
48353 }
48354
48355 static swig_type_info **
48356 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
48357 swig_type_info **type_pointer;
48358
48359 /* first check if module already created */
48360 type_pointer = SWIG_Python_GetTypeListHandle();
48361 if (type_pointer) {
48362 return type_pointer;
48363 } else {
48364 /* create a new module and variable */
48365 return SWIG_Python_SetTypeListHandle(type_list_handle);
48366 }
48367 }
48368
48369 #ifdef __cplusplus
48370 }
48371 #endif
48372
48373 /* -----------------------------------------------------------------------------*
48374 * Partial Init method
48375 * -----------------------------------------------------------------------------*/
48376
48377 #ifdef SWIG_LINK_RUNTIME
48378 #ifdef __cplusplus
48379 extern "C"
48380 #endif
48381 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
48382 #endif
48383
48384 #ifdef __cplusplus
48385 extern "C"
48386 #endif
48387 SWIGEXPORT(void) SWIG_init(void) {
48388 static PyObject *SWIG_globals = 0;
48389 static int typeinit = 0;
48390 PyObject *m, *d;
48391 int i;
48392 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
48393
48394 /* Fix SwigMethods to carry the callback ptrs when needed */
48395 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
48396
48397 m = Py_InitModule((char *) SWIG_name, SwigMethods);
48398 d = PyModule_GetDict(m);
48399
48400 if (!typeinit) {
48401 #ifdef SWIG_LINK_RUNTIME
48402 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
48403 #else
48404 # ifndef SWIG_STATIC_RUNTIME
48405 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
48406 # endif
48407 #endif
48408 for (i = 0; swig_types_initial[i]; i++) {
48409 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
48410 }
48411 typeinit = 1;
48412 }
48413 SWIG_InstallConstants(d,swig_const_table);
48414
48415
48416 #ifndef wxPyUSE_EXPORT
48417 // Make our API structure a CObject so other modules can import it
48418 // from this module.
48419 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
48420 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
48421 Py_XDECREF(cobj);
48422 #endif
48423
48424 {
48425 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int((int)(wxSIZE_FORCE)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int((int)(wxID_NONE)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
49482 }
49483 {
49484 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
49485 }
49486 {
49487 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
49488 }
49489 {
49490 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
49491 }
49492 {
49493 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
49494 }
49495 {
49496 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
49497 }
49498 {
49499 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
49539 }
49540 {
49541 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
49542 }
49543 {
49544 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
49545 }
49546 {
49547 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
49548 }
49549 {
49550 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
49551 }
49552 {
49553 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
49554 }
49555 {
49556 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
49557 }
49558 {
49559 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
49560 }
49561 {
49562 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
49563 }
49564 {
49565 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
49566 }
49567 {
49568 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
49569 }
49570 {
49571 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
49572 }
49573 {
49574 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
49575 }
49576 {
49577 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
49578 }
49579 {
49580 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
49581 }
49582 {
49583 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
49584 }
49585 {
49586 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
49587 }
49588 {
49589 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
49590 }
49591 {
49592 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
49593 }
49594 {
49595 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
49596 }
49597 {
49598 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
49599 }
49600 {
49601 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
49602 }
49603 {
49604 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
49605 }
49606 {
49607 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
49608 }
49609 {
49610 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
49611 }
49612 {
49613 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
49614 }
49615 {
49616 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
49617 }
49618 {
49619 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
49620 }
49621 {
49622 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
49626 }
49627 {
49628 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
49629 }
49630 {
49631 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
49632 }
49633 {
49634 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
49635 }
49636 {
49637 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
49638 }
49639 {
49640 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
49641 }
49642 {
49643 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
49644 }
49645 {
49646 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49647 }
49648 {
49649 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49650 }
49651 {
49652 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49653 }
49654 {
49655 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49656 }
49657 {
49658 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49659 }
49660 {
49661 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49662 }
49663 {
49664 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49665 }
49666 {
49667 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49668 }
49669 {
49670 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49671 }
49672 {
49673 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49674 }
49675 {
49676 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49677 }
49678 {
49679 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49680 }
49681 {
49682 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49683 }
49684 {
49685 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49686 }
49687 {
49688 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49689 }
49690 {
49691 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49692 }
49693 {
49694 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49695 }
49696 {
49697 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49698 }
49699 {
49700 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49701 }
49702 {
49703 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49704 }
49705 {
49706 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49707 }
49708 {
49709 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49710 }
49711 {
49712 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49713 }
49714 {
49715 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49716 }
49717 {
49718 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49719 }
49720 {
49721 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49722 }
49723 {
49724 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49725 }
49726 {
49727 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49728 }
49729 {
49730 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49731 }
49732 {
49733 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49734 }
49735 {
49736 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49737 }
49738 {
49739 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49740 }
49741 {
49742 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49743 }
49744 {
49745 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49746 }
49747 {
49748 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49749 }
49750 {
49751 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49752 }
49753 {
49754 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49758 }
49759 {
49760 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49761 }
49762 {
49763 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49764 }
49765 {
49766 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49788 }
49789 {
49790 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49791 }
49792 {
49793 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49794 }
49795 {
49796 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49797 }
49798 {
49799 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49800 }
49801 {
49802 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49803 }
49804 {
49805 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49806 }
49807 {
49808 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49809 }
49810 {
49811 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49821 }
49822 {
49823 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49824 }
49825 {
49826 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49827 }
49828 {
49829 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49839 }
49840 {
49841 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49842 }
49843 {
49844 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49893 }
49894 {
49895 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49896 }
49897 {
49898 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49899 }
49900 {
49901 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49902 }
49903 {
49904 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49908 }
49909 {
49910 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49911 }
49912 {
49913 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49914 }
49915 {
49916 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49917 }
49918 {
49919 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49920 }
49921 {
49922 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49923 }
49924 {
49925 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49926 }
49927 {
49928 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49929 }
49930 {
49931 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49932 }
49933 {
49934 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49935 }
49936 {
49937 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49938 }
49939 {
49940 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49941 }
49942 {
49943 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49944 }
49945 {
49946 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49947 }
49948 {
49949 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49950 }
49951 {
49952 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49953 }
49954 {
49955 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49956 }
49957 {
49958 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49959 }
49960 {
49961 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49962 }
49963 {
49964 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49965 }
49966 {
49967 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49968 }
49969 {
49970 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49971 }
49972 {
49973 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49974 }
49975 {
49976 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49977 }
49978 {
49979 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49980 }
49981 {
49982 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49983 }
49984 {
49985 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49986 }
49987 {
49988 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49989 }
49990 {
49991 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49992 }
49993 {
49994 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49995 }
49996 {
49997 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49998 }
49999 {
50000 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD)));
50001 }
50002 {
50003 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int((int)(wxPAPER_A6)));
50004 }
50005 {
50006 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int((int)(wxPAPER_JENV_KAKU2)));
50007 }
50008 {
50009 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int((int)(wxPAPER_JENV_KAKU3)));
50010 }
50011 {
50012 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int((int)(wxPAPER_JENV_CHOU3)));
50013 }
50014 {
50015 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int((int)(wxPAPER_JENV_CHOU4)));
50016 }
50017 {
50018 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int((int)(wxPAPER_LETTER_ROTATED)));
50019 }
50020 {
50021 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int((int)(wxPAPER_A3_ROTATED)));
50022 }
50023 {
50024 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int((int)(wxPAPER_A4_ROTATED)));
50025 }
50026 {
50027 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int((int)(wxPAPER_A5_ROTATED)));
50028 }
50029 {
50030 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B4_JIS_ROTATED)));
50031 }
50032 {
50033 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B5_JIS_ROTATED)));
50034 }
50035 {
50036 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50037 }
50038 {
50039 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50040 }
50041 {
50042 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int((int)(wxPAPER_A6_ROTATED)));
50043 }
50044 {
50045 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU2_ROTATED)));
50046 }
50047 {
50048 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU3_ROTATED)));
50049 }
50050 {
50051 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU3_ROTATED)));
50052 }
50053 {
50054 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU4_ROTATED)));
50055 }
50056 {
50057 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int((int)(wxPAPER_B6_JIS)));
50058 }
50059 {
50060 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B6_JIS_ROTATED)));
50061 }
50062 {
50063 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int((int)(wxPAPER_12X11)));
50064 }
50065 {
50066 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int((int)(wxPAPER_JENV_YOU4)));
50067 }
50068 {
50069 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_YOU4_ROTATED)));
50070 }
50071 {
50072 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int((int)(wxPAPER_P16K)));
50073 }
50074 {
50075 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int((int)(wxPAPER_P32K)));
50076 }
50077 {
50078 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int((int)(wxPAPER_P32KBIG)));
50079 }
50080 {
50081 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int((int)(wxPAPER_PENV_1)));
50082 }
50083 {
50084 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int((int)(wxPAPER_PENV_2)));
50085 }
50086 {
50087 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int((int)(wxPAPER_PENV_3)));
50088 }
50089 {
50090 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int((int)(wxPAPER_PENV_4)));
50091 }
50092 {
50093 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int((int)(wxPAPER_PENV_5)));
50094 }
50095 {
50096 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int((int)(wxPAPER_PENV_6)));
50097 }
50098 {
50099 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int((int)(wxPAPER_PENV_7)));
50100 }
50101 {
50102 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int((int)(wxPAPER_PENV_8)));
50103 }
50104 {
50105 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int((int)(wxPAPER_PENV_9)));
50106 }
50107 {
50108 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int((int)(wxPAPER_PENV_10)));
50109 }
50110 {
50111 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int((int)(wxPAPER_P16K_ROTATED)));
50112 }
50113 {
50114 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int((int)(wxPAPER_P32K_ROTATED)));
50115 }
50116 {
50117 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int((int)(wxPAPER_P32KBIG_ROTATED)));
50118 }
50119 {
50120 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_1_ROTATED)));
50121 }
50122 {
50123 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_2_ROTATED)));
50124 }
50125 {
50126 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_3_ROTATED)));
50127 }
50128 {
50129 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_4_ROTATED)));
50130 }
50131 {
50132 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_5_ROTATED)));
50133 }
50134 {
50135 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_6_ROTATED)));
50136 }
50137 {
50138 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_7_ROTATED)));
50139 }
50140 {
50141 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_8_ROTATED)));
50142 }
50143 {
50144 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_9_ROTATED)));
50145 }
50146 {
50147 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_10_ROTATED)));
50148 }
50149 {
50150 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
50151 }
50152 {
50153 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
50154 }
50155 {
50156 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
50157 }
50158 {
50159 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
50160 }
50161 {
50162 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
50163 }
50164 {
50165 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
50166 }
50167 {
50168 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
50169 }
50170 {
50171 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
50172 }
50173 {
50174 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
50175 }
50176 {
50177 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
50178 }
50179 {
50180 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
50181 }
50182 {
50183 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
50184 }
50185 {
50186 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50187 }
50188 {
50189 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50190 }
50191 {
50192 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
50193 }
50194 {
50195 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
50196 }
50197 {
50198 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
50199 }
50200 {
50201 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
50202 }
50203 {
50204 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
50205 }
50206 {
50207 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
50208 }
50209 {
50210 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
50211 }
50212 {
50213 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
50214 }
50215 {
50216 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
50217 }
50218 {
50219 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
50220 }
50221 {
50222 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
50223 }
50224 {
50225 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
50226 }
50227 {
50228 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
50229 }
50230 {
50231 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int((int)(wxMOD_ALTGR)));
50232 }
50233 {
50234 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
50235 }
50236 {
50237 PyDict_SetItemString(d,"MOD_META", SWIG_From_int((int)(wxMOD_META)));
50238 }
50239 {
50240 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
50241 }
50242 {
50243 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int((int)(wxMOD_CMD)));
50244 }
50245 {
50246 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int((int)(wxMOD_ALL)));
50247 }
50248 {
50249 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
50250 }
50251 {
50252 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
50253 }
50254 {
50255 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
50256 }
50257 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
50258 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
50259 {
50260 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
50261 }
50262 {
50263 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
50264 }
50265 {
50266 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
50267 }
50268 {
50269 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
50270 }
50271 {
50272 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
50273 }
50274 {
50275 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
50276 }
50277 {
50278 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
50279 }
50280 {
50281 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
50282 }
50283 {
50284 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
50285 }
50286 {
50287 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
50288 }
50289 {
50290 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
50291 }
50292 {
50293 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
50294 }
50295 {
50296 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
50297 }
50298 {
50299 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
50300 }
50301 {
50302 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
50303 }
50304 {
50305 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
50306 }
50307 {
50308 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
50309 }
50310 {
50311 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
50312 }
50313 {
50314 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
50315 }
50316 {
50317 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
50318 }
50319 {
50320 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
50321 }
50322 {
50323 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
50324 }
50325 {
50326 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
50327 }
50328 {
50329 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
50330 }
50331 {
50332 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
50333 }
50334 {
50335 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
50336 }
50337 {
50338 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
50339 }
50340 {
50341 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
50342 }
50343 {
50344 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
50345 }
50346 {
50347 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
50348 }
50349 {
50350 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
50351 }
50352 {
50353 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
50354 }
50355 {
50356 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
50357 }
50358 {
50359 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
50360 }
50361 {
50362 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
50363 }
50364 {
50365 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
50366 }
50367 {
50368 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
50369 }
50370 {
50371 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
50372 }
50373 {
50374 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
50375 }
50376 {
50377 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
50378 }
50379 {
50380 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
50381 }
50382 {
50383 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
50384 }
50385 {
50386 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
50387 }
50388 {
50389 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
50390 }
50391 {
50392 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
50393 }
50394 {
50395 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
50396 }
50397 {
50398 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
50399 }
50400 {
50401 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
50402 }
50403 {
50404 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
50405 }
50406 {
50407 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
50408 }
50409 {
50410 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
50411 }
50412 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
50413 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
50414 {
50415 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
50416 }
50417 {
50418 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
50419 }
50420 {
50421 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
50422 }
50423
50424 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
50425
50426
50427 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
50428
50429 {
50430 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
50431 }
50432 {
50433 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
50434 }
50435 {
50436 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
50437 }
50438 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
50439 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
50440 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
50441 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
50442 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
50443 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
50444 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
50445 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
50446 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
50447 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
50448 {
50449 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
50450 }
50451 {
50452 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
50453 }
50454 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
50455 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
50456 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
50457 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
50458 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
50459 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
50460 {
50461 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
50462 }
50463 {
50464 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
50465 }
50466 {
50467 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
50468 }
50469 {
50470 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
50471 }
50472 {
50473 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
50474 }
50475 {
50476 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
50477 }
50478 {
50479 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
50480 }
50481 {
50482 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
50483 }
50484 {
50485 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
50486 }
50487 {
50488 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
50489 }
50490 {
50491 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
50492 }
50493 {
50494 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
50495 }
50496 {
50497 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
50498 }
50499 {
50500 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
50501 }
50502 {
50503 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
50504 }
50505 {
50506 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
50507 }
50508 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
50509 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
50510 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
50511 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
50512 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
50513 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
50514 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
50515 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
50516 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
50517 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
50518 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
50519 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
50520 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
50521 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
50522 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
50523 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
50524 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
50525 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
50526 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
50527 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
50528 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
50529 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
50530 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
50531 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
50532 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
50533 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
50534 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
50535 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
50536 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
50537 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
50538 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
50539 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
50540 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
50541 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
50542 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
50543 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
50544 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
50545 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
50546 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
50547 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
50548 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
50549 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
50550 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
50551 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
50552 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
50553 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
50554 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
50555 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
50556 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
50557 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
50558 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
50559 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
50560 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
50561 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
50562 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
50563 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
50564 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
50565 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
50566 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
50567 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
50568 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
50569 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
50570 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
50571 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
50572 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
50573 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
50574 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
50575 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
50576 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
50577 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
50578 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
50579 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
50580 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
50581 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
50582 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
50583 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
50584 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
50585 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
50586 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
50587 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
50588 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
50589 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
50590 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
50591 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
50592 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
50593 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
50594 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
50595 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
50596 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
50597 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
50598 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
50599 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
50600 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
50601 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
50602 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
50603 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
50604 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
50605 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
50606 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
50607 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
50608 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
50609 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
50610 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
50611 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
50612 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
50613 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
50614 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
50615 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
50616 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
50617 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
50618 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
50619 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
50620 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
50621 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
50622 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
50623 {
50624 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
50625 }
50626 {
50627 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
50628 }
50629 {
50630 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
50631 }
50632 {
50633 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
50634 }
50635 {
50636 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
50637 }
50638 {
50639 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
50640 }
50641 {
50642 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
50643 }
50644 {
50645 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
50646 }
50647 {
50648 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
50649 }
50650 {
50651 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
50652 }
50653 {
50654 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
50655 }
50656 {
50657 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
50658 }
50659 {
50660 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
50661 }
50662 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
50663 {
50664 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
50665 }
50666 {
50667 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
50668 }
50669 {
50670 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
50671 }
50672 {
50673 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
50674 }
50675 {
50676 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
50677 }
50678 {
50679 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
50680 }
50681 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
50682 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
50683 {
50684 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
50685 }
50686 {
50687 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
50688 }
50689 {
50690 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
50691 }
50692 {
50693 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
50694 }
50695 {
50696 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
50697 }
50698 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
50699 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
50700 {
50701 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
50702 }
50703 {
50704 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
50705 }
50706 {
50707 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
50708 }
50709 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
50710 {
50711 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
50712 }
50713 {
50714 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
50715 }
50716 {
50717 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
50718 }
50719 {
50720 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
50721 }
50722 {
50723 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
50724 }
50725 {
50726 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
50727 }
50728 {
50729 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
50730 }
50731 {
50732 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
50733 }
50734 {
50735 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
50736 }
50737 {
50738 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
50739 }
50740 {
50741 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
50742 }
50743 {
50744 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
50745 }
50746 {
50747 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
50748 }
50749 {
50750 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
50751 }
50752 {
50753 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
50754 }
50755 {
50756 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
50757 }
50758 {
50759 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
50760 }
50761 {
50762 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
50763 }
50764 {
50765 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
50766 }
50767
50768 // Initialize threading, some globals and such
50769 __wxPyPreStart(d);
50770
50771
50772 // Although these are defined in __version__ they need to be here too so
50773 // that an assert can be done to ensure that the wxPython and the wxWindows
50774 // versions match.
50775 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
50776 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
50777 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
50778
50779 }
50780
wxWidgets (Impactor)